void
RigidBodyKinematics::setRigidBodySpecificVelocity(const double time,
const std::vector<double>& /*incremented_angle_from_reference_axis*/,
const std::vector<double>& center_of_mass,
const std::vector<double>& /*tagged_pt_position*/)
{
std::vector<double> vel_parser(NDIM);
d_parser_time = time;
for (int d = 0; d < NDIM; ++d) d_parser_posn[d] = center_of_mass[d];
for (int d = 0; d < NDIM; ++d) vel_parser[d] = d_kinematicsvel_parsers[d]->Eval();
static const StructureParameters& struct_param = getStructureParameters();
static const int coarsest_ln = struct_param.getCoarsestLevelNumber();
static const int finest_ln = struct_param.getFinestLevelNumber();
static const int total_levels = finest_ln - coarsest_ln + 1;
static const std::vector<std::pair<int, int> >& idx_range = struct_param.getLagIdxRange();
for (int ln = 0; ln < total_levels; ++ln)
{
const int nodes_this_ln = idx_range[ln].second - idx_range[ln].first;
for (int d = 0; d < NDIM; ++d)
{
for (int idx = 0; idx < nodes_this_ln; ++idx) d_kinematics_vel[ln][d][idx] = vel_parser[d];
}
}
return;
} // setRigidBodySpecificVelocity
void
RigidBodyKinematics::setRigidBodySpecificVelocity(const double time,
const std::vector<double>& /*incremented_angle_from_reference_axis*/,
const std::vector<double>& center_of_mass,
const std::vector<double>& /*tagged_pt_position*/)
{
std::vector<double> vel_parser(NDIM);
d_parser_time = time;
for (int d = 0; d < NDIM; ++d) d_parser_posn[d] = center_of_mass[d];
for (int d = 0; d < NDIM; ++d) vel_parser[d] = d_kinematicsvel_parsers[d]->Eval();
const StructureParameters& struct_param = getStructureParameters();
#if !defined(NDEBUG)
{
const int finest_ln = struct_param.getFinestLevelNumber();
const int coarsest_ln = struct_param.getCoarsestLevelNumber();
TBOX_ASSERT(finest_ln == coarsest_ln);
}
#endif
const std::vector<std::pair<int, int> >& idx_range = struct_param.getLagIdxRange();
const int nodes_this_ln = idx_range[0].second - idx_range[0].first;
for (int d = 0; d < NDIM; ++d)
for (int idx = 0; idx < nodes_this_ln; ++idx) d_kinematics_vel[d][idx] = vel_parser[d];
return;
} // setRigidBodySpecificVelocity
const std::vector<std::vector<double> >&
OscillatingCylinderKinematics::getCurrentKinematicsVelocity(const int level) const
{
static const StructureParameters& struct_param = getStructureParameters();
static const int coarsest_ln = struct_param.getCoarsestLevelNumber();
const int offset = level - coarsest_ln;
return d_current_kinematics_vel[offset];
} // getCurrentKinematicsVelocity
KnifeFishKinematics::KnifeFishKinematics(
const std::string& object_name,
SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> input_db,
IBTK::LDataManager* l_data_manager,
SAMRAI::tbox::Pointer<SAMRAI::hier::PatchHierarchy<NDIM> > patch_hierarchy,
bool register_for_restart)
: ConstraintIBKinematics(object_name,input_db,l_data_manager,register_for_restart),
d_kinematics_vel(NDIM),
d_shape(NDIM),
d_current_time(0.0)
{
// NOTE: Parent class constructor registers class with the restart manager, sets object name.
//Set the size of vectors.
const StructureParameters& struct_param = getStructureParameters();
const int coarsest_ln = struct_param.getCoarsestLevelNumber();
const int finest_ln = struct_param.getFinestLevelNumber();
TBOX_ASSERT(coarsest_ln == finest_ln);
const std::vector<std::pair<int,int> >& idx_range = struct_param.getLagIdxRange();
const int nodes_body = idx_range[0].second - idx_range[0].first;
for(int d = 0; d < NDIM; ++d)
{
d_kinematics_vel[d].resize(nodes_body);
d_shape[d].resize(nodes_body);
}
SAMRAI::tbox::Array<double> forward_swim_vel;
if(input_db->keyExists("forward_swim_vel"))
{
forward_swim_vel = input_db->getDoubleArray("forward_swim_vel");
TBOX_ASSERT( forward_swim_vel.getSize() == NDIM );
}
else
{
TBOX_ERROR(" KnifefishKinematics::KnifefishKinematics() :: Forward swimming velocity does not exist in the InputDatabase \n\n" << std::endl );
}
for (unsigned int d = 0; d < NDIM; ++d)
std::fill(d_kinematics_vel[d].begin(), d_kinematics_vel[d].end(), forward_swim_vel[d]);
bool from_restart = RestartManager::getManager()->isFromRestart();
if(from_restart)
{
getFromRestart();
}
// set current velocity using current time for initial and restarted runs.
setKnifefishSpecificVelocity(d_current_time);
return;
} //KnifeFishKinematics
const std::vector<std::vector<double> >&
RigidBodyKinematics::getKinematicsVelocity(const int level) const
{
static const StructureParameters& struct_param = getStructureParameters();
static const int coarsest_ln = struct_param.getCoarsestLevelNumber();
#ifdef DEBUG_CHECK_ASSERTIONS
static const int finest_ln = struct_param.getFinestLevelNumber();
TBOX_ASSERT(coarsest_ln <= level && level <= finest_ln);
#endif
return d_kinematics_vel[level - coarsest_ln];
} // getKinematicsVelocity
void
OscillatingCylinderKinematics::setOscillatingCylinderSpecificVelocity(const double time)
{
// Set the size of vectors.
const StructureParameters& struct_param = getStructureParameters();
const std::vector<std::pair<int, int> >& idx_range = struct_param.getLagIdxRange();
const int number_lag_points = idx_range[0].second - idx_range[0].first;
for (int k = 0; k < number_lag_points; ++k)
{
d_current_kinematics_vel[0][0][k] = d_prescribed_trans_vel + d_Uinf * std::cos(2 * M_PI * d_freq * time);
}
return;
} // setOscillatingCylinderSpecificVelocity
OscillatingCylinderKinematics::OscillatingCylinderKinematics(const std::string& object_name,
Pointer<Database> input_db,
LDataManager* l_data_manager,
Pointer<PatchHierarchy<NDIM> > /*patch_hierarchy*/,
bool register_for_restart)
: ConstraintIBKinematics(object_name, input_db, l_data_manager, register_for_restart),
d_prescribed_trans_vel(0.0),
d_current_time(0.0)
{
// NOTE: Parent class constructor registers class with the restart manager, sets object name.
// Get kinematic parameters from the input file
if (input_db->keyExists("frequency"))
{
d_freq = input_db->getDouble("frequency");
pout << "FREQUENCY ================= " << d_freq << "\n\n\n";
}
else
{
TBOX_ERROR(
" OscillatingCylinderKinematics::OscillatingCylinderKinematics() :: frequency of cylinder does not exist "
"in the InputDatabase \n\n"
<< std::endl);
}
if (input_db->keyExists("U_infinity"))
{
d_Uinf = input_db->getDouble("U_infinity");
pout << "U_INFINITY ================= " << d_Uinf << "\n\n\n";
}
else
{
TBOX_ERROR(
" OscillatingCylinderKinematics::OscillatingCylinderKinematics() :: maximum speed of cylinder does not "
"exist in the InputDatabase \n\n"
<< std::endl);
}
// Set the size of vectors.
const StructureParameters& struct_param = getStructureParameters();
const int coarsest_ln = struct_param.getCoarsestLevelNumber();
const int finest_ln = struct_param.getFinestLevelNumber();
const int total_levels = finest_ln - coarsest_ln + 1;
const std::vector<std::pair<int, int> >& idx_range = struct_param.getLagIdxRange();
if (total_levels > 1)
{
TBOX_ERROR(
" OscillatingCylinderKinematics::OscillatingCylinderKinematics() :: Total levels > 1, OscillatingCylinder "
"should be places on only one level \n\n"
<< std::endl);
}
// d_vec_coord.resize(number_lag_points);
// d_vec_amp.resize(number_lag_points);
d_new_kinematics_vel.resize(total_levels);
d_current_kinematics_vel.resize(total_levels);
for (int ln = 0; ln < total_levels; ++ln)
{
const int nodes_this_ln = idx_range[ln].second - idx_range[ln].first;
d_new_kinematics_vel[ln].resize(NDIM);
d_current_kinematics_vel[ln].resize(NDIM);
for (int d = 0; d < NDIM; ++d)
{
d_new_kinematics_vel[ln][d].resize(nodes_this_ln);
d_current_kinematics_vel[ln][d].resize(nodes_this_ln);
}
}
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart)
{
getFromRestart();
}
// set current velocity using current time for initial and restarted runs.
setOscillatingCylinderSpecificVelocity(d_current_time);
return;
} // OscillatingCylinderKinematics
RigidBodyKinematics::RigidBodyKinematics(const std::string& object_name,
Pointer<Database> input_db,
LDataManager* l_data_manager,
Pointer<PatchHierarchy<NDIM> > /*patch_hierarchy*/,
bool register_for_restart)
: ConstraintIBKinematics(object_name, input_db, l_data_manager, register_for_restart),
d_parser_time(0.0),
d_center_of_mass(3, 0.0),
d_incremented_angle_from_reference_axis(3, 0.0),
d_tagged_pt_position(3, 0.0)
{
// NOTE: Parent class constructor registers class with the restart manager, sets object name.
// Read-in kinematics velocity functions
for (int d = 0; d < NDIM; ++d)
{
const std::string postfix = "_function_" + std::to_string(d);
std::string key_name = "kinematics_velocity" + postfix;
if (input_db->isString(key_name))
{
d_kinematicsvel_function_strings.push_back(input_db->getString(key_name));
}
else
{
d_kinematicsvel_function_strings.push_back("0.0");
TBOX_WARNING("RigidBodyKinematics::RigidBodyKinematics() :\n"
<< " no function corresponding to key " << key_name << "found for dimension = " << d
<< "; using kinematics_vel = 0.0. " << std::endl);
}
d_kinematicsvel_parsers.push_back(new mu::Parser());
d_kinematicsvel_parsers.back()->SetExpr(d_kinematicsvel_function_strings.back());
d_all_parsers.push_back(d_kinematicsvel_parsers.back());
}
// Define constants and variables for the parsers.
for (std::vector<mu::Parser*>::const_iterator cit = d_all_parsers.begin(); cit != d_all_parsers.end(); ++cit)
{
// Various names for pi.
(*cit)->DefineConst("pi", PII);
(*cit)->DefineConst("Pi", PII);
(*cit)->DefineConst("PI", PII);
// Variables
(*cit)->DefineVar("T", &d_parser_time);
(*cit)->DefineVar("t", &d_parser_time);
for (int d = 0; d < NDIM; ++d)
{
const std::string postfix = std::to_string(d);
(*cit)->DefineVar("X" + postfix, d_parser_posn.data() + d);
(*cit)->DefineVar("x" + postfix, d_parser_posn.data() + d);
(*cit)->DefineVar("X_" + postfix, d_parser_posn.data() + d);
(*cit)->DefineVar("x_" + postfix, d_parser_posn.data() + d);
}
}
// Set the size of vectors.
const StructureParameters& struct_param = getStructureParameters();
const int coarsest_ln = struct_param.getCoarsestLevelNumber();
const int finest_ln = struct_param.getFinestLevelNumber();
const int total_levels = finest_ln - coarsest_ln + 1;
d_kinematics_vel.resize(total_levels);
const std::vector<std::pair<int, int> >& idx_range = struct_param.getLagIdxRange();
for (int ln = 0; ln < total_levels; ++ln)
{
const int nodes_this_ln = idx_range[ln].second - idx_range[ln].first;
d_kinematics_vel[ln].resize(NDIM);
for (int d = 0; d < NDIM; ++d)
{
d_kinematics_vel[ln][d].resize(nodes_this_ln);
}
}
bool from_restart = RestartManager::getManager()->isFromRestart();
if (from_restart)
{
getFromRestart();
setRigidBodySpecificVelocity(
d_current_time, d_incremented_angle_from_reference_axis, d_center_of_mass, d_tagged_pt_position);
setShape(d_current_time, d_incremented_angle_from_reference_axis);
}
return;
} // RigidBodyKinematics
