void
ForceProjector::calculateEulerianBodyForce(const double /*new_time*/, const double current_time)
{
// allocate patch data for Eulerian forcing.
const int coarsest_ln = 0;
const int finest_ln = d_patch_hierarchy->getFinestLevelNumber();
for (int ln = coarsest_ln; ln <= finest_ln; ++ln)
{
Pointer<PatchLevel<NDIM> > level = d_patch_hierarchy->getPatchLevel(ln);
if (level->checkAllocated(d_body_force_idx)) level->deallocatePatchData(d_body_force_idx);
level->allocatePatchData(d_body_force_idx, current_time);
for (PatchLevel<NDIM>::Iterator p(level); p; p++)
{
Pointer<Patch<NDIM> > patch = level->getPatch(p());
if (d_solver_type == "STAGGERED")
{
Pointer<SideData<NDIM, double> > body_force_data = patch->getPatchData(d_body_force_idx);
body_force_data->fill(0.0);
}
else if (d_solver_type == "COLLOCATED")
{
Pointer<CellData<NDIM, double> > body_force_data = patch->getPatchData(d_body_force_idx);
body_force_data->fill(0.0);
}
else
{
TBOX_ERROR("ForceProjector::calculateEulerianBodyForce() "
<< "UNKNOWN SOLVER ENCOUNTERED"
<< std::endl);
}
} // iterate over patches
} // all levels.
// spread the lagrangian force from finest level to the finest level.
std::vector<Pointer<LData> > F_data(finest_ln + 1, Pointer<LData>(NULL));
std::vector<Pointer<LData> > X_data(finest_ln + 1, Pointer<LData>(NULL));
// Fill in the above vectors at the finest level.
F_data[finest_ln] = d_lag_force[finest_ln];
X_data[finest_ln] = d_lag_data_manager->getLData("X", finest_ln);
// Spread the deformation velocities.
d_lag_data_manager->spread(d_body_force_idx, F_data, X_data, (RobinPhysBdryPatchStrategy*)NULL);
return;
} // calculateEulerianBodyForce
void GeneralizedIBMethod::initializePatchHierarchy(
Pointer<PatchHierarchy<NDIM> > hierarchy,
Pointer<GriddingAlgorithm<NDIM> > gridding_alg,
int u_data_idx,
const std::vector<Pointer<CoarsenSchedule<NDIM> > >& u_synch_scheds,
const std::vector<Pointer<RefineSchedule<NDIM> > >& u_ghost_fill_scheds,
int integrator_step,
double init_data_time,
bool initial_time)
{
// Initialize various Lagrangian data objects required by the conventional
// IB method.
IBMethod::initializePatchHierarchy(hierarchy,
gridding_alg,
u_data_idx,
u_synch_scheds,
u_ghost_fill_scheds,
integrator_step,
init_data_time,
initial_time);
// Initialize various Lagrangian data objects required by the gIB method.
if (initial_time)
{
// Lookup the range of hierarchy levels.
const int coarsest_ln = 0;
const int finest_ln = d_hierarchy->getFinestLevelNumber();
// Initialize the interpolated angular velocity field.
std::vector<Pointer<LData> > W_data(finest_ln + 1);
std::vector<Pointer<LData> > X_data(finest_ln + 1);
for (int ln = coarsest_ln; ln <= finest_ln; ++ln)
{
if (!d_l_data_manager->levelContainsLagrangianData(ln)) continue;
X_data[ln] = d_l_data_manager->getLData(LDataManager::POSN_DATA_NAME, ln);
W_data[ln] = d_l_data_manager->getLData("W", ln);
}
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)
{
Pointer<CellVariable<NDIM, double> > w_cc_var = d_w_var;
getHierarchyMathOps()->curl(
d_w_idx, w_cc_var, u_data_idx, u_cc_var, NULL, init_data_time);
}
else if (u_sc_var)
{
Pointer<SideVariable<NDIM, double> > w_sc_var = d_w_var;
getHierarchyMathOps()->curl(
d_w_idx, w_sc_var, u_data_idx, u_sc_var, NULL, init_data_time);
}
else
{
TBOX_ERROR(d_object_name << "::initializePatchHierarchy():\n"
<< " unsupported velocity data centering" << std::endl);
}
getVelocityHierarchyDataOps()->scale(d_w_idx, 0.5, d_w_idx);
d_l_data_manager->interp(d_w_idx,
W_data,
X_data,
std::vector<Pointer<CoarsenSchedule<NDIM> > >(),
getGhostfillRefineSchedules(d_object_name + "::w"),
init_data_time);
resetAnchorPointValues(W_data, coarsest_ln, finest_ln);
}
// Indicate that the force-and-torque strategy needs to be re-initialized.
d_ib_force_and_torque_fcn_needs_init = true;
return;
} // initializePatchHierarchy
