void INSStaggeredVCStokesOperator::initializeOperatorState( const SAMRAIVectorReal<NDIM,double>& in, const SAMRAIVectorReal<NDIM,double>& /*out*/) { IBAMR_TIMER_START(t_initialize_operator_state); if (d_is_initialized) deallocateOperatorState(); d_x_scratch = in.cloneVector("INSStaggeredVCStokesOperator::x_scratch"); d_x_scratch->allocateVectorData(); typedef HierarchyGhostCellInterpolation::InterpolationTransactionComponent InterpolationTransactionComponent; InterpolationTransactionComponent U_scratch_component(d_x_scratch->getComponentDescriptorIndex(0), U_DATA_COARSEN_TYPE, BDRY_EXTRAP_TYPE, CONSISTENT_TYPE_2_BDRY); InterpolationTransactionComponent P_scratch_component(d_x_scratch->getComponentDescriptorIndex(1), P_DATA_COARSEN_TYPE, BDRY_EXTRAP_TYPE, CONSISTENT_TYPE_2_BDRY); InterpolationTransactionComponent mu_component(d_mu_data_idx, MU_DATA_COARSEN_TYPE, BDRY_EXTRAP_TYPE, CONSISTENT_TYPE_2_BDRY); std::vector<InterpolationTransactionComponent> U_P_MU_components(3); U_P_MU_components[0] = U_scratch_component; U_P_MU_components[1] = P_scratch_component; U_P_MU_components[2] = mu_component; d_U_P_MU_bdry_fill_op = new HierarchyGhostCellInterpolation(); d_U_P_MU_bdry_fill_op->initializeOperatorState(U_P_MU_components, d_x_scratch->getPatchHierarchy()); d_is_initialized = true; IBAMR_TIMER_STOP(t_initialize_operator_state); return; }// initializeOperatorState
StaggeredStokesOperator::~StaggeredStokesOperator() { deallocateOperatorState(); delete d_default_U_bc_coef; d_default_U_bc_coef = NULL; delete d_default_P_bc_coef; d_default_P_bc_coef = NULL; return; } // ~StaggeredStokesOperator
void INSStaggeredCenteredConvectiveOperator::initializeOperatorState( const SAMRAIVectorReal<NDIM, double>& in, const SAMRAIVectorReal<NDIM, double>& out) { IBAMR_TIMER_START(t_initialize_operator_state); if (d_is_initialized) deallocateOperatorState(); // Get the hierarchy configuration. d_hierarchy = in.getPatchHierarchy(); d_coarsest_ln = in.getCoarsestLevelNumber(); d_finest_ln = in.getFinestLevelNumber(); #if !defined(NDEBUG) TBOX_ASSERT(d_hierarchy == out.getPatchHierarchy()); TBOX_ASSERT(d_coarsest_ln == out.getCoarsestLevelNumber()); TBOX_ASSERT(d_finest_ln == out.getFinestLevelNumber()); #else NULL_USE(out); #endif // Setup the interpolation transaction information. typedef HierarchyGhostCellInterpolation::InterpolationTransactionComponent InterpolationTransactionComponent; d_transaction_comps.resize(1); d_transaction_comps[0] = InterpolationTransactionComponent(d_U_scratch_idx, in.getComponentDescriptorIndex(0), "CONSERVATIVE_LINEAR_REFINE", false, "CONSERVATIVE_COARSEN", d_bdry_extrap_type, false, d_bc_coefs); // Initialize the interpolation operators. d_hier_bdry_fill = new HierarchyGhostCellInterpolation(); d_hier_bdry_fill->initializeOperatorState(d_transaction_comps, d_hierarchy); // Initialize the BC helper. d_bc_helper = new StaggeredStokesPhysicalBoundaryHelper(); d_bc_helper->cacheBcCoefData(d_bc_coefs, d_solution_time, d_hierarchy); // Allocate scratch data. for (int ln = d_coarsest_ln; ln <= d_finest_ln; ++ln) { Pointer<PatchLevel<NDIM> > level = d_hierarchy->getPatchLevel(ln); if (!level->checkAllocated(d_U_scratch_idx)) { level->allocatePatchData(d_U_scratch_idx); } } d_is_initialized = true; IBAMR_TIMER_STOP(t_initialize_operator_state); return; } // initializeOperatorState
void AdvDiffCenteredConvectiveOperator::initializeOperatorState(const SAMRAIVectorReal<NDIM, double>& in, const SAMRAIVectorReal<NDIM, double>& out) { IBAMR_TIMER_START(t_initialize_operator_state); if (d_is_initialized) deallocateOperatorState(); // Get the hierarchy configuration. d_hierarchy = in.getPatchHierarchy(); d_coarsest_ln = in.getCoarsestLevelNumber(); d_finest_ln = in.getFinestLevelNumber(); #if !defined(NDEBUG) TBOX_ASSERT(d_hierarchy == out.getPatchHierarchy()); TBOX_ASSERT(d_coarsest_ln == out.getCoarsestLevelNumber()); TBOX_ASSERT(d_finest_ln == out.getFinestLevelNumber()); #else NULL_USE(out); #endif Pointer<CartesianGridGeometry<NDIM> > grid_geom = d_hierarchy->getGridGeometry(); // Setup the coarsen algorithm, operator, and schedules. Pointer<CoarsenOperator<NDIM> > coarsen_op = grid_geom->lookupCoarsenOperator(d_q_flux_var, "CONSERVATIVE_COARSEN"); d_coarsen_alg = new CoarsenAlgorithm<NDIM>(); if (d_difference_form == ADVECTIVE || d_difference_form == SKEW_SYMMETRIC) d_coarsen_alg->registerCoarsen(d_q_extrap_idx, d_q_extrap_idx, coarsen_op); if (d_difference_form == CONSERVATIVE || d_difference_form == SKEW_SYMMETRIC) d_coarsen_alg->registerCoarsen(d_q_flux_idx, d_q_flux_idx, coarsen_op); d_coarsen_scheds.resize(d_finest_ln + 1); for (int ln = d_coarsest_ln + 1; ln <= d_finest_ln; ++ln) { Pointer<PatchLevel<NDIM> > level = d_hierarchy->getPatchLevel(ln); Pointer<PatchLevel<NDIM> > coarser_level = d_hierarchy->getPatchLevel(ln - 1); d_coarsen_scheds[ln] = d_coarsen_alg->createSchedule(coarser_level, level); } // Setup the refine algorithm, operator, patch strategy, and schedules. Pointer<RefineOperator<NDIM> > refine_op = grid_geom->lookupRefineOperator(d_Q_var, "CONSERVATIVE_LINEAR_REFINE"); d_ghostfill_alg = new RefineAlgorithm<NDIM>(); d_ghostfill_alg->registerRefine(d_Q_scratch_idx, in.getComponentDescriptorIndex(0), d_Q_scratch_idx, refine_op); if (d_outflow_bdry_extrap_type != "NONE") d_ghostfill_strategy = new CartExtrapPhysBdryOp(d_Q_scratch_idx, d_outflow_bdry_extrap_type); d_ghostfill_scheds.resize(d_finest_ln + 1); for (int ln = d_coarsest_ln; ln <= d_finest_ln; ++ln) { Pointer<PatchLevel<NDIM> > level = d_hierarchy->getPatchLevel(ln); d_ghostfill_scheds[ln] = d_ghostfill_alg->createSchedule(level, ln - 1, d_hierarchy, d_ghostfill_strategy); } d_is_initialized = true; IBAMR_TIMER_STOP(t_initialize_operator_state); return; } // initializeOperatorState
void PETScSNESFunctionGOWrapper::initializeOperatorState(const SAMRAIVectorReal<NDIM, double>& in, const SAMRAIVectorReal<NDIM, double>& out) { if (d_is_initialized) deallocateOperatorState(); d_x = in.cloneVector(""); d_y = out.cloneVector(""); MPI_Comm comm; int ierr = PetscObjectGetComm(reinterpret_cast<PetscObject>(d_petsc_snes), &comm); IBTK_CHKERRQ(ierr); d_petsc_x = PETScSAMRAIVectorReal::createPETScVector(d_x, comm); d_petsc_y = PETScSAMRAIVectorReal::createPETScVector(d_y, comm); d_is_initialized = true; return; } // initializeOperatorState
void IBImplicitModHelmholtzOperator::initializeOperatorState( const SAMRAIVectorReal<NDIM,double>& in, const SAMRAIVectorReal<NDIM,double>& out) { IBAMR_TIMER_START(t_initialize_operator_state); if (d_is_initialized) deallocateOperatorState(); SAMRAIVectorReal<NDIM,double> in_u(in.getName(), in.getPatchHierarchy(), in.getCoarsestLevelNumber(), in.getFinestLevelNumber()); in_u.addComponent(in.getComponentVariable(0), in.getComponentDescriptorIndex(0), in.getControlVolumeIndex(0)); SAMRAIVectorReal<NDIM,double> out_u(out.getName(), out.getPatchHierarchy(), out.getCoarsestLevelNumber(), out.getFinestLevelNumber()); out_u.addComponent(out.getComponentVariable(0), out.getComponentDescriptorIndex(0), out.getControlVolumeIndex(0)); d_helmholtz_op->initializeOperatorState(in_u, out_u); // d_ib_SJSstar_op->initializeOperatorState(in_u, out_u); d_is_initialized = true; IBAMR_TIMER_STOP(t_initialize_operator_state); return; }// initializeOperatorState
IBImplicitModHelmholtzOperator::~IBImplicitModHelmholtzOperator() { deallocateOperatorState(); return; }// ~IBImplicitModHelmholtzOperator
LinearOperator::~LinearOperator() { deallocateOperatorState(); return; } // ~LinearOperator()
INSCollocatedPPMConvectiveOperator::~INSCollocatedPPMConvectiveOperator() { deallocateOperatorState(); return; }// ~INSCollocatedPPMConvectiveOperator
PETScSNESFunctionGOWrapper::~PETScSNESFunctionGOWrapper() { if (d_is_initialized) deallocateOperatorState(); return; } // ~PETScSNESFunctionGOWrapper()
INSStaggeredVCStokesOperator::~INSStaggeredVCStokesOperator() { deallocateOperatorState(); return; }// ~INSStaggeredVCStokesOperator
FaceDataSynchronization::~FaceDataSynchronization() { if (d_is_initialized) deallocateOperatorState(); return; } // ~FaceDataSynchronization
INSStaggeredCenteredConvectiveOperator::~INSStaggeredCenteredConvectiveOperator() { deallocateOperatorState(); return; } // ~INSStaggeredCenteredConvectiveOperator
PETScSNESJacobianJOWrapper::~PETScSNESJacobianJOWrapper() { if (d_is_initialized) deallocateOperatorState(); return; } // ~PETScSNESJacobianJOWrapper()
AdvDiffCenteredConvectiveOperator::~AdvDiffCenteredConvectiveOperator() { deallocateOperatorState(); return; } // ~AdvDiffCenteredConvectiveOperator
ConvectiveOperator::~ConvectiveOperator() { deallocateOperatorState(); return; }// ~ConvectiveOperator
void StaggeredStokesOperator::initializeOperatorState(const SAMRAIVectorReal<NDIM, double>& in, const SAMRAIVectorReal<NDIM, double>& out) { IBAMR_TIMER_START(t_initialize_operator_state); // Deallocate the operator state if the operator is already initialized. if (d_is_initialized) deallocateOperatorState(); // Setup solution and rhs vectors. d_x = in.cloneVector(in.getName()); d_b = out.cloneVector(out.getName()); d_x->allocateVectorData(); // Setup the interpolation transaction information. d_U_fill_pattern = new SideNoCornersFillPattern(SIDEG, false, false, true); d_P_fill_pattern = new CellNoCornersFillPattern(CELLG, false, false, true); typedef HierarchyGhostCellInterpolation::InterpolationTransactionComponent InterpolationTransactionComponent; d_transaction_comps.resize(2); d_transaction_comps[0] = InterpolationTransactionComponent(d_x->getComponentDescriptorIndex(0), in.getComponentDescriptorIndex(0), DATA_REFINE_TYPE, USE_CF_INTERPOLATION, DATA_COARSEN_TYPE, BDRY_EXTRAP_TYPE, CONSISTENT_TYPE_2_BDRY, d_U_bc_coefs, d_U_fill_pattern); d_transaction_comps[1] = InterpolationTransactionComponent(in.getComponentDescriptorIndex(1), DATA_REFINE_TYPE, USE_CF_INTERPOLATION, DATA_COARSEN_TYPE, BDRY_EXTRAP_TYPE, CONSISTENT_TYPE_2_BDRY, d_P_bc_coef, d_P_fill_pattern); // Initialize the interpolation operators. d_hier_bdry_fill = new HierarchyGhostCellInterpolation(); d_hier_bdry_fill->initializeOperatorState(d_transaction_comps, d_x->getPatchHierarchy()); // Initialize hierarchy math ops object. if (!d_hier_math_ops_external) { d_hier_math_ops = new HierarchyMathOps(d_object_name + "::HierarchyMathOps", in.getPatchHierarchy(), in.getCoarsestLevelNumber(), in.getFinestLevelNumber()); } #if !defined(NDEBUG) else { TBOX_ASSERT(d_hier_math_ops); } #endif // Indicate the operator is initialized. d_is_initialized = true; IBAMR_TIMER_STOP(t_initialize_operator_state); return; } // initializeOperatorState
GeneralOperator::~GeneralOperator() { deallocateOperatorState(); return; } // ~GeneralOperator()
void FaceDataSynchronization::initializeOperatorState( const std::vector<SynchronizationTransactionComponent>& transaction_comps, Pointer<PatchHierarchy<NDIM> > hierarchy) { // Deallocate the operator state if the operator is already initialized. if (d_is_initialized) deallocateOperatorState(); // Reset the transaction components. d_transaction_comps = transaction_comps; // Cache hierarchy data. d_hierarchy = hierarchy; d_grid_geom = d_hierarchy->getGridGeometry(); d_coarsest_ln = 0; d_finest_ln = d_hierarchy->getFinestLevelNumber(); // Setup cached coarsen algorithms and schedules. VariableDatabase<NDIM>* var_db = VariableDatabase<NDIM>::getDatabase(); bool registered_coarsen_op = false; d_coarsen_alg = new CoarsenAlgorithm<NDIM>(); for (unsigned int comp_idx = 0; comp_idx < d_transaction_comps.size(); ++comp_idx) { const std::string& coarsen_op_name = d_transaction_comps[comp_idx].d_coarsen_op_name; if (coarsen_op_name != "NONE") { const int data_idx = d_transaction_comps[comp_idx].d_data_idx; Pointer<Variable<NDIM> > var; var_db->mapIndexToVariable(data_idx, var); #if !defined(NDEBUG) TBOX_ASSERT(var); #endif Pointer<CoarsenOperator<NDIM> > coarsen_op = d_grid_geom->lookupCoarsenOperator(var, coarsen_op_name); #if !defined(NDEBUG) TBOX_ASSERT(coarsen_op); #endif d_coarsen_alg->registerCoarsen(data_idx, // destination data_idx, // source coarsen_op); registered_coarsen_op = true; } } CoarsenPatchStrategy<NDIM>* coarsen_strategy = NULL; d_coarsen_scheds.resize(d_finest_ln + 1); if (registered_coarsen_op) { for (int ln = d_coarsest_ln + 1; ln <= d_finest_ln; ++ln) { Pointer<PatchLevel<NDIM> > level = d_hierarchy->getPatchLevel(ln); Pointer<PatchLevel<NDIM> > coarser_level = d_hierarchy->getPatchLevel(ln - 1); d_coarsen_scheds[ln] = d_coarsen_alg->createSchedule(coarser_level, level, coarsen_strategy); } } // Setup cached refine algorithms and schedules. d_refine_alg = new RefineAlgorithm<NDIM>(); for (unsigned int comp_idx = 0; comp_idx < d_transaction_comps.size(); ++comp_idx) { const int data_idx = d_transaction_comps[comp_idx].d_data_idx; Pointer<Variable<NDIM> > var; var_db->mapIndexToVariable(data_idx, var); Pointer<FaceVariable<NDIM, double> > fc_var = var; if (!fc_var) { TBOX_ERROR("FaceDataSynchronization::initializeOperatorState():\n" << " only double-precision face-centered data is supported." << std::endl); } Pointer<RefineOperator<NDIM> > refine_op = NULL; Pointer<VariableFillPattern<NDIM> > fill_pattern = new FaceSynchCopyFillPattern(); d_refine_alg->registerRefine(data_idx, // destination data_idx, // source data_idx, // temporary work space refine_op, fill_pattern); } d_refine_scheds.resize(d_finest_ln + 1); for (int ln = d_coarsest_ln; ln <= d_finest_ln; ++ln) { Pointer<PatchLevel<NDIM> > level = d_hierarchy->getPatchLevel(ln); d_refine_scheds[ln] = d_refine_alg->createSchedule(level); } // Indicate the operator is initialized. d_is_initialized = true; return; } // initializeOperatorState
PETScMatLOWrapper::~PETScMatLOWrapper() { if (d_is_initialized) deallocateOperatorState(); return; } // ~PETScMatLOWrapper()