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