/*!
* Convenience function to register several variables with the same \a prefix, that have a file
* as a value. Takes the prefix and registers variables like \c{prefix:FilePath} and
* \c{prefix:Path}, with descriptions that start with the given \a heading.
* For example \c{registerFileVariables("CurrentDocument", tr("Current Document"))} registers
* variables such as \c{CurrentDocument:FilePath} with description
* "Current Document: Full path including file name."
*
* \sa isFileVariable()
* \sa fileVariableValue()
*/
void VariableManager::registerFileVariables(const QByteArray &prefix, const QString &heading)
{
registerVariable(prefix + kFilePathPostfix, tr("%1: Full path including file name.").arg(heading));
registerVariable(prefix + kPathPostfix, tr("%1: Full path excluding file name.").arg(heading));
registerVariable(prefix + kFileNamePostfix, tr("%1: File name without path.").arg(heading));
registerVariable(prefix + kFileBaseNamePostfix, tr("%1: File base name without path and suffix.").arg(heading));
}
void GeneralizedIBMethod::registerEulerianVariables()
{
IBMethod::registerEulerianVariables();
const IntVector<NDIM> ib_ghosts = getMinimumGhostCellWidth();
const IntVector<NDIM> ghosts = 1;
const IntVector<NDIM> no_ghosts = 0;
Pointer<Variable<NDIM> > u_var = d_ib_solver->getVelocityVariable();
Pointer<CellVariable<NDIM, double> > u_cc_var = u_var;
Pointer<SideVariable<NDIM, double> > u_sc_var = u_var;
if (u_cc_var)
{
d_f_var = new CellVariable<NDIM, double>(d_object_name + "::f", NDIM);
d_w_var = new CellVariable<NDIM, double>(d_object_name + "::w", NDIM);
d_n_var = new CellVariable<NDIM, double>(d_object_name + "::n", NDIM);
}
else if (u_sc_var)
{
d_f_var = new SideVariable<NDIM, double>(d_object_name + "::f");
d_w_var = new SideVariable<NDIM, double>(d_object_name + "::w");
d_n_var = new SideVariable<NDIM, double>(d_object_name + "::n");
}
else
{
TBOX_ERROR(d_object_name << "::registerEulerianVariables():\n"
<< " unsupported velocity data centering" << std::endl);
}
registerVariable(d_f_idx, d_f_var, no_ghosts, d_ib_solver->getScratchContext());
registerVariable(d_w_idx, d_w_var, ib_ghosts, d_ib_solver->getScratchContext());
registerVariable(d_n_idx, d_n_var, ghosts, d_ib_solver->getScratchContext());
return;
} // registerEulerianVariables
FixationPoint::FixationPoint(const ParameterValueMap ¶meters):
RectangleStimulus(parameters),
SquareRegionTrigger(registerVariable(parameters[X_POSITION]),
registerVariable(parameters[Y_POSITION]),
registerVariable(parameters[TRIGGER_WIDTH]),
VariablePtr(parameters[TRIGGER_WATCH_X]),
VariablePtr(parameters[TRIGGER_WATCH_Y]),
VariablePtr(parameters[TRIGGER_FLAG]))
{ }
CircularFixationPoint::CircularFixationPoint(const ParameterValueMap ¶meters):
CircleStimulus(parameters),
CircularRegionTrigger(registerVariable(parameters[X_POSITION]),
registerVariable(parameters[Y_POSITION]),
registerVariable(parameters[FixationPoint::TRIGGER_WIDTH]),
VariablePtr(parameters[FixationPoint::TRIGGER_WATCH_X]),
VariablePtr(parameters[FixationPoint::TRIGGER_WATCH_Y]),
VariablePtr(parameters[FixationPoint::TRIGGER_FLAG]))
{ }
/*!
* Makes the given integral-valued \a variable known to the variable manager,
* together with a localized \a description.
*
* \sa registerVariable(), registerFileVariables()
*/
void VariableManager::registerIntVariable(const QByteArray &variable,
const QString &description, const VariableManager::IntFunction &value)
{
const VariableManager::IntFunction valuecopy = value; // do not capture a reference in a lambda
registerVariable(variable, description,
[valuecopy]() { return QString::number(valuecopy ? valuecopy() : 0); });
}
void S_zeroAssignments(struct Node *t) {
if (t == NULL)
return;
if (t->tag == TASSIGN) {
char *name = t->children->iname;
int zero = 0;
if (t->children->next->tag == TNUM) {
if (t->children->next->ival == 0.0) {
zero = 1;
}
}
registerVariable(name, TDOUBLE);
registerZeroVar(name, zero);
} else if (t->tag == TFOR) {
struct Node *pntr = t->children->next;
while (pntr != NULL) {
S_zeroAssignments(pntr);
pntr = pntr->next;
}
} else if (t->tag == TIF) {
S_zeroAssignments(t->children->next);
} else if (t->tag == TIFELSE) {
S_zeroAssignments(t->children->next->next);
} else if (t->tag == TCOMBINE) {
struct Node *pntr = t->children;
while (pntr != NULL) {
S_zeroAssignments(pntr);
pntr = pntr->next;
}
}
}
/*!
* Convenience function to register several variables with the same \a prefix, that have a file
* as a value. Takes the prefix and registers variables like \c{prefix:FilePath} and
* \c{prefix:Path}, with descriptions that start with the given \a heading.
* For example \c{registerFileVariables("CurrentDocument", tr("Current Document"))} registers
* variables such as \c{CurrentDocument:FilePath} with description
* "Current Document: Full path including file name."
*/
void VariableManager::registerFileVariables(const QByteArray &prefix,
const QString &heading, const StringFunction &base)
{
registerVariable(prefix + kFilePathPostfix,
QCoreApplication::translate("Core::VariableManager", "%1: Full path including file name.").arg(heading),
[base]() { return QFileInfo(base()).filePath(); });
registerVariable(prefix + kPathPostfix,
QCoreApplication::translate("Core::VariableManager", "%1: Full path excluding file name.").arg(heading),
[base]() { return QFileInfo(base()).path(); });
registerVariable(prefix + kFileNamePostfix,
QCoreApplication::translate("Core::VariableManager", "%1: File name without path.").arg(heading),
[base]() { return QFileInfo(base()).fileName(); });
registerVariable(prefix + kFileBaseNamePostfix,
QCoreApplication::translate("Core::VariableManager", "%1: File base name without path and suffix.").arg(heading),
[base]() { return QFileInfo(base()).baseName(); });
}
DriftingGratingStimulus::DriftingGratingStimulus(const ParameterValueMap ¶meters) :
StandardDynamicStimulus(parameters),
xoffset(registerVariable(parameters[BasicTransformStimulus::X_POSITION])),
yoffset(registerVariable(parameters[BasicTransformStimulus::Y_POSITION])),
width(registerVariable(parameters[BasicTransformStimulus::X_SIZE])),
height(registerVariable(parameters[BasicTransformStimulus::Y_SIZE])),
rotation(registerVariable(parameters[BasicTransformStimulus::ROTATION])),
alpha_multiplier(registerVariable(parameters[BasicTransformStimulus::ALPHA_MULTIPLIER])),
spatial_frequency(registerVariable(parameters[FREQUENCY])),
speed(registerVariable(parameters[SPEED])),
starting_phase(registerVariable(parameters[STARTING_PHASE])),
direction_in_degrees(registerVariable(parameters[DIRECTION]))
{
const std::string &grating_type = parameters[GRATING_TYPE].str();
shared_ptr<Variable> grating_sample_rate(parameters[GRATING_SAMPLE_RATE]);
if (grating_type == "sinusoid") {
grating = shared_ptr<SinusoidGratingData>(new SinusoidGratingData(grating_sample_rate));
} else if (grating_type == "square") {
grating = shared_ptr<SquareGratingData>(new SquareGratingData(grating_sample_rate));
} else if (grating_type == "triangle") {
grating = shared_ptr<TriangleGratingData>(new TriangleGratingData(grating_sample_rate));
} else if (grating_type == "sawtooth") {
grating = shared_ptr<SawtoothGratingData>(new SawtoothGratingData(grating_sample_rate, parameters[INVERTED]));
} else {
throw SimpleException("illegal grating type", grating_type);
}
const std::string &mask_type = parameters[MASK].str();
shared_ptr<Variable> mask_size(new ConstantVariable(128L));
if (mask_type == "rectangle") {
mask = shared_ptr<Mask>(new RectangleMask(mask_size));
} else if (mask_type == "ellipse") {
mask = shared_ptr<Mask>(new EllipseMask(mask_size));
} else if (mask_type == "gaussian") {
mask = shared_ptr<Mask>(new GaussianMask(mask_size, parameters[MEAN], parameters[STD_DEV]));
} else {
throw SimpleException("illegal mask", mask_type);
}
}
BaseFrameListStimulus::BaseFrameListStimulus(const ParameterValueMap ¶meters) :
StandardDynamicStimulus(parameters),
loop(registerVariable(parameters[LOOP])),
repeats(registerVariable(parameters[REPEATS])),
lastFrameDrawn(-1),
didSetEnding(false),
didSetEnded(false)
{
// We need to use find() because "stimulus_group" isn't a valid parameter for all
// BaseFrameListStimulus subclasses, meaning it won't always have a default value
if ((parameters.find(STIMULUS_GROUP) != parameters.end()) && !(parameters[STIMULUS_GROUP].empty())) {
stimulusGroup = StimulusGroupPtr(parameters[STIMULUS_GROUP]);
}
// Ditto for "ending"
if ((parameters.find(ENDING) != parameters.end()) && !(parameters[ENDING].empty())) {
ending = VariablePtr(parameters[ENDING]);
}
if (!(parameters[ENDED].empty())) {
ended = VariablePtr(parameters[ENDED]);
}
}
void IBHierarchyIntegrator::registerLoadBalancer(Pointer<LoadBalancer<NDIM> > load_balancer)
{
#if !defined(NDEBUG)
TBOX_ASSERT(load_balancer);
#endif
d_load_balancer = load_balancer;
if (d_workload_idx == -1)
{
d_workload_var = new CellVariable<NDIM, double>(d_object_name + "::workload");
registerVariable(d_workload_idx, d_workload_var, 0, getCurrentContext());
}
d_ib_method_ops->registerLoadBalancer(load_balancer, d_workload_idx);
return;
} // registerLoadBalancer
MovingDots::MovingDots(const ParameterValueMap ¶meters) :
StandardDynamicStimulus(parameters),
fieldRadius(registerVariable(parameters[FIELD_RADIUS])),
fieldCenterX(registerVariable(parameters[FIELD_CENTER_X])),
fieldCenterY(registerVariable(parameters[FIELD_CENTER_Y])),
dotDensity(registerVariable(parameters[DOT_DENSITY])),
dotSize(registerVariable(parameters[DOT_SIZE])),
alpha(registerVariable(parameters[ALPHA_MULTIPLIER])),
direction(registerVariable(parameters[DIRECTION])),
speed(registerVariable(parameters[SPEED])),
coherence(registerVariable(parameters[COHERENCE])),
lifetime(registerVariable(parameters[LIFETIME])),
announceDots(parameters[ANNOUNCE_DOTS]),
previousFieldRadius(1.0f),
currentFieldRadius(1.0f),
previousNumDots(0),
currentNumDots(0),
previousSpeed(0.0f),
currentSpeed(0.0f),
previousCoherence(1.0f),
currentCoherence(1.0f),
previousLifetime(0.0f),
currentLifetime(0.0f),
dotSizeToPixels(0.0f),
previousTime(-1),
currentTime(-1)
{
ParsedColorTrio color(parameters[COLOR]);
red = registerVariable(color.getR());
green = registerVariable(color.getG());
blue = registerVariable(color.getB());
if (parameters[RAND_SEED].empty()) {
randSeed = Clock::instance()->getSystemTimeNS();
} else {
randSeed = MWTime(parameters[RAND_SEED]);
}
randGen.seed(randSeed);
}
void
AdvDiffPredictorCorrectorHierarchyIntegrator::initializeHierarchyIntegrator(
Pointer<PatchHierarchy<NDIM> > hierarchy,
Pointer<GriddingAlgorithm<NDIM> > gridding_alg)
{
if (d_integrator_is_initialized) return;
d_hierarchy = hierarchy;
d_gridding_alg = gridding_alg;
Pointer<CartesianGridGeometry<NDIM> > grid_geom = d_hierarchy->getGridGeometry();
// Initialize the HyperbolicPatchStrategy and HyperbolicLevelIntegrator
// objects that provide numerical routines for explicitly integrating the
// advective terms.
d_hyp_patch_ops = new AdvDiffPredictorCorrectorHyperbolicPatchOps(
d_object_name+"::AdvDiffPredictorCorrectorHyperbolicPatchOps",
d_hyp_patch_ops_db,
d_explicit_predictor,
grid_geom,
d_registered_for_restart);
d_hyp_level_integrator = new HyperbolicLevelIntegrator<NDIM>(
d_object_name+"::HyperbolicLevelIntegrator",
d_hyp_level_integrator_db,
d_hyp_patch_ops,
d_registered_for_restart,
/*using_time_refinement*/ false);
// Setup variable contexts.
d_current_context = d_hyp_level_integrator->getCurrentContext();
d_new_context = d_hyp_level_integrator->getNewContext();
// Register the VisIt data writer with the patch strategy object, which is
// the object that actually registers variables for plotting.
if (d_visit_writer)
{
d_hyp_patch_ops->registerVisItDataWriter(d_visit_writer);
}
// Register variables with the hyperbolic level integrator.
for (std::vector<Pointer<FaceVariable<NDIM,double> > >::const_iterator cit = d_u_var.begin(); cit != d_u_var.end(); ++cit)
{
Pointer<FaceVariable<NDIM,double> > u_var = *cit;
d_hyp_patch_ops->registerAdvectionVelocity(u_var);
d_hyp_patch_ops->setAdvectionVelocityIsDivergenceFree(u_var,d_u_is_div_free[u_var]);
if (d_u_fcn[u_var]) d_hyp_patch_ops->setAdvectionVelocityFunction(u_var,d_u_fcn[u_var]);
}
const IntVector<NDIM> cell_ghosts = CELLG;
for (std::vector<Pointer<CellVariable<NDIM,double> > >::const_iterator cit = d_F_var.begin(); cit != d_F_var.end(); ++cit)
{
Pointer<CellVariable<NDIM,double> > F_var = *cit;
d_hyp_level_integrator->registerVariable(
F_var, cell_ghosts,
HyperbolicLevelIntegrator<NDIM>::TIME_DEP,
d_hierarchy->getGridGeometry(),
"CONSERVATIVE_COARSEN",
"CONSERVATIVE_LINEAR_REFINE");
}
for (std::vector<Pointer<SideVariable<NDIM,double> > >::const_iterator cit = d_diffusion_coef_var.begin(); cit != d_diffusion_coef_var.end(); ++cit)
{
Pointer<SideVariable<NDIM,double> > D_var = *cit;
d_hyp_level_integrator->registerVariable(
D_var, cell_ghosts,
HyperbolicLevelIntegrator<NDIM>::TIME_DEP,
d_hierarchy->getGridGeometry(),
"CONSERVATIVE_COARSEN",
"CONSERVATIVE_LINEAR_REFINE");
int D_scratch_idx;
registerVariable(D_scratch_idx, D_var, cell_ghosts, getScratchContext());
}
for (std::vector<Pointer<SideVariable<NDIM,double> > >::const_iterator cit = d_diffusion_coef_rhs_var.begin(); cit != d_diffusion_coef_rhs_var.end(); ++cit)
{
Pointer<SideVariable<NDIM,double> > D_rhs_var = *cit;
int D_rhs_scratch_idx;
registerVariable(D_rhs_scratch_idx, D_rhs_var, cell_ghosts, getScratchContext());
}
for (std::vector<Pointer<CellVariable<NDIM,double> > >::const_iterator cit = d_Q_rhs_var.begin(); cit != d_Q_rhs_var.end(); ++cit)
{
Pointer<CellVariable<NDIM,double> > Q_rhs_var = *cit;
int Q_rhs_scratch_idx;
registerVariable(Q_rhs_scratch_idx, Q_rhs_var, cell_ghosts, getScratchContext());
d_hyp_patch_ops->registerSourceTerm(Q_rhs_var);
}
for (std::vector<Pointer<CellVariable<NDIM,double> > >::const_iterator cit = d_Q_var.begin(); cit != d_Q_var.end(); ++cit)
{
Pointer<CellVariable<NDIM,double> > Q_var = *cit;
int Q_scratch_idx;
registerVariable(Q_scratch_idx, Q_var, cell_ghosts, getScratchContext());
d_hyp_patch_ops->registerTransportedQuantity(Q_var);
if (d_Q_u_map[Q_var]) d_hyp_patch_ops->setAdvectionVelocity(Q_var,d_Q_u_map[Q_var]);
d_hyp_patch_ops->setSourceTerm(Q_var,d_Q_Q_rhs_map[Q_var]);
d_hyp_patch_ops->setConvectiveDifferencingType(Q_var,d_Q_difference_form[Q_var]);
if (d_Q_init[Q_var]) d_hyp_patch_ops->setInitialConditions(Q_var,d_Q_init[Q_var]);
if (!d_Q_bc_coef[Q_var].empty()) d_hyp_patch_ops->setPhysicalBcCoefs(Q_var,d_Q_bc_coef[Q_var]);
}
// Initialize the HyperbolicLevelIntegrator.
//
// WARNING: This must be done AFTER all variables have been registered with
// the level integrator.
d_hyp_level_integrator->initializeLevelIntegrator(d_gridding_alg);
// Perform hierarchy initialization operations common to all implementations
// of AdvDiffHierarchyIntegrator.
AdvDiffHierarchyIntegrator::initializeHierarchyIntegrator(hierarchy, gridding_alg);
// Indicate that the integrator has been initialized.
d_integrator_is_initialized = true;
return;
}// initializeHierarchyIntegrator
void IBHierarchyIntegrator::initializeHierarchyIntegrator(
Pointer<PatchHierarchy<NDIM> > hierarchy,
Pointer<GriddingAlgorithm<NDIM> > gridding_alg)
{
if (d_integrator_is_initialized) return;
d_hierarchy = hierarchy;
d_gridding_alg = gridding_alg;
// Obtain the Hierarchy data operations objects.
HierarchyDataOpsManager<NDIM>* hier_ops_manager =
HierarchyDataOpsManager<NDIM>::getManager();
d_hier_velocity_data_ops = hier_ops_manager->getOperationsDouble(d_u_var, hierarchy, true);
d_hier_pressure_data_ops = hier_ops_manager->getOperationsDouble(d_p_var, hierarchy, true);
d_hier_cc_data_ops = hier_ops_manager->getOperationsDouble(
new CellVariable<NDIM, double>("cc_var"), hierarchy, true);
// Initialize all variables.
VariableDatabase<NDIM>* var_db = VariableDatabase<NDIM>::getDatabase();
const IntVector<NDIM> ib_ghosts = d_ib_method_ops->getMinimumGhostCellWidth();
const IntVector<NDIM> ghosts = 1;
d_u_idx = var_db->registerVariableAndContext(d_u_var, d_ib_context, ib_ghosts);
d_f_idx = var_db->registerVariableAndContext(d_f_var, d_ib_context, ghosts);
if (d_time_stepping_type == TRAPEZOIDAL_RULE)
{
d_f_current_idx = var_db->registerClonedPatchDataIndex(d_f_var, d_f_idx);
}
else
{
d_f_current_idx = -1;
}
if (d_ib_method_ops->hasFluidSources())
{
d_p_idx = var_db->registerVariableAndContext(d_p_var, d_ib_context, ib_ghosts);
d_q_idx = var_db->registerVariableAndContext(d_q_var, d_ib_context, ghosts);
}
else
{
d_q_var = NULL;
d_q_idx = -1;
}
if (!d_mark_file_name.empty())
{
d_mark_var = new LMarkerSetVariable(d_object_name + "::markers");
registerVariable(
d_mark_current_idx, d_mark_new_idx, d_mark_scratch_idx, d_mark_var, ghosts);
}
// Initialize the fluid solver.
if (d_ib_method_ops->hasFluidSources())
{
d_ins_hier_integrator->registerFluidSourceFunction(new IBEulerianSourceFunction(this));
}
d_ins_hier_integrator->initializeHierarchyIntegrator(hierarchy, gridding_alg);
// Have the IB method ops object register any additional Eulerian variables
// and communications algorithms that it requires.
d_ib_method_ops->registerEulerianVariables();
d_ib_method_ops->registerEulerianCommunicationAlgorithms();
// Create several communications algorithms, used in filling ghost cell data
// and synchronizing data on the patch hierarchy.
Pointer<Geometry<NDIM> > grid_geom = d_hierarchy->getGridGeometry();
const int u_new_idx = var_db->mapVariableAndContextToIndex(d_u_var, getNewContext());
const int u_scratch_idx =
var_db->mapVariableAndContextToIndex(d_u_var, getScratchContext());
const int p_new_idx = var_db->mapVariableAndContextToIndex(d_p_var, getNewContext());
const int p_scratch_idx =
var_db->mapVariableAndContextToIndex(d_p_var, getScratchContext());
Pointer<CellVariable<NDIM, double> > u_cc_var = d_u_var;
Pointer<SideVariable<NDIM, double> > u_sc_var = d_u_var;
if (u_cc_var)
{
d_u_phys_bdry_op =
new CartCellRobinPhysBdryOp(u_scratch_idx,
d_ins_hier_integrator->getVelocityBoundaryConditions(),
/*homogeneous_bc*/ false);
}
else if (u_sc_var)
{
d_u_phys_bdry_op =
new CartSideRobinPhysBdryOp(u_scratch_idx,
d_ins_hier_integrator->getVelocityBoundaryConditions(),
/*homogeneous_bc*/ false);
}
else
{
TBOX_ERROR(
"IBHierarchyIntegrator::initializeHierarchy(): unsupported velocity data "
"centering\n");
}
d_u_ghostfill_alg = new RefineAlgorithm<NDIM>();
d_u_ghostfill_op = NULL;
d_u_ghostfill_alg->registerRefine(d_u_idx, d_u_idx, d_u_idx, d_u_ghostfill_op);
registerGhostfillRefineAlgorithm(
d_object_name + "::u", d_u_ghostfill_alg, d_u_phys_bdry_op);
d_u_coarsen_alg = new CoarsenAlgorithm<NDIM>();
d_u_coarsen_op = grid_geom->lookupCoarsenOperator(d_u_var, "CONSERVATIVE_COARSEN");
d_u_coarsen_alg->registerCoarsen(d_u_idx, d_u_idx, d_u_coarsen_op);
registerCoarsenAlgorithm(d_object_name + "::u::CONSERVATIVE_COARSEN", d_u_coarsen_alg);
d_f_prolong_alg = new RefineAlgorithm<NDIM>();
d_f_prolong_op = grid_geom->lookupRefineOperator(d_f_var, "CONSERVATIVE_LINEAR_REFINE");
d_f_prolong_alg->registerRefine(d_f_idx, d_f_idx, d_f_idx, d_f_prolong_op);
registerProlongRefineAlgorithm(d_object_name + "::f", d_f_prolong_alg);
if (d_ib_method_ops->hasFluidSources())
{
Pointer<CellVariable<NDIM, double> > p_cc_var = d_p_var;
if (p_cc_var)
{
d_p_phys_bdry_op = new CartCellRobinPhysBdryOp(
p_scratch_idx,
d_ins_hier_integrator->getPressureBoundaryConditions(),
/*homogeneous_bc*/ false);
}
else
{
TBOX_ERROR(
"IBHierarchyIntegrator::initializeHierarchy(): unsupported pressure data "
"centering\n");
}
d_p_ghostfill_alg = new RefineAlgorithm<NDIM>();
d_p_ghostfill_op = NULL;
d_p_ghostfill_alg->registerRefine(d_p_idx, d_p_idx, d_p_idx, d_p_ghostfill_op);
registerGhostfillRefineAlgorithm(
d_object_name + "::p", d_p_ghostfill_alg, d_p_phys_bdry_op);
d_p_coarsen_alg = new CoarsenAlgorithm<NDIM>();
d_p_coarsen_op = grid_geom->lookupCoarsenOperator(d_p_var, "CONSERVATIVE_COARSEN");
d_p_coarsen_alg->registerCoarsen(d_p_idx, d_p_idx, d_p_coarsen_op);
registerCoarsenAlgorithm(d_object_name + "::p::CONSERVATIVE_COARSEN", d_p_coarsen_alg);
d_q_prolong_alg = new RefineAlgorithm<NDIM>();
d_q_prolong_op =
grid_geom->lookupRefineOperator(d_q_var, "CONSERVATIVE_LINEAR_REFINE");
d_q_prolong_alg->registerRefine(d_q_idx, d_q_idx, d_q_idx, d_q_prolong_op);
registerProlongRefineAlgorithm(d_object_name + "::q", d_q_prolong_alg);
}
Pointer<RefineAlgorithm<NDIM> > refine_alg = new RefineAlgorithm<NDIM>();
Pointer<RefineOperator<NDIM> > refine_op;
refine_op = grid_geom->lookupRefineOperator(d_u_var, "CONSERVATIVE_LINEAR_REFINE");
refine_alg->registerRefine(u_scratch_idx, u_new_idx, u_scratch_idx, refine_op);
refine_op = grid_geom->lookupRefineOperator(d_p_var, "LINEAR_REFINE");
refine_alg->registerRefine(p_scratch_idx, p_new_idx, p_scratch_idx, refine_op);
ComponentSelector instrumentation_data_fill_bc_idxs;
instrumentation_data_fill_bc_idxs.setFlag(u_scratch_idx);
instrumentation_data_fill_bc_idxs.setFlag(p_scratch_idx);
RefinePatchStrategy<NDIM>* refine_patch_bdry_op =
new CartExtrapPhysBdryOp(instrumentation_data_fill_bc_idxs, "LINEAR");
registerGhostfillRefineAlgorithm(
d_object_name + "::INSTRUMENTATION_DATA_FILL", refine_alg, refine_patch_bdry_op);
// Read in initial marker positions.
if (!d_mark_file_name.empty())
{
LMarkerUtilities::readMarkerPositions(
d_mark_init_posns, d_mark_file_name, hierarchy->getGridGeometry());
}
// Setup the tag buffer.
const int finest_hier_ln = gridding_alg->getMaxLevels() - 1;
const int tsize = d_tag_buffer.size();
d_tag_buffer.resizeArray(finest_hier_ln);
for (int i = tsize; i < finest_hier_ln; ++i) d_tag_buffer[i] = 0;
for (int i = std::max(tsize, 1); i < d_tag_buffer.size(); ++i)
{
d_tag_buffer[i] = d_tag_buffer[i - 1];
}
d_ib_method_ops->setupTagBuffer(d_tag_buffer, d_gridding_alg);
// Indicate that the integrator has been initialized.
d_integrator_is_initialized = true;
return;
} // initializeHierarchyIntegrator
VariablePtr FreezableCollection::registerVariable(const ParameterValue ¶m, bool check_for_duplicates) {
return registerVariable(VariablePtr(param), check_for_duplicates);
}
