// 扰动网格
void MeshOpt::disturbMesh(hier::Patch<NDIM>& patch,
const double time,
const double dt,
const bool initial_time)
{
NULL_USE(dt);
NULL_USE(time);
NULL_USE(initial_time);
tbox::Pointer< pdat::NodeData<NDIM,double> > coords_current
= patch.getPatchData(d_coords_current_id);
tbox::Pointer< pdat::NodeData<NDIM,bool> > fixed_info
= patch.getPatchData(d_fixed_info_id);
int count = -1;
double dist = 0.01;
for(pdat::NodeIterator<NDIM> ic((*coords_current).getBox()); ic; ic++)
{
dist *= -1;
if((*fixed_info)(ic(),0) == false)
{
(*coords_current)(ic(),0) += dist;
(*coords_current)(ic(),1) -= dist;
}
++count;
}
// 表示已扰动
d_flag = 1;
}
void PatchMultiblockTestStrategy::tagCellsInInputBoxes(
hier::Patch& patch,
int level_number,
int tag_index)
{
if (level_number < static_cast<int>(d_refine_level_boxes.size())) {
std::shared_ptr<pdat::CellData<int> > tags(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<int>, hier::PatchData>(
patch.getPatchData(tag_index)));
TBOX_ASSERT(tags);
tags->fillAll(0);
const hier::Box pbox = patch.getBox();
for (hier::BoxContainer::iterator k =
d_refine_level_boxes[level_number].begin();
k != d_refine_level_boxes[level_number].end(); ++k) {
tags->fill(1, *k * pbox, 0);
}
}
}
void EdgeMultiblockTest::initializeDataOnPatch(
hier::Patch& patch,
const std::shared_ptr<hier::PatchHierarchy> hierarchy,
int level_number,
const hier::BlockId& block_id,
char src_or_dst)
{
NULL_USE(hierarchy);
NULL_USE(src_or_dst);
if ((d_refine_option == "INTERIOR_FROM_SAME_LEVEL")
|| ((d_refine_option == "INTERIOR_FROM_COARSER_LEVEL")
&& (level_number < d_finest_level_number))) {
for (int i = 0; i < static_cast<int>(d_variables.size()); ++i) {
std::shared_ptr<pdat::EdgeData<double> > edge_data(
SAMRAI_SHARED_PTR_CAST<pdat::EdgeData<double>, hier::PatchData>(
patch.getPatchData(d_variables[i], getDataContext())));
TBOX_ASSERT(edge_data);
hier::Box dbox = edge_data->getGhostBox();
edge_data->fillAll((double)block_id.getBlockValue());
}
}
}
/********************************************************************
* 网格处理 *
********************************************************************/
void MeshOpt::setNodeInfo(hier::Patch<NDIM>& patch)
{
const hier::Index<NDIM> ifirst=patch.getBox().lower();
const hier::Index<NDIM> ilast =patch.getBox().upper();
int cols = ilast(0) - ifirst(0)+2;
int rows = ilast(1) - ifirst(1)+2;
int num_of_nodes = cols*rows;
tbox::Array<bool> d_fixed_info(num_of_nodes,true);
for(int row = 0; row < rows; row++)
{
for(int col = 0; col < cols; col++)
{
if(row == 0 || row == rows-1 || col == 0 || col == cols-1)
{
d_fixed_info[row*cols+col] = true;
}
else
d_fixed_info[row*cols+col] = false;
}
}
tbox::Pointer< pdat::NodeData<NDIM,bool> > fixed_info
= patch.getPatchData(d_fixed_info_id);
int count=-1;
for(pdat::NodeIterator<NDIM> ic((*fixed_info).getBox()); ic; ic++)
{
(*fixed_info)(ic(),0) = d_fixed_info[++count];
}
}
void EdgeMultiblockTest::postprocessRefine(
hier::Patch& fine,
const hier::Patch& coarse,
const std::shared_ptr<hier::VariableContext>& context,
const hier::Box& fine_box,
const hier::IntVector& ratio) const
{
pdat::EdgeDoubleConstantRefine ref_op;
hier::BoxContainer fine_box_list(fine_box);
hier::BoxContainer empty_box_list;
xfer::BoxGeometryVariableFillPattern fill_pattern;
for (int i = 0; i < static_cast<int>(d_variables.size()); ++i) {
int id = hier::VariableDatabase::getDatabase()->
mapVariableAndContextToIndex(d_variables[i], context);
std::shared_ptr<hier::PatchDataFactory> fine_pdf(
fine.getPatchDescriptor()->getPatchDataFactory(id));
std::shared_ptr<hier::BoxOverlap> fine_overlap(
fill_pattern.computeFillBoxesOverlap(
fine_box_list,
empty_box_list,
fine.getBox(),
fine.getPatchData(id)->getGhostBox(),
*fine_pdf));
ref_op.refine(fine, coarse, id, id, *fine_overlap, ratio);
}
}
/*************************************************************************
* 步长构件: 计算并返回网格片上的稳定时间步长.
*************************************************************************/
double MeshOpt::getPatchDt(hier::Patch<NDIM>& patch,
const double time,
const bool initial_time,
const int flag_last_dt,
const double last_dt,
const string& intc_name)
{
#ifdef DEBUG_CHECK_ASSERTIONS
assert(intc_name=="TIME_STEP_SIZE");
#endif
NULL_USE(flag_last_dt);
NULL_USE(last_dt);
tbox::Pointer< pdat::NodeData<NDIM,double> > coords_current =
patch.getPatchData(d_coords_current_id);
#ifdef DEBUG_CHECK_ASSERTIONS
assert(!coords_current.isNull());
#endif
#ifdef DEBUG_CHECK_ASSERTIONS
assert(ghost_cells == d_zeroghosts);
#endif
double stabdt = 0.1;
return stabdt;
}
/*************************************************************************
* 初值构件: 初始化网格结点坐标
*************************************************************************/
void MeshOpt::initializePatchData( hier::Patch<NDIM>& patch,
const double time,
const bool initial_time,
const string& intc_name)
{
#ifdef DEBUG_CHECK_ASSERTIONS
assert(intc_name=="INIT");
#endif
(void) time;
if (initial_time) {
tbox::Pointer< pdat::NodeData<NDIM,double> > coords_current =
patch.getPatchData(d_coords_current_id);
#ifdef DEBUG_CHECK_ASSERTIONS
assert(!coords_current.isNull());
#endif
#ifdef DEBUG_CHECK_ASSERTIONS
assert(ghost_cells == d_zeroghosts);
#endif
// 生成初始网格.
if(!d_grid_tool.isNull()) {
d_grid_tool->generateDeformingMeshForDomain(patch,
d_coords_current_id);
}
tbox::Pointer< pdat::NodeData<NDIM,bool> > fixed_info
= patch.getPatchData(d_fixed_info_id);
// 赋初值
fixed_info->fillAll(false);
// 设定结点类型
setNodeInfo(patch);
}
}
/*
*************************************************************************
*
* Tag cells for spherical octant problem
*
*************************************************************************
*/
void MblkGeometry::tagOctantCells(
hier::Patch& patch,
const int xyz_id,
boost::shared_ptr<pdat::CellData<int> >& temp_tags,
const double regrid_time,
const int refine_tag_val)
{
TBOX_ASSERT(d_geom_problem == "SPHERICAL_SHELL" &&
d_sshell_type == "OCTANT");
TBOX_ASSERT(temp_tags);
boost::shared_ptr<pdat::NodeData<double> > xyz(
BOOST_CAST<pdat::NodeData<double>, hier::PatchData>(
patch.getPatchData(xyz_id)));
TBOX_ASSERT(xyz);
if (d_dim == tbox::Dimension(3)) {
/*
* Tag in X direction only
*/
double xtag_loc_lo = d_sshell_rmin
+ (regrid_time * d_tag_velocity) - (0.5 * d_tag_width);
double xtag_loc_hi = d_sshell_rmin
+ (regrid_time * d_tag_velocity) + (0.5 * d_tag_width);
hier::Box pbox = patch.getBox();
for (int k = pbox.lower(2); k <= pbox.upper(2) + 1; ++k) {
for (int j = pbox.lower(1); j <= pbox.upper(1) + 1; ++j) {
for (int i = pbox.lower(0); i <= pbox.upper(0) + 1; ++i) {
hier::Index ic(i, j, k);
pdat::NodeIndex node(ic, pdat::NodeIndex::LLL);
hier::Index icm1(i - 1, j - 1, k - 1);
pdat::CellIndex cell(icm1);
double node_x_loc = (*xyz)(node, 0);
if ((node_x_loc > xtag_loc_lo) &&
(node_x_loc < xtag_loc_hi)) {
(*temp_tags)(cell) = refine_tag_val;
}
}
}
}
}
}
void MblkGeometry::buildCartesianGridOnPatch(
const hier::Patch& patch,
const int xyz_id,
const int level_number,
const int block_number)
{
boost::shared_ptr<pdat::NodeData<double> > xyz(
BOOST_CAST<pdat::NodeData<double>, hier::PatchData>(
patch.getPatchData(xyz_id)));
TBOX_ASSERT(xyz);
pdat::NodeIterator niend(pdat::NodeGeometry::end(patch.getBox()));
for (pdat::NodeIterator ni(pdat::NodeGeometry::begin(patch.getBox()));
ni != niend; ++ni) {
pdat::NodeIndex node = *ni;
if (d_block_rotation[block_number] == 0) {
(*xyz)(node, 0) =
d_cart_xlo[block_number][0] + node(0) * d_dx[level_number][block_number][0];
(*xyz)(node, 1) =
d_cart_xlo[block_number][1] + node(1) * d_dx[level_number][block_number][1];
if (d_dim == tbox::Dimension(3)) {
(*xyz)(node, 2) =
d_cart_xlo[block_number][2] + node(2) * d_dx[level_number][block_number][2];
}
}
if (d_block_rotation[block_number] == 1) { // I sideways, J down
(*xyz)(node, 0) =
d_cart_xlo[block_number][0] - node(0) * d_dx[level_number][block_number][0];
(*xyz)(node, 1) =
d_cart_xlo[block_number][1] + node(1) * d_dx[level_number][block_number][1];
if (d_dim == tbox::Dimension(3)) {
(*xyz)(node, 2) =
d_cart_xlo[block_number][2] + node(2) * d_dx[level_number][block_number][2];
}
}
}
}
void MeshOpt::transformMeshtoPatch(MeshImpl * mesh, hier::Patch<NDIM>& patch, MsqError& err)
{
std::vector<Mesh::VertexHandle> vertices;
mesh->get_all_vertices(vertices,err);
size_t num_of_vertices = vertices.size();
// std::cout << num_of_vertices << std::endl;
std::vector<MsqVertex> coords(num_of_vertices);
mesh->vertices_get_coordinates(arrptr(vertices),arrptr(coords),num_of_vertices,err);
tbox::Pointer< pdat::NodeData<NDIM,double> > coords_current
= patch.getPatchData(d_coords_current_id);
int count = 0;
for(pdat::NodeIterator<NDIM> ic((*coords_current).getBox()); ic; ic++)
{
(*coords_current)(ic(),0) = coords[count][0];
(*coords_current)(ic(),1) = coords[count][1];
++count;
}
return;
}
void MblkGeometry::buildSShellGridOnPatch(
const hier::Patch& patch,
const hier::Box& domain,
const int xyz_id,
const int level_number,
const int block_number)
{
bool xyz_allocated = patch.checkAllocated(xyz_id);
if (!xyz_allocated) {
TBOX_ERROR("xyz data not allocated" << std::endl);
//patch.allocatePatchData(xyz_id);
}
boost::shared_ptr<pdat::NodeData<double> > xyz(
BOOST_CAST<pdat::NodeData<double>, hier::PatchData>(
patch.getPatchData(xyz_id)));
TBOX_ASSERT(xyz);
if (d_dim == tbox::Dimension(3)) {
const hier::Index ifirst = patch.getBox().lower();
const hier::Index ilast = patch.getBox().upper();
hier::IntVector nghost_cells = xyz->getGhostCellWidth();
//int imin = ifirst(0);
//int imax = ilast(0) + 1;
//int jmin = ifirst(1);
//int jmax = ilast(1) + 1;
//int kmin = ifirst(2);
//int kmax = ilast(2) + 1;
//int nx = imax - imin + 1;
//int ny = jmax - jmin + 1;
//int nxny = nx*ny;
int nd_imin = ifirst(0) - nghost_cells(0);
int nd_imax = ilast(0) + 1 + nghost_cells(0);
int nd_jmin = ifirst(1) - nghost_cells(1);
int nd_jmax = ilast(1) + 1 + nghost_cells(1);
int nd_kmin = ifirst(2) - nghost_cells(2);
int nd_kmax = ilast(2) + 1 + nghost_cells(2);
int nd_nx = nd_imax - nd_imin + 1;
int nd_ny = nd_jmax - nd_jmin + 1;
int nd_nxny = nd_nx * nd_ny;
double* x = xyz->getPointer(0);
double* y = xyz->getPointer(1);
double* z = xyz->getPointer(2);
bool found = false;
int nrad = (domain.upper(0) - domain.lower(0) + 1);
int nth = (domain.upper(1) - domain.lower(1) + 1);
int nphi = (domain.upper(2) - domain.lower(2) + 1);
/*
* If its a solid shell, its a single block and dx = dr, dth, dphi
*/
if (d_sshell_type == "SOLID") {
d_dx[level_number][block_number][0] = (d_sshell_rmax - d_sshell_rmin) / (double)nrad;
d_dx[level_number][block_number][1] =
2.0 * tbox::MathUtilities<double>::Abs(d_sangle_thmin)
/ (double)nth;
d_dx[level_number][block_number][2] =
2.0 * tbox::MathUtilities<double>::Abs(d_sangle_thmin)
/ (double)nphi;
//
// step in a radial direction in x and set y and z appropriately
// for a solid angle we go -th to th and -phi to phi
//
for (int k = nd_kmin; k <= nd_kmax; ++k) {
for (int j = nd_jmin; j <= nd_jmax; ++j) {
double theta = d_sangle_thmin + j * d_dx[level_number][block_number][1]; // dx used for dth
double phi = d_sangle_thmin + k * d_dx[level_number][block_number][2];
double xface = cos(theta) * cos(phi);
double yface = sin(theta) * cos(phi);
double zface = sin(phi);
for (int i = nd_imin; i <= nd_imax; ++i) {
int ind = POLY3(i,
j,
k,
nd_imin,
nd_jmin,
nd_kmin,
nd_nx,
nd_nxny);
double r = d_sshell_rmin + d_dx[level_number][block_number][0] * (i);
double xx = r * xface;
double yy = r * yface;
double zz = r * zface;
x[ind] = xx;
y[ind] = yy;
z[ind] = zz;
}
}
}
found = true;
}
/*
* If its an octant problem, then its got multiple (three) blocks
*/
if (d_sshell_type == "OCTANT") {
double drad = (d_sshell_rmax - d_sshell_rmin) / nrad;
//
// as in the solid angle we go along a radial direction in
// x setting y and z appropriately, but here we have logic for
// the block we are in. This is contained in the dispOctant.m
// matlab code.
//
for (int k = nd_kmin; k <= nd_kmax; ++k) {
for (int j = nd_jmin; j <= nd_jmax; ++j) {
//
// compute the position on the unit sphere for our radial line
//
double xface, yface, zface;
computeUnitSphereOctant(block_number, nth, j, k,
&xface, &yface, &zface);
for (int i = nd_imin; i <= nd_imax; ++i) {
int ind = POLY3(i,
j,
k,
nd_imin,
nd_jmin,
nd_kmin,
nd_nx,
nd_nxny);
double r = d_sshell_rmin + drad * (i);
double xx = r * xface;
double yy = r * yface;
double zz = r * zface;
x[ind] = xx;
y[ind] = yy;
z[ind] = zz;
}
}
}
found = true;
}
if (!found) {
TBOX_ERROR(
d_object_name << ": "
<< "spherical shell nodal positions for "
<< d_sshell_type
<< " not found" << std::endl);
}
}
}
int SkeletonBoundaryUtilities2::checkBdryData(
const string& varname,
const hier::Patch& patch,
int data_id,
int depth,
const hier::IntVector& gcw_to_check,
const hier::BoundaryBox& bbox,
int bcase,
double bstate)
{
TBOX_ASSERT(!varname.empty());
TBOX_ASSERT(data_id >= 0);
TBOX_ASSERT(depth >= 0);
int num_bad_values = 0;
int btype = bbox.getBoundaryType();
int bloc = bbox.getLocationIndex();
std::shared_ptr<hier::PatchGeometry> pgeom(patch.getPatchGeometry());
std::shared_ptr<pdat::CellData<double> > vardata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
patch.getPatchData(data_id)));
TBOX_ASSERT(vardata);
string bdry_type_str;
if (btype == Bdry::EDGE2D) {
bdry_type_str = "EDGE";
} else if (btype == Bdry::NODE2D) {
bdry_type_str = "NODE";
} else {
TBOX_ERROR(
"Unknown btype " << btype
<< " passed to SkeletonBoundaryUtilities2::checkBdryData()! "
<< endl);
}
tbox::plog << "\n\nCHECKING 2D " << bdry_type_str << " BDRY DATA..." << endl;
tbox::plog << "varname = " << varname << " : depth = " << depth << endl;
tbox::plog << "bbox = " << bbox.getBox() << endl;
tbox::plog << "btype, bloc, bcase = "
<< btype << ", = " << bloc << ", = " << bcase << endl;
tbox::Dimension::dir_t idir;
double valfact = 0.0, constval = 0.0, dxfact = 0.0;
int offsign;
get2dBdryDirectionCheckValues(idir, offsign,
btype, bloc, bcase);
if (btype == Bdry::EDGE2D) {
if (bcase == BdryCond::FLOW) {
valfact = 1.0;
constval = 0.0;
dxfact = 0.0;
} else if (bcase == BdryCond::REFLECT) {
valfact = -1.0;
constval = 0.0;
dxfact = 0.0;
} else if (bcase == BdryCond::DIRICHLET) {
valfact = 0.0;
constval = bstate;
dxfact = 0.0;
} else {
TBOX_ERROR(
"Unknown bcase " << bcase
<< " passed to SkeletonBoundaryUtilities2::checkBdryData()"
<< "\n for " << bdry_type_str
<< " at location " << bloc << endl);
}
} else if (btype == Bdry::NODE2D) {
if (bcase == BdryCond::XFLOW || bcase == BdryCond::YFLOW) {
valfact = 1.0;
constval = 0.0;
dxfact = 0.0;
} else if (bcase == BdryCond::XREFLECT || bcase == BdryCond::YREFLECT) {
valfact = -1.0;
constval = 0.0;
dxfact = 0.0;
} else if (bcase == BdryCond::XDIRICHLET ||
bcase == BdryCond::YDIRICHLET) {
valfact = 0.0;
constval = bstate;
dxfact = 0.0;
} else {
TBOX_ERROR(
"Unknown bcase " << bcase
<< " passed to SkeletonBoundaryUtilities2::checkBdryData()"
<< "\n for " << bdry_type_str
<< " at location " << bloc << endl);
}
}
hier::Box gbox_to_check(
vardata->getGhostBox() * pgeom->getBoundaryFillBox(bbox,
patch.getBox(),
gcw_to_check));
hier::Box cbox(gbox_to_check);
hier::Box dbox(gbox_to_check);
hier::Index ifirst(vardata->getBox().lower());
hier::Index ilast(vardata->getBox().upper());
if (offsign == -1) {
cbox.setLower(idir, ifirst(idir) - 1);
cbox.setUpper(idir, ifirst(idir) - 1);
dbox.setLower(idir, ifirst(idir));
dbox.setUpper(idir, ifirst(idir));
} else {
cbox.setLower(idir, ilast(idir) + 1);
cbox.setUpper(idir, ilast(idir) + 1);
dbox.setLower(idir, ilast(idir));
dbox.setUpper(idir, ilast(idir));
}
pdat::CellIterator id(pdat::CellGeometry::begin(dbox));
pdat::CellIterator icend(pdat::CellGeometry::end(cbox));
for (pdat::CellIterator ic(pdat::CellGeometry::begin(cbox));
ic != icend; ++ic) {
double checkval = valfact * (*vardata)(*id, depth) + constval;
pdat::CellIndex check = *ic;
for (int p = 0; p < gbox_to_check.numberCells(idir); ++p) {
double offcheckval = checkval + dxfact * (p + 1);
if ((*vardata)(check, depth) != offcheckval) {
++num_bad_values;
TBOX_WARNING("Bad " << bdry_type_str
<< " boundary value for " << varname
<< " found in cell " << check
<< "\n found = " << (*vardata)(check, depth)
<< " : correct = " << offcheckval << endl);
}
check(idir) += offsign;
}
++id;
}
return num_bad_values;
}
void
CartesianFaceDoubleWeightedAverage::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, coarse_box, ratio);
std::shared_ptr<pdat::FaceData<double> > fdata(
SAMRAI_SHARED_PTR_CAST<pdat::FaceData<double>, hier::PatchData>(
fine.getPatchData(src_component)));
std::shared_ptr<pdat::FaceData<double> > cdata(
SAMRAI_SHARED_PTR_CAST<pdat::FaceData<double>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
const hier::Index& cilo = cdata->getGhostBox().lower();
const hier::Index& cihi = cdata->getGhostBox().upper();
const std::shared_ptr<CartesianPatchGeometry> fgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
const std::shared_ptr<CartesianPatchGeometry> cgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
TBOX_ASSERT(fgeom);
TBOX_ASSERT(cgeom);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
for (int d = 0; d < cdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub1d, CARTWGTAVGFACEDOUB1D) (ifirstc(0),
ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
} else if ((dim == tbox::Dimension(2))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub2d0, CARTWGTAVGFACEDOUB2D0) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub2d1, CARTWGTAVGFACEDOUB2D1) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
} else if ((dim == tbox::Dimension(3))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub3d0, CARTWGTAVGFACEDOUB3D0) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub3d1, CARTWGTAVGFACEDOUB3D1) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub3d2, CARTWGTAVGFACEDOUB3D2) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(2, d),
cdata->getPointer(2, d));
} else if ((dim == tbox::Dimension(4))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d0, CARTWGTAVGFACEDOUB4D0) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d1, CARTWGTAVGFACEDOUB4D1) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d2, CARTWGTAVGFACEDOUB4D2) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(2, d),
cdata->getPointer(2, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d3, CARTWGTAVGFACEDOUB4D3) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(3, d),
cdata->getPointer(3, d));
} else {
TBOX_ERROR("CartesianFaceDoubleWeightedAverage error...\n"
<< "dim > 4 not supported." << std::endl);
}
}
}
void MblkGeometry::buildWedgeGridOnPatch(
const hier::Patch& patch,
const int xyz_id,
const int level_number,
const int block_number)
{
boost::shared_ptr<pdat::NodeData<double> > xyz(
BOOST_CAST<pdat::NodeData<double>, hier::PatchData>(
patch.getPatchData(xyz_id)));
TBOX_ASSERT(xyz);
const hier::Index ifirst = patch.getBox().lower();
const hier::Index ilast = patch.getBox().upper();
hier::IntVector nghost_cells = xyz->getGhostCellWidth();
int nd_imin = ifirst(0) - nghost_cells(0);
int nd_imax = ilast(0) + 1 + nghost_cells(0);
int nd_jmin = ifirst(1) - nghost_cells(1);
int nd_jmax = ilast(1) + 1 + nghost_cells(1);
int nd_nx = nd_imax - nd_imin + 1;
int nd_ny = nd_jmax - nd_jmin + 1;
//int nd_nz = nd_kmax - nd_kmin + 1;
int nd_nxny = nd_nx * nd_ny;
//int nd_nel = nd_nx*nd_ny*nd_nz;
double dx[SAMRAI::MAX_DIM_VAL];
dx[0] = d_dx[level_number][block_number][0];
dx[1] = d_dx[level_number][block_number][1];
double* x = xyz->getPointer(0);
double* y = xyz->getPointer(1);
int nd_kmin;
int nd_kmax;
dx[2] = d_dx[level_number][block_number][2];
double* z = 0;
if (d_dim == tbox::Dimension(3)) {
nd_kmin = ifirst(2) - nghost_cells(2);
nd_kmax = ilast(2) + 1 + nghost_cells(2);
dx[2] = d_dx[level_number][block_number][2];
z = xyz->getPointer(2);
} else {
nd_kmin = 0;
nd_kmax = 0;
}
//
// ----------- set the wedge nodal positions
//
for (int k = nd_kmin; k <= nd_kmax; ++k) {
for (int j = nd_jmin; j <= nd_jmax; ++j) {
for (int i = nd_imin; i <= nd_imax; ++i) {
int ind = POLY3(i, j, k, nd_imin, nd_jmin, nd_kmin, nd_nx, nd_nxny);
double r = d_wedge_rmin[block_number] + dx[0] * (i);
double th = d_wedge_thmin + dx[1] * (j);
double xx = r * cos(th);
double yy = r * sin(th);
x[ind] = xx;
y[ind] = yy;
if (d_dim == tbox::Dimension(3)) {
double zz = d_wedge_zmin + dx[2] * (k);
z[ind] = zz;
}
}
}
}
}
void
CartesianCellDoubleConservativeLinearRefine::refine(
hier::Patch& fine,
const hier::Patch& coarse,
const int dst_component,
const int src_component,
const hier::Box& fine_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, fine_box, ratio);
std::shared_ptr<pdat::CellData<double> > cdata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
coarse.getPatchData(src_component)));
std::shared_ptr<pdat::CellData<double> > fdata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
fine.getPatchData(dst_component)));
TBOX_ASSERT(cdata);
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Box cgbox(cdata->getGhostBox());
const hier::Index& cilo = cgbox.lower();
const hier::Index& cihi = cgbox.upper();
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
const std::shared_ptr<CartesianPatchGeometry> cgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
const std::shared_ptr<CartesianPatchGeometry> fgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
TBOX_ASSERT(cgeom);
TBOX_ASSERT(fgeom);
const hier::Box coarse_box = hier::Box::coarsen(fine_box, ratio);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
const hier::Index& ifirstf = fine_box.lower();
const hier::Index& ilastf = fine_box.upper();
const hier::IntVector tmp_ghosts(dim, 0);
std::vector<double> diff0(cgbox.numberCells(0) + 1);
pdat::CellData<double> slope0(cgbox, 1, tmp_ghosts);
for (int d = 0; d < fdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
SAMRAI_F77_FUNC(cartclinrefcelldoub1d, CARTCLINREFCELLDOUB1D) (ifirstc(0),
ilastc(0),
ifirstf(0), ilastf(0),
cilo(0), cihi(0),
filo(0), fihi(0),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d),
&diff0[0], slope0.getPointer());
} else if ((dim == tbox::Dimension(2))) {
std::vector<double> diff1(cgbox.numberCells(1) + 1);
pdat::CellData<double> slope1(cgbox, 1, tmp_ghosts);
SAMRAI_F77_FUNC(cartclinrefcelldoub2d, CARTCLINREFCELLDOUB2D) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
ifirstf(0), ifirstf(1), ilastf(0), ilastf(1),
cilo(0), cilo(1), cihi(0), cihi(1),
filo(0), filo(1), fihi(0), fihi(1),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d),
&diff0[0], slope0.getPointer(),
&diff1[0], slope1.getPointer());
} else if ((dim == tbox::Dimension(3))) {
std::vector<double> diff1(cgbox.numberCells(1) + 1);
pdat::CellData<double> slope1(cgbox, 1, tmp_ghosts);
std::vector<double> diff2(cgbox.numberCells(2) + 1);
pdat::CellData<double> slope2(cgbox, 1, tmp_ghosts);
SAMRAI_F77_FUNC(cartclinrefcelldoub3d, CARTCLINREFCELLDOUB3D) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d),
&diff0[0], slope0.getPointer(),
&diff1[0], slope1.getPointer(),
&diff2[0], slope2.getPointer());
} else {
TBOX_ERROR("CartesianCellDoubleConservativeLinearRefine error...\n"
<< "dim > 3 not supported." << std::endl);
}
}
}
void SkeletonOutersideDoubleWeightedAverage::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
boost::shared_ptr<pdat::OuterfaceData<double> > fdata(
BOOST_CAST<pdat::OuterfaceData<double>, hier::PatchData>(
fine.getPatchData(src_component)));
boost::shared_ptr<pdat::OuterfaceData<double> > cdata(
BOOST_CAST<pdat::OuterfaceData<double>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Index filo = fdata->getGhostBox().lower();
const hier::Index fihi = fdata->getGhostBox().upper();
const hier::Index cilo = cdata->getGhostBox().lower();
const hier::Index cihi = cdata->getGhostBox().upper();
const boost::shared_ptr<hier::PatchGeometry> fgeom(
fine.getPatchGeometry());
const boost::shared_ptr<hier::PatchGeometry> cgeom(
coarse.getPatchGeometry());
const hier::Index ifirstc = coarse_box.lower();
const hier::Index ilastc = coarse_box.upper();
int flev_num = fine.getPatchLevelNumber();
int clev_num = coarse.getPatchLevelNumber();
// deal with levels not in hierarchy
if (flev_num < 0) flev_num = clev_num + 1;
if (clev_num < 0) clev_num = flev_num - 1;
double cdx[SAMRAI::MAX_DIM_VAL];
double fdx[SAMRAI::MAX_DIM_VAL];
getDx(clev_num, cdx);
getDx(flev_num, fdx);
for (int d = 0; d < cdata->getDepth(); ++d) {
// loop over lower and upper outerside arrays
for (int i = 0; i < 2; ++i) {
if (d_dim == tbox::Dimension(1)) {
SAMRAI_F77_FUNC(cartwgtavgoutfacedoub1d, CARTWGTAVGOUTFACEDOUB1D) (
ifirstc(0), ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fdx,
cdx,
fdata->getPointer(0, i, d),
cdata->getPointer(0, i, d));
} else if (d_dim == tbox::Dimension(2)) {
SAMRAI_F77_FUNC(cartwgtavgoutfacedoub2d0, CARTWGTAVGOUTFACEDOUB2D0) (
ifirstc(0), ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fdx,
cdx,
fdata->getPointer(0, i, d),
cdata->getPointer(0, i, d));
SAMRAI_F77_FUNC(cartwgtavgoutfacedoub2d1, CARTWGTAVGOUTFACEDOUB2D1) (
ifirstc(0), ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fdx,
cdx,
fdata->getPointer(1, i, d),
cdata->getPointer(1, i, d));
} else if (d_dim == tbox::Dimension(3)) {
SAMRAI_F77_FUNC(cartwgtavgoutfacedoub3d0, CARTWGTAVGOUTFACEDOUB3D0) (
ifirstc(0), ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdx,
cdx,
fdata->getPointer(0, i, d),
cdata->getPointer(0, i, d));
SAMRAI_F77_FUNC(cartwgtavgoutfacedoub3d1, CARTWGTAVGOUTFACEDOUB3D1) (
ifirstc(0), ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdx,
cdx,
fdata->getPointer(1, i, d),
cdata->getPointer(1, i, d));
SAMRAI_F77_FUNC(cartwgtavgoutfacedoub3d2, CARTWGTAVGOUTFACEDOUB3D2) (
ifirstc(0), ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdx,
cdx,
fdata->getPointer(2, i, d),
cdata->getPointer(2, i, d));
} else {
TBOX_ERROR("SkeletonOutersideDoubleWeightedAverage error...\n"
<< "d_dim > 3 not supported." << endl);
}
}
}
}
/*
*************************************************************************
*
* Verify results of communication operations. This test must be
* consistent with data initialization and boundary operations above.
*
*************************************************************************
*/
bool EdgeMultiblockTest::verifyResults(
const hier::Patch& patch,
const std::shared_ptr<hier::PatchHierarchy> hierarchy,
const int level_number,
const hier::BlockId& block_id)
{
tbox::plog << "\nEntering EdgeMultiblockTest::verifyResults..." << endl;
tbox::plog << "level_number = " << level_number << endl;
tbox::plog << "Patch box = " << patch.getBox() << endl;
hier::IntVector tgcw(d_dim, 0);
for (int i = 0; i < static_cast<int>(d_variables.size()); ++i) {
tgcw.max(patch.getPatchData(d_variables[i], getDataContext())->
getGhostCellWidth());
}
hier::Box pbox = patch.getBox();
std::shared_ptr<pdat::EdgeData<double> > solution(
new pdat::EdgeData<double>(pbox, 1, tgcw));
hier::Box tbox(pbox);
tbox.grow(tgcw);
std::shared_ptr<hier::BaseGridGeometry> grid_geom(
hierarchy->getGridGeometry());
hier::BoxContainer singularity(
grid_geom->getSingularityBoxContainer(block_id));
hier::IntVector ratio =
hierarchy->getPatchLevel(level_number)->getRatioToLevelZero();
singularity.refine(ratio);
bool test_failed = false;
for (int i = 0; i < static_cast<int>(d_variables.size()); ++i) {
double correct = (double)block_id.getBlockValue();
std::shared_ptr<pdat::EdgeData<double> > edge_data(
SAMRAI_SHARED_PTR_CAST<pdat::EdgeData<double>, hier::PatchData>(
patch.getPatchData(d_variables[i], getDataContext())));
TBOX_ASSERT(edge_data);
int depth = edge_data->getDepth();
hier::Box interior_box(pbox);
interior_box.grow(hier::IntVector(d_dim, -1));
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
pdat::EdgeIterator ciend(pdat::EdgeGeometry::end(interior_box, axis));
for (pdat::EdgeIterator ci(pdat::EdgeGeometry::begin(interior_box, axis));
ci != ciend; ++ci) {
for (int d = 0; d < depth; ++d) {
double result = (*edge_data)(*ci, d);
if (!tbox::MathUtilities<double>::equalEps(correct, result)) {
tbox::perr << "Test FAILED: ...."
<< " : edge index = " << *ci << endl;
tbox::perr << " Variable = " << d_variable_src_name[i]
<< " : depth index = " << d << endl;
tbox::perr << " result = " << result
<< " : correct = " << correct << endl;
test_failed = true;
}
}
}
}
hier::Box gbox = edge_data->getGhostBox();
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box patch_edge_box =
pdat::EdgeGeometry::toEdgeBox(pbox, axis);
hier::BoxContainer tested_neighbors;
hier::BoxContainer sing_edge_boxlist;
for (hier::BoxContainer::iterator si = singularity.begin();
si != singularity.end(); ++si) {
sing_edge_boxlist.pushFront(
pdat::EdgeGeometry::toEdgeBox(*si, axis));
}
for (hier::BaseGridGeometry::ConstNeighborIterator ne(
grid_geom->begin(block_id));
ne != grid_geom->end(block_id); ++ne) {
const hier::BaseGridGeometry::Neighbor& nbr = *ne;
if (nbr.isSingularity()) {
continue;
}
correct = nbr.getBlockId().getBlockValue();
hier::BoxContainer neighbor_ghost(nbr.getTransformedDomain());
hier::BoxContainer neighbor_edge_ghost;
for (hier::BoxContainer::iterator nn = neighbor_ghost.begin();
nn != neighbor_ghost.end(); ++nn) {
hier::Box neighbor_ghost_interior(
pdat::EdgeGeometry::toEdgeBox(*nn, axis));
neighbor_ghost_interior.grow(-hier::IntVector::getOne(d_dim));
neighbor_edge_ghost.pushFront(neighbor_ghost_interior);
}
neighbor_edge_ghost.refine(ratio);
neighbor_edge_ghost.intersectBoxes(
pdat::EdgeGeometry::toEdgeBox(gbox, axis));
neighbor_edge_ghost.removeIntersections(sing_edge_boxlist);
neighbor_edge_ghost.removeIntersections(tested_neighbors);
for (hier::BoxContainer::iterator ng = neighbor_edge_ghost.begin();
ng != neighbor_edge_ghost.end(); ++ng) {
hier::Box::iterator ciend(ng->end());
for (hier::Box::iterator ci(ng->begin()); ci != ciend; ++ci) {
pdat::EdgeIndex ei(*ci, 0, 0);
ei.setAxis(axis);
if (!patch_edge_box.contains(ei)) {
for (int d = 0; d < depth; ++d) {
double result = (*edge_data)(ei, d);
if (!tbox::MathUtilities<double>::equalEps(correct,
result)) {
tbox::perr << "Test FAILED: ...."
<< " : edge index = " << ei << endl;
tbox::perr << " Variable = "
<< d_variable_src_name[i]
<< " : depth index = " << d << endl;
tbox::perr << " result = " << result
<< " : correct = " << correct << endl;
test_failed = true;
}
}
}
}
}
tested_neighbors.spliceBack(neighbor_edge_ghost);
}
}
std::shared_ptr<hier::PatchGeometry> pgeom(patch.getPatchGeometry());
for (int b = 0; b < d_dim.getValue(); ++b) {
const std::vector<hier::BoundaryBox>& bdry =
pgeom->getCodimensionBoundaries(b + 1);
for (int k = 0; k < static_cast<int>(bdry.size()); ++k) {
hier::Box fill_box = pgeom->getBoundaryFillBox(bdry[k],
patch.getBox(),
tgcw);
fill_box = fill_box * gbox;
if (bdry[k].getIsMultiblockSingularity()) {
correct = 0.0;
int num_sing_neighbors = 0;
for (hier::BaseGridGeometry::ConstNeighborIterator ns(
grid_geom->begin(block_id));
ns != grid_geom->end(block_id); ++ns) {
const hier::BaseGridGeometry::Neighbor& nbr = *ns;
if (nbr.isSingularity()) {
hier::BoxContainer neighbor_ghost(
nbr.getTransformedDomain());
neighbor_ghost.refine(ratio);
neighbor_ghost.intersectBoxes(fill_box);
if (neighbor_ghost.size()) {
++num_sing_neighbors;
correct += nbr.getBlockId().getBlockValue();
}
}
}
if (num_sing_neighbors == 0) {
correct = (double)bdry[k].getLocationIndex() + 200.0;
} else {
correct /= (double)num_sing_neighbors;
}
} else {
correct = (double)(bdry[k].getLocationIndex() + 100);
}
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box patch_edge_box =
pdat::EdgeGeometry::toEdgeBox(pbox, axis);
pdat::EdgeIterator ciend(pdat::EdgeGeometry::end(fill_box, axis));
for (pdat::EdgeIterator ci(pdat::EdgeGeometry::begin(fill_box, axis));
ci != ciend; ++ci) {
if (!patch_edge_box.contains(*ci)) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n && bdry[k].getBox().numberCells(n) ==
1) {
if ((*ci)(n) == patch_edge_box.lower() (n) ||
(*ci)(n) == patch_edge_box.upper() (n)) {
use_index = false;
break;
}
}
}
if (use_index) {
for (int d = 0; d < depth; ++d) {
double result = (*edge_data)(*ci, d);
if (!tbox::MathUtilities<double>::equalEps(correct,
result)) {
tbox::perr << "Test FAILED: ...."
<< " : edge index = " << *ci << endl;
tbox::perr << " Variable = "
<< d_variable_src_name[i]
<< " : depth index = " << d << endl;
tbox::perr << " result = " << result
<< " : correct = " << correct << endl;
test_failed = true;
}
}
}
}
}
}
}
}
}
if (!test_failed) {
tbox::plog << "EdgeMultiblockTest Successful!" << endl;
} else {
tbox::perr << "Multiblock EdgeMultiblockTest FAILED: \n" << endl;
}
solution.reset(); // just to be anal...
tbox::plog << "\nExiting EdgeMultiblockTest::verifyResults..." << endl;
tbox::plog << "level_number = " << level_number << endl;
tbox::plog << "Patch box = " << patch.getBox() << endl << endl;
return !test_failed;
}
void
CartesianNodeComplexLinearRefine::refine(
hier::Patch& fine,
const hier::Patch& coarse,
const int dst_component,
const int src_component,
const hier::Box& fine_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, fine_box, ratio);
boost::shared_ptr<pdat::NodeData<dcomplex> > cdata(
BOOST_CAST<pdat::NodeData<dcomplex>, hier::PatchData>(
coarse.getPatchData(src_component)));
boost::shared_ptr<pdat::NodeData<dcomplex> > fdata(
BOOST_CAST<pdat::NodeData<dcomplex>, hier::PatchData>(
fine.getPatchData(dst_component)));
TBOX_ASSERT(cdata);
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Box cgbox(cdata->getGhostBox());
const hier::Index cilo = cgbox.lower();
const hier::Index cihi = cgbox.upper();
const hier::Index filo = fdata->getGhostBox().lower();
const hier::Index fihi = fdata->getGhostBox().upper();
const boost::shared_ptr<CartesianPatchGeometry> cgeom(
BOOST_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
const boost::shared_ptr<CartesianPatchGeometry> fgeom(
BOOST_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
TBOX_ASSERT(cgeom);
TBOX_ASSERT(fgeom);
const hier::Box coarse_box = hier::Box::coarsen(fine_box, ratio);
const hier::Index ifirstc = coarse_box.lower();
const hier::Index ilastc = coarse_box.upper();
const hier::Index ifirstf = fine_box.lower();
const hier::Index ilastf = fine_box.upper();
for (int d = 0; d < fdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
SAMRAI_F77_FUNC(cartlinrefnodecplx1d, CARTLINREFNODECPLX1D) (ifirstc(0),
ilastc(0),
ifirstf(0), ilastf(0),
cilo(0), cihi(0),
filo(0), fihi(0),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d));
} else if ((dim == tbox::Dimension(2))) {
SAMRAI_F77_FUNC(cartlinrefnodecplx2d, CARTLINREFNODECPLX2D) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
ifirstf(0), ifirstf(1), ilastf(0), ilastf(1),
cilo(0), cilo(1), cihi(0), cihi(1),
filo(0), filo(1), fihi(0), fihi(1),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d));
} else if ((dim == tbox::Dimension(3))) {
SAMRAI_F77_FUNC(cartlinrefnodecplx3d, CARTLINREFNODECPLX3D) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d));
} else {
TBOX_ERROR("CartesianNodeComplexLinearRefine error...\n"
<< "dim > 3 not supported." << std::endl);
}
}
}
void
CartesianSideFloatWeightedAverage::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, coarse_box, ratio);
std::shared_ptr<pdat::SideData<float> > fdata(
SAMRAI_SHARED_PTR_CAST<pdat::SideData<float>, hier::PatchData>(
fine.getPatchData(src_component)));
std::shared_ptr<pdat::SideData<float> > cdata(
SAMRAI_SHARED_PTR_CAST<pdat::SideData<float>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::IntVector& directions = cdata->getDirectionVector();
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, fdata->getDirectionVector()));
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
const hier::Index& cilo = cdata->getGhostBox().lower();
const hier::Index& cihi = cdata->getGhostBox().upper();
const std::shared_ptr<CartesianPatchGeometry> fgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
const std::shared_ptr<CartesianPatchGeometry> cgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
TBOX_ASSERT(fgeom);
TBOX_ASSERT(cgeom);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
for (int d = 0; d < cdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
if (directions(0)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot1d, CARTWGTAVGSIDEFLOT1D) (ifirstc(0),
ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
}
} else if ((dim == tbox::Dimension(2))) {
if (directions(0)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot2d0, CARTWGTAVGSIDEFLOT2D0) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
}
if (directions(1)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot2d1, CARTWGTAVGSIDEFLOT2D1) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
}
} else if ((dim == tbox::Dimension(3))) {
if (directions(0)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot3d0, CARTWGTAVGSIDEFLOT3D0) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
}
if (directions(1)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot3d1, CARTWGTAVGSIDEFLOT3D1) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
}
if (directions(2)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot3d2, CARTWGTAVGSIDEFLOT3D2) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(2, d),
cdata->getPointer(2, d));
}
} else {
TBOX_ERROR("CartesianSideFloatWeightedAverage error...\n"
<< "dim > 3 not supported." << std::endl);
}
}
}
void BoundaryDataTester::checkBoundaryData(
int btype,
const hier::Patch& patch,
const hier::IntVector& ghost_width_to_check)
{
#ifdef DEBUG_CHECK_ASSERTIONS
if (d_dim == tbox::Dimension(2)) {
TBOX_ASSERT(btype == Bdry::EDGE2D ||
btype == Bdry::NODE2D);
}
if (d_dim == tbox::Dimension(3)) {
TBOX_ASSERT(btype == Bdry::FACE3D ||
btype == Bdry::EDGE3D ||
btype == Bdry::NODE3D);
}
#endif
const std::shared_ptr<geom::CartesianPatchGeometry> pgeom(
SAMRAI_SHARED_PTR_CAST<geom::CartesianPatchGeometry, hier::PatchGeometry>(
patch.getPatchGeometry()));
TBOX_ASSERT(pgeom);
const std::vector<hier::BoundaryBox>& bdry_boxes =
pgeom->getCodimensionBoundaries(btype);
for (int i = 0; i < static_cast<int>(bdry_boxes.size()); ++i) {
hier::BoundaryBox bbox = bdry_boxes[i];
TBOX_ASSERT(bbox.getBoundaryType() == btype);
int bloc = bbox.getLocationIndex();
for (int iv = 0; iv < static_cast<int>(d_variables.size()); ++iv) {
std::shared_ptr<pdat::CellData<double> > cvdata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
patch.getPatchData(d_variables[iv], d_variable_context)));
TBOX_ASSERT(cvdata);
int depth = d_variable_depth[iv];
int bscalarcase = 0;
int bvectorcase = 0;
int refbdryloc = 0;
if (d_dim == tbox::Dimension(2)) {
if (btype == Bdry::EDGE2D) {
bscalarcase = d_scalar_bdry_edge_conds[bloc];
bvectorcase = d_vector_bdry_edge_conds[bloc];
refbdryloc = bloc;
} else { // btype == Bdry::NODE2D
bscalarcase = d_scalar_bdry_node_conds[bloc];
bvectorcase = d_vector_bdry_node_conds[bloc];
refbdryloc = d_node_bdry_edge[bloc];
}
}
if (d_dim == tbox::Dimension(3)) {
if (btype == Bdry::FACE3D) {
bscalarcase = d_scalar_bdry_face_conds[bloc];
bvectorcase = d_vector_bdry_face_conds[bloc];
refbdryloc = bloc;
} else if (btype == Bdry::EDGE3D) {
bscalarcase = d_scalar_bdry_edge_conds[bloc];
bvectorcase = d_vector_bdry_edge_conds[bloc];
refbdryloc = d_edge_bdry_face[bloc];
} else { // btype == Bdry::NODE3D
bscalarcase = d_scalar_bdry_node_conds[bloc];
bvectorcase = d_vector_bdry_node_conds[bloc];
refbdryloc = d_node_bdry_face[bloc];
}
}
int data_id = hier::VariableDatabase::getDatabase()->
mapVariableAndContextToIndex(d_variables[iv], d_variable_context);
int num_bad_values = 0;
if (depth == 1) {
if (d_dim == tbox::Dimension(2)) {
num_bad_values =
appu::CartesianBoundaryUtilities2::
checkBdryData(d_variable_name[iv],
patch,
data_id,
0,
ghost_width_to_check,
bbox,
bscalarcase,
d_variable_bc_values[iv][refbdryloc]);
}
if (d_dim == tbox::Dimension(3)) {
num_bad_values =
appu::CartesianBoundaryUtilities3::
checkBdryData(d_variable_name[iv],
patch,
data_id,
0,
ghost_width_to_check,
bbox,
bscalarcase,
d_variable_bc_values[iv][refbdryloc]);
}
#if (TESTING == 1)
if (num_bad_values > 0) {
++d_fail_count;
tbox::perr << "\nBoundary Test FAILED: \n"
<< " " << num_bad_values << " bad "
<< d_variable_name[iv] << " values found for"
<< " boundary type " << btype
<< " at location "
<< bloc << endl;
}
#endif
} else {
for (int id = 0; id < depth; ++id) {
int vbcase = bscalarcase;
if (d_dim == tbox::Dimension(2)) {
if (btype == Bdry::EDGE2D) {
if ((id == 0 && (bloc == BdryLoc::XLO ||
bloc == BdryLoc::XHI)) ||
(id == 1 && (bloc == BdryLoc::YLO ||
bloc == BdryLoc::YHI))) {
vbcase = bvectorcase;
}
} else {
if ((id == 0 && bvectorcase == BdryCond::XREFLECT) ||
(id == 1 && bvectorcase == BdryCond::YREFLECT)) {
vbcase = bvectorcase;
}
}
}
if (d_dim == tbox::Dimension(3)) {
if (btype == Bdry::FACE3D) {
if ((id == 0 && (bloc == BdryLoc::XLO ||
bloc == BdryLoc::XHI)) ||
(id == 1 && (bloc == BdryLoc::YLO ||
bloc == BdryLoc::YHI)) ||
(id == 2 && (bloc == BdryLoc::ZLO ||
bloc == BdryLoc::ZHI))) {
vbcase = bvectorcase;
}
} else {
if ((id == 0 && bvectorcase == BdryCond::XREFLECT) ||
(id == 1 && bvectorcase == BdryCond::YREFLECT) ||
(id == 2 && bvectorcase == BdryCond::ZREFLECT)) {
vbcase = bvectorcase;
}
}
}
if (d_dim == tbox::Dimension(2)) {
num_bad_values =
appu::CartesianBoundaryUtilities2::
checkBdryData(d_variable_name[iv],
patch,
data_id,
id,
ghost_width_to_check,
bbox,
vbcase,
d_variable_bc_values[iv][refbdryloc * depth + id]);
}
if (d_dim == tbox::Dimension(3)) {
num_bad_values =
appu::CartesianBoundaryUtilities3::
checkBdryData(d_variable_name[iv],
patch,
data_id,
id,
ghost_width_to_check,
bbox,
vbcase,
d_variable_bc_values[iv][refbdryloc * depth + id]);
}
#if (TESTING == 1)
if (num_bad_values > 0) {
++d_fail_count;
tbox::perr << "\nBoundary Test FAILED: \n"
<< " " << num_bad_values << " bad "
<< d_variable_name[iv] << " values found for"
<< " boundary type " << btype
<< " at location "
<< bloc << endl;
}
#endif
} // for (int id = 0; id < depth; ++id)
} // else
} // for (int iv = 0; iv < static_cast<int>(d_variables.size()); ++iv)
} // for (int i = 0; i < static_cast<int>(bdry_boxes.size()); ++i )
}
void BoundaryDataTester::setPhysicalBoundaryConditions(
hier::Patch& patch,
const double fill_time,
const hier::IntVector& ghost_width_to_fill)
{
NULL_USE(fill_time);
tbox::plog << "\n\nFilling boundary data on patch = " << patch.getBox()
<< endl;
tbox::plog << "ghost_width_to_fill = " << ghost_width_to_fill << endl;
for (int iv = 0; iv < static_cast<int>(d_variables.size()); ++iv) {
std::shared_ptr<pdat::CellData<double> > cvdata(
SAMRAI_SHARED_PTR_CAST<pdat::CellData<double>, hier::PatchData>(
patch.getPatchData(d_variables[iv], d_variable_context)));
TBOX_ASSERT(cvdata);
tbox::plog << "\n iv = " << iv << " : " << d_variable_name[iv] << endl;
tbox::plog << " depth = " << cvdata->getDepth() << endl;
hier::IntVector fill_gcw(hier::IntVector::min(cvdata->getGhostCellWidth(),
ghost_width_to_fill));
if (d_dim == tbox::Dimension(3)) {
appu::CartesianBoundaryUtilities3::
fillFaceBoundaryData(d_variable_name[iv], cvdata,
patch,
fill_gcw,
((cvdata->getDepth() > 1) ?
d_vector_bdry_face_conds :
d_scalar_bdry_face_conds),
d_variable_bc_values[iv]);
appu::CartesianBoundaryUtilities3::
fillEdgeBoundaryData(d_variable_name[iv], cvdata,
patch,
fill_gcw,
((cvdata->getDepth() > 1) ?
d_vector_bdry_edge_conds :
d_scalar_bdry_edge_conds),
d_variable_bc_values[iv]);
appu::CartesianBoundaryUtilities3::
fillNodeBoundaryData(d_variable_name[iv], cvdata,
patch,
fill_gcw,
((cvdata->getDepth() > 1) ?
d_vector_bdry_node_conds :
d_scalar_bdry_node_conds),
d_variable_bc_values[iv]);
}
if (d_dim == tbox::Dimension(2)) {
appu::CartesianBoundaryUtilities2::
fillEdgeBoundaryData(d_variable_name[iv], cvdata,
patch,
fill_gcw,
((cvdata->getDepth() > 1) ?
d_vector_bdry_edge_conds :
d_scalar_bdry_edge_conds),
d_variable_bc_values[iv]);
appu::CartesianBoundaryUtilities2::
fillNodeBoundaryData(d_variable_name[iv], cvdata,
patch,
fill_gcw,
((cvdata->getDepth() > 1) ?
d_vector_bdry_node_conds :
d_scalar_bdry_node_conds),
d_variable_bc_values[iv]);
}
}
if (d_dim == tbox::Dimension(2)) {
checkBoundaryData(Bdry::EDGE2D, patch, ghost_width_to_fill);
checkBoundaryData(Bdry::NODE2D, patch, ghost_width_to_fill);
}
if (d_dim == tbox::Dimension(3)) {
checkBoundaryData(Bdry::FACE3D, patch, ghost_width_to_fill);
checkBoundaryData(Bdry::EDGE3D, patch, ghost_width_to_fill);
checkBoundaryData(Bdry::NODE3D, patch, ghost_width_to_fill);
}
}
void
OuternodeDoubleInjection::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
boost::shared_ptr<OuternodeData<double> > fdata(
BOOST_CAST<OuternodeData<double>, hier::PatchData>(
fine.getPatchData(src_component)));
boost::shared_ptr<OuternodeData<double> > cdata(
BOOST_CAST<OuternodeData<double>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
TBOX_ASSERT_OBJDIM_EQUALITY4(coarse, fine, coarse_box, ratio);
const hier::Index filo = fine.getBox().lower();
const hier::Index fihi = fine.getBox().upper();
const hier::Index cilo = coarse.getBox().lower();
const hier::Index cihi = coarse.getBox().upper();
const hier::Index ifirstc = coarse_box.lower();
const hier::Index ilastc = coarse_box.upper();
for (int i = 0; i < 2; ++i) {
for (int axis = 0; axis < dim.getValue(); ++axis) {
if (cdata->dataExists(axis)) {
for (int d = 0; d < cdata->getDepth(); ++d) {
if (dim == tbox::Dimension(1)) {
SAMRAI_F77_FUNC(conavgouternodedoub1d,
CONAVGOUTERNODEDOUB1D) (ifirstc(0), ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
} else if (dim == tbox::Dimension(2)) {
if (axis == 0) {
SAMRAI_F77_FUNC(conavgouternodedoub2d0,
CONAVGOUTERNODEDOUB2D0) (ifirstc(0), ifirstc(1),
ilastc(0), ilastc(1),
filo(0), filo(1),
fihi(0), fihi(1),
cilo(0), cilo(1),
cihi(0), cihi(1),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
if (axis == 1) {
SAMRAI_F77_FUNC(conavgouternodedoub2d1,
CONAVGOUTERNODEDOUB2D1) (ifirstc(0), ifirstc(1),
ilastc(0), ilastc(1),
filo(0), filo(1),
fihi(0), fihi(1),
cilo(0), cilo(1),
cihi(0), cihi(1),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
} else if (dim == tbox::Dimension(3)) {
if (axis == 0) {
SAMRAI_F77_FUNC(conavgouternodedoub3d0,
CONAVGOUTERNODEDOUB3D0) (ifirstc(0), ifirstc(1),
ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
if (axis == 1) {
SAMRAI_F77_FUNC(conavgouternodedoub3d1,
CONAVGOUTERNODEDOUB3D1) (ifirstc(0), ifirstc(1),
ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
if (axis == 2) {
SAMRAI_F77_FUNC(conavgouternodedoub3d2,
CONAVGOUTERNODEDOUB3D2) (ifirstc(0), ifirstc(1),
ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
}
}
}
}
}
}
void EdgeMultiblockTest::fillSingularityBoundaryConditions(
hier::Patch& patch,
const hier::PatchLevel& encon_level,
std::shared_ptr<const hier::Connector> dst_to_encon,
const hier::Box& fill_box,
const hier::BoundaryBox& bbox,
const std::shared_ptr<hier::BaseGridGeometry>& grid_geometry)
{
const tbox::Dimension& dim = fill_box.getDim();
const hier::BoxId& dst_mb_id = patch.getBox().getBoxId();
const hier::BlockId& patch_blk_id = patch.getBox().getBlockId();
for (int i = 0; i < static_cast<int>(d_variables.size()); ++i) {
std::shared_ptr<pdat::EdgeData<double> > edge_data(
SAMRAI_SHARED_PTR_CAST<pdat::EdgeData<double>, hier::PatchData>(
patch.getPatchData(d_variables[i], getDataContext())));
TBOX_ASSERT(edge_data);
hier::Box sing_fill_box(edge_data->getGhostBox() * fill_box);
int depth = edge_data->getDepth();
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box pbox = pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis);
hier::Index plower(pbox.lower());
hier::Index pupper(pbox.upper());
pdat::EdgeIterator niend(pdat::EdgeGeometry::end(sing_fill_box, axis));
for (pdat::EdgeIterator ni(pdat::EdgeGeometry::begin(sing_fill_box, axis));
ni != niend; ++ni) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n && bbox.getBox().numberCells(n) == 1) {
if ((*ni)(n) == plower(n) || (*ni)(n) == pupper(n)) {
use_index = false;
break;
}
}
}
if (use_index) {
for (int d = 0; d < depth; ++d) {
(*edge_data)(*ni, d) = 0.0;
}
}
}
}
int num_encon_used = 0;
if (grid_geometry->hasEnhancedConnectivity()) {
hier::Connector::ConstNeighborhoodIterator ni =
dst_to_encon->findLocal(dst_mb_id);
if (ni != dst_to_encon->end()) {
for (hier::Connector::ConstNeighborIterator ei = dst_to_encon->begin(ni);
ei != dst_to_encon->end(ni); ++ei) {
const hier::BlockId& encon_blk_id = ei->getBlockId();
std::shared_ptr<hier::Patch> encon_patch(
encon_level.getPatch(ei->getBoxId()));
hier::Transformation::RotationIdentifier rotation =
hier::Transformation::NO_ROTATE;
hier::IntVector offset(dim);
hier::BaseGridGeometry::ConstNeighborIterator itr =
grid_geometry->find(patch_blk_id, encon_blk_id);
if (itr != grid_geometry->end(patch_blk_id)) {
rotation = (*itr).getRotationIdentifier();
offset = (*itr).getShift(encon_level.getLevelNumber());
}
hier::Transformation transformation(rotation, offset,
encon_blk_id,
patch_blk_id);
hier::Box encon_patch_box(encon_patch->getBox());
transformation.transform(encon_patch_box);
hier::Box encon_fill_box(encon_patch_box * sing_fill_box);
if (!encon_fill_box.empty()) {
const hier::Transformation::RotationIdentifier back_rotate =
hier::Transformation::getReverseRotationIdentifier(
rotation, dim);
hier::IntVector back_shift(dim);
hier::Transformation::calculateReverseShift(
back_shift, offset, rotation);
hier::Transformation back_trans(back_rotate, back_shift,
patch_blk_id,
encon_blk_id);
std::shared_ptr<pdat::EdgeData<double> > sing_data(
SAMRAI_SHARED_PTR_CAST<pdat::EdgeData<double>, hier::PatchData>(
encon_patch->getPatchData(
d_variables[i], getDataContext())));
TBOX_ASSERT(sing_data);
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box pbox(
pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis));
hier::Index plower(pbox.lower());
hier::Index pupper(pbox.upper());
pdat::EdgeIterator ciend(pdat::EdgeGeometry::end(sing_fill_box, axis));
for (pdat::EdgeIterator ci(pdat::EdgeGeometry::begin(sing_fill_box, axis));
ci != ciend; ++ci) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n && bbox.getBox().numberCells(n) == 1) {
if ((*ci)(n) == plower(n) || (*ci)(n) == pupper(n)) {
use_index = false;
break;
}
}
}
if (use_index) {
pdat::EdgeIndex src_index(*ci);
pdat::EdgeGeometry::transform(src_index, back_trans);
for (int d = 0; d < depth; ++d) {
(*edge_data)(*ci, d) += (*sing_data)(src_index, d);
}
}
}
}
++num_encon_used;
}
}
}
}
if (num_encon_used) {
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box pbox =
pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis);
hier::Index plower(pbox.lower());
hier::Index pupper(pbox.upper());
pdat::EdgeIterator ciend(pdat::EdgeGeometry::end(sing_fill_box, axis));
for (pdat::EdgeIterator ci(pdat::EdgeGeometry::begin(sing_fill_box, axis));
ci != ciend; ++ci) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n && bbox.getBox().numberCells(n) == 1) {
if ((*ci)(n) == plower(n) || (*ci)(n) == pupper(n)) {
use_index = false;
break;
}
}
}
if (use_index) {
for (int d = 0; d < depth; ++d) {
(*edge_data)(*ci, d) /= num_encon_used;
}
}
}
}
} else {
/*
* In cases of reduced connectivity, there are no other blocks
* from which to acquire data.
*/
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box pbox =
pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis);
hier::Index plower(pbox.lower());
hier::Index pupper(pbox.upper());
pdat::EdgeIterator ciend(pdat::EdgeGeometry::end(sing_fill_box, axis));
for (pdat::EdgeIterator ci(pdat::EdgeGeometry::begin(sing_fill_box, axis));
ci != ciend; ++ci) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n && bbox.getBox().numberCells(n) == 1) {
if ((*ci)(n) == plower(n) || (*ci)(n) == pupper(n)) {
use_index = false;
break;
}
}
}
if (use_index) {
for (int d = 0; d < depth; ++d) {
(*edge_data)(*ci, d) =
(double)bbox.getLocationIndex() + 200.0;
}
}
}
}
}
}
}
void EdgeMultiblockTest::setPhysicalBoundaryConditions(
hier::Patch& patch,
const double time,
const hier::IntVector& gcw_to_fill) const
{
NULL_USE(time);
std::shared_ptr<hier::PatchGeometry> pgeom(patch.getPatchGeometry());
const std::vector<hier::BoundaryBox>& node_bdry =
pgeom->getCodimensionBoundaries(d_dim.getValue());
const int num_node_bdry_boxes = static_cast<int>(node_bdry.size());
std::vector<hier::BoundaryBox> empty_vector(0, hier::BoundaryBox(d_dim));
const std::vector<hier::BoundaryBox>& edge_bdry =
d_dim > tbox::Dimension(1) ?
pgeom->getCodimensionBoundaries(d_dim.getValue() - 1) : empty_vector;
const int num_edge_bdry_boxes = static_cast<int>(edge_bdry.size());
const std::vector<hier::BoundaryBox>& face_bdry =
d_dim == tbox::Dimension(3) ?
pgeom->getCodimensionBoundaries(d_dim.getValue() - 2) : empty_vector;
const int num_face_bdry_boxes = static_cast<int>(face_bdry.size());
for (int i = 0; i < static_cast<int>(d_variables.size()); ++i) {
std::shared_ptr<pdat::EdgeData<double> > edge_data(
SAMRAI_SHARED_PTR_CAST<pdat::EdgeData<double>, hier::PatchData>(
patch.getPatchData(d_variables[i], getDataContext())));
TBOX_ASSERT(edge_data);
/*
* Set node boundary data.
*/
for (int nb = 0; nb < num_node_bdry_boxes; ++nb) {
hier::Box fill_box = pgeom->getBoundaryFillBox(node_bdry[nb],
patch.getBox(),
gcw_to_fill);
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box patch_edge_box =
pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis);
if (!node_bdry[nb].getIsMultiblockSingularity()) {
pdat::EdgeIterator niend(pdat::EdgeGeometry::end(fill_box, axis));
for (pdat::EdgeIterator ni(pdat::EdgeGeometry::begin(fill_box, axis));
ni != niend; ++ni) {
if (!patch_edge_box.contains(*ni)) {
for (int d = 0; d < edge_data->getDepth(); ++d) {
(*edge_data)(*ni, d) =
(double)(node_bdry[nb].getLocationIndex() + 100);
}
}
}
}
}
}
if (d_dim > tbox::Dimension(1)) {
/*
* Set edge boundary data.
*/
for (int eb = 0; eb < num_edge_bdry_boxes; ++eb) {
hier::Box fill_box = pgeom->getBoundaryFillBox(edge_bdry[eb],
patch.getBox(),
gcw_to_fill);
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box patch_edge_box =
pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis);
hier::Index plower(patch_edge_box.lower());
hier::Index pupper(patch_edge_box.upper());
if (!edge_bdry[eb].getIsMultiblockSingularity()) {
pdat::EdgeIterator niend(pdat::EdgeGeometry::end(fill_box, axis));
for (pdat::EdgeIterator ni(pdat::EdgeGeometry::begin(fill_box, axis));
ni != niend; ++ni) {
if (!patch_edge_box.contains(*ni)) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n &&
edge_bdry[eb].getBox().numberCells(n) == 1) {
if ((*ni)(n) == plower(n) || (*ni)(n) ==
pupper(n)) {
use_index = false;
break;
}
}
}
if (use_index) {
for (int d = 0; d < edge_data->getDepth(); ++d) {
(*edge_data)(*ni, d) =
(double)(edge_bdry[eb].getLocationIndex()
+ 100);
}
}
}
}
}
}
}
}
if (d_dim == tbox::Dimension(3)) {
/*
* Set face boundary data.
*/
for (int fb = 0; fb < num_face_bdry_boxes; ++fb) {
hier::Box fill_box = pgeom->getBoundaryFillBox(face_bdry[fb],
patch.getBox(),
gcw_to_fill);
for (int axis = 0; axis < d_dim.getValue(); ++axis) {
hier::Box patch_edge_box =
pdat::EdgeGeometry::toEdgeBox(patch.getBox(), axis);
hier::Index plower(patch_edge_box.lower());
hier::Index pupper(patch_edge_box.upper());
if (!face_bdry[fb].getIsMultiblockSingularity()) {
pdat::EdgeIterator niend(pdat::EdgeGeometry::end(fill_box, axis));
for (pdat::EdgeIterator ni(pdat::EdgeGeometry::begin(fill_box, axis));
ni != niend; ++ni) {
if (!patch_edge_box.contains(*ni)) {
bool use_index = true;
for (tbox::Dimension::dir_t n = 0; n < d_dim.getValue(); ++n) {
if (axis != n &&
face_bdry[fb].getBox().numberCells(n) == 1) {
if ((*ni)(n) == plower(n) || (*ni)(n) ==
pupper(n)) {
use_index = false;
break;
}
}
}
if (use_index) {
(*edge_data)(*ni) =
(double)(face_bdry[fb].getLocationIndex() + 100);
}
}
}
}
}
}
}
}
}
void
EdgeFloatConstantRefine::refine(
hier::Patch& fine,
const hier::Patch& coarse,
const int dst_component,
const int src_component,
const hier::BoxOverlap& fine_overlap,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
std::shared_ptr<EdgeData<float> > cdata(
SAMRAI_SHARED_PTR_CAST<EdgeData<float>, hier::PatchData>(
coarse.getPatchData(src_component)));
std::shared_ptr<EdgeData<float> > fdata(
SAMRAI_SHARED_PTR_CAST<EdgeData<float>, hier::PatchData>(
fine.getPatchData(dst_component)));
const EdgeOverlap* t_overlap = CPP_CAST<const EdgeOverlap *>(&fine_overlap);
TBOX_ASSERT(t_overlap != 0);
TBOX_ASSERT(cdata);
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
TBOX_ASSERT_OBJDIM_EQUALITY3(fine, coarse, ratio);
const hier::Box& cgbox(cdata->getGhostBox());
const hier::Index& cilo = cgbox.lower();
const hier::Index& cihi = cgbox.upper();
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
for (int axis = 0; axis < dim.getValue(); ++axis) {
const hier::BoxContainer& boxes = t_overlap->getDestinationBoxContainer(axis);
for (hier::BoxContainer::const_iterator b = boxes.begin();
b != boxes.end(); ++b) {
hier::Box fine_box(*b);
TBOX_ASSERT_DIM_OBJDIM_EQUALITY1(dim, fine_box);
for (tbox::Dimension::dir_t i = 0; i < dim.getValue(); ++i) {
if (i != axis) {
fine_box.setUpper(i, fine_box.upper(i) - 1);
}
}
const hier::Box coarse_box = hier::Box::coarsen(fine_box, ratio);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
const hier::Index& ifirstf = fine_box.lower();
const hier::Index& ilastf = fine_box.upper();
for (int d = 0; d < fdata->getDepth(); ++d) {
if (dim == tbox::Dimension(1)) {
SAMRAI_F77_FUNC(conrefedgeflot1d, CONREFEDGEFLOT1D) (
ifirstc(0), ilastc(0),
ifirstf(0), ilastf(0),
cilo(0), cihi(0),
filo(0), fihi(0),
&ratio[0],
cdata->getPointer(0, d),
fdata->getPointer(0, d));
} else if (dim == tbox::Dimension(2)) {
if (axis == 0) {
SAMRAI_F77_FUNC(conrefedgeflot2d0, CONREFEDGEFLOT2D0) (
ifirstc(0), ifirstc(1), ilastc(0), ilastc(1),
ifirstf(0), ifirstf(1), ilastf(0), ilastf(1),
cilo(0), cilo(1), cihi(0), cihi(1),
filo(0), filo(1), fihi(0), fihi(1),
&ratio[0],
cdata->getPointer(0, d),
fdata->getPointer(0, d));
} else if (axis == 1) {
SAMRAI_F77_FUNC(conrefedgeflot2d1, CONREFEDGEFLOT2D1) (
ifirstc(0), ifirstc(1), ilastc(0), ilastc(1),
ifirstf(0), ifirstf(1), ilastf(0), ilastf(1),
cilo(0), cilo(1), cihi(0), cihi(1),
filo(0), filo(1), fihi(0), fihi(1),
&ratio[0],
cdata->getPointer(1, d),
fdata->getPointer(1, d));
}
} else if (dim == tbox::Dimension(3)) {
if (axis == 0) {
SAMRAI_F77_FUNC(conrefedgeflot3d0, CONREFEDGEFLOT3D0) (
ifirstc(0), ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cdata->getPointer(0, d),
fdata->getPointer(0, d));
} else if (axis == 1) {
SAMRAI_F77_FUNC(conrefedgeflot3d1, CONREFEDGEFLOT3D1) (
ifirstc(0), ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cdata->getPointer(1, d),
fdata->getPointer(1, d));
} else if (axis == 2) {
SAMRAI_F77_FUNC(conrefedgeflot3d2, CONREFEDGEFLOT3D2) (
ifirstc(0), ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cdata->getPointer(2, d),
fdata->getPointer(2, d));
}
} else {
TBOX_ERROR(
"EdgeFloatConstantRefine::refine dimension > 3 not supported"
<< std::endl);
}
}
}
}
}