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()
