/*
*************************************************************************
*
* Compute the rotations for the particular block number. The
* "local_blocks" argument is basically saying who is the ne
*
*************************************************************************
*/
void computeBlocksOctant(
const hier::Box& bb,
int local_blocks[6],
int nblock,
int nth)
{
const hier::Index ifirst = bb.lower();
const hier::Index ilast = bb.upper();
local_blocks[0] = nblock; // imin stays local
local_blocks[3] = nblock; // jmin stays local
static int jmn[3] = { 0, 0, 2 }; // matrix of rotations
static int jmx[3] = { 1, 1, 1 };
static int kmn[3] = { 0, 1, 0 };
static int kmx[3] = { 2, 2, 2 };
//
// bounds of the patch zones go from 0 to nth-1
//
if (ifirst(1) <= 0) local_blocks[1] = jmn[nblock];
if (ifirst(2) <= 0) local_blocks[2] = kmn[nblock];
if (ilast(1) >= nth - 1) local_blocks[4] = jmx[nblock];
if (ilast(2) >= nth - 1) local_blocks[5] = kmx[nblock];
}
void MblkGeometry::setCartesianMetrics(
const hier::Box& domain,
const int level_number,
const int block_number)
{
if (d_metrics_set[level_number][block_number]) return;
hier::Index lower(domain.lower());
hier::Index upper(domain.upper());
hier::Index diff(upper - lower + hier::Index(lower.getDim(), 1));
if (static_cast<int>(d_dx.size()) < (level_number + 1)) {
d_dx.resize(level_number + 1);
}
if (static_cast<int>(d_dx[level_number].size()) < d_nblocks) {
d_dx[level_number].resize(d_nblocks);
}
if (static_cast<int>(d_dx[level_number][block_number].size()) < d_dim.getValue()) {
d_dx[level_number][block_number].resize(d_dim.getValue());
}
for (int i = 0; i < d_dim.getValue(); ++i) {
d_dx[level_number][block_number][i] =
(d_cart_xhi[block_number][i] - d_cart_xlo[block_number][i]) / (double)diff(i);
}
d_metrics_set[level_number][block_number] = true;
}
NodeIterator::NodeIterator(
const hier::Box& box,
bool begin):
d_index(box.lower(), hier::IntVector::getZero(box.getDim())),
d_box(NodeGeometry::toNodeBox(box))
{
if (!d_box.empty() && !begin) {
d_index(d_box.getDim().getValue() - 1) =
d_box.upper(static_cast<tbox::Dimension::dir_t>(d_box.getDim().getValue() - 1)) + 1;
}
}
dcomplex
PatchFaceDataNormOpsComplex::dot(
const std::shared_ptr<pdat::FaceData<dcomplex> >& data1,
const std::shared_ptr<pdat::FaceData<dcomplex> >& data2,
const hier::Box& box,
const std::shared_ptr<pdat::FaceData<double> >& cvol) const
{
TBOX_ASSERT(data1 && data2);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
dcomplex retval = dcomplex(0.0, 0.0);
if (!cvol) {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
const hier::Box face_box = pdat::FaceGeometry::toFaceBox(box, d);
retval += d_array_ops.dot(data1->getArrayData(d),
data2->getArrayData(d),
face_box);
}
} else {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
const hier::Box face_box = pdat::FaceGeometry::toFaceBox(box, d);
retval += d_array_ops.dotWithControlVolume(
data1->getArrayData(d),
data2->getArrayData(d),
cvol->getArrayData(d),
face_box);
}
}
return retval;
}
double
PatchFaceDataNormOpsComplex::maxNorm(
const std::shared_ptr<pdat::FaceData<dcomplex> >& data,
const hier::Box& box,
const std::shared_ptr<pdat::FaceData<double> >& cvol) const
{
TBOX_ASSERT(data);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
double retval = 0.0;
if (!cvol) {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
const hier::Box face_box =
pdat::FaceGeometry::toFaceBox(box, d);
retval = tbox::MathUtilities<double>::Max(retval,
d_array_ops.maxNorm(data->getArrayData(d), face_box));
}
} else {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
const hier::Box face_box =
pdat::FaceGeometry::toFaceBox(box, d);
retval = tbox::MathUtilities<double>::Max(retval,
d_array_ops.maxNormWithControlVolume(
data->getArrayData(d), cvol->getArrayData(d), face_box));
}
}
return retval;
}
dcomplex
PatchSideDataNormOpsComplex::integral(
const boost::shared_ptr<pdat::SideData<dcomplex> >& data,
const hier::Box& box,
const boost::shared_ptr<pdat::SideData<double> >& vol) const
{
TBOX_ASSERT(data);
int dimVal = box.getDim().getValue();
dcomplex retval = dcomplex(0.0, 0.0);
const hier::IntVector& directions = data->getDirectionVector();
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, vol->getDirectionVector()));
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
retval += d_array_ops.integral(
data->getArrayData(d),
vol->getArrayData(d),
pdat::SideGeometry::toSideBox(box, d));
}
}
return retval;
}
double
PatchFaceDataNormOpsComplex::L1Norm(
const std::shared_ptr<pdat::FaceData<dcomplex> >& data,
const hier::Box& box,
const std::shared_ptr<pdat::FaceData<double> >& cvol) const
{
TBOX_ASSERT(data);
TBOX_ASSERT_OBJDIM_EQUALITY2(*data, box);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
double retval = 0.0;
if (!cvol) {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
const hier::Box face_box = pdat::FaceGeometry::toFaceBox(box, d);
retval += d_array_ops.L1Norm(data->getArrayData(d), face_box);
}
} else {
TBOX_ASSERT_OBJDIM_EQUALITY2(*data, *cvol);
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
const hier::Box face_box = pdat::FaceGeometry::toFaceBox(box, d);
retval += d_array_ops.L1NormWithControlVolume(data->getArrayData(d),
cvol->getArrayData(d),
face_box);
}
}
return retval;
}
ArrayDataIterator::ArrayDataIterator(
const hier::Box& box,
bool begin):
d_index(box.lower()),
d_box(box)
{
if (!d_box.empty() && !begin) {
d_index(d_box.getDim().getValue() - 1) =
d_box.upper(static_cast<tbox::Dimension::dir_t>(d_box.getDim().getValue() - 1)) + 1;
}
}
SideIterator::SideIterator(
const hier::Box& box,
const tbox::Dimension::dir_t axis,
bool begin):
d_index(box.lower(), axis, SideIndex::Lower),
d_box(SideGeometry::toSideBox(box, axis))
{
if (!d_box.empty() && !begin) {
d_index(d_box.getDim().getValue() - 1) =
d_box.upper(static_cast<tbox::Dimension::dir_t>(d_box.getDim().getValue() - 1)) + 1;
}
}
/*
*************************************************************************
*
* Compute the boxes for the stencil around a given patch box
*
*************************************************************************
*/
void
FirstLayerCellVariableFillPattern::computeStencilBoxes(
hier::BoxContainer& stencil_boxes,
const hier::Box& dst_box) const
{
TBOX_ASSERT(stencil_boxes.size() == 0);
hier::Box ghost_box(
hier::Box::grow(dst_box,
hier::IntVector::getOne(dst_box.getDim())));
stencil_boxes.removeIntersections(ghost_box, dst_box);
}
size_t
PatchSideDataNormOpsReal<TYPE>::numberOfEntries(
const boost::shared_ptr<pdat::SideData<TYPE> >& data,
const hier::Box& box) const
{
TBOX_ASSERT(data);
TBOX_ASSERT_OBJDIM_EQUALITY2(*data, box);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
size_t retval = 0;
const hier::Box ibox = box * data->getGhostBox();
const hier::IntVector& directions = data->getDirectionVector();
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box dbox = pdat::SideGeometry::toSideBox(ibox, d);
retval += (dbox.size() * data->getDepth());
}
}
return retval;
}
CoarsenCopyTransaction::CoarsenCopyTransaction(
const std::shared_ptr<hier::PatchLevel>& dst_level,
const std::shared_ptr<hier::PatchLevel>& src_level,
const std::shared_ptr<hier::BoxOverlap>& overlap,
const hier::Box& dst_box,
const hier::Box& src_box,
const CoarsenClasses::Data** coarsen_data,
int item_id):
d_dst_patch_rank(dst_box.getOwnerRank()),
d_src_patch_rank(src_box.getOwnerRank()),
d_overlap(overlap),
d_coarsen_data(coarsen_data),
d_item_id(item_id),
d_incoming_bytes(0),
d_outgoing_bytes(0)
{
TBOX_ASSERT(dst_level);
TBOX_ASSERT(src_level);
TBOX_ASSERT(overlap);
TBOX_ASSERT_OBJDIM_EQUALITY4(*dst_level,
*src_level,
dst_box,
src_box);
TBOX_ASSERT(dst_box.getLocalId() >= 0);
TBOX_ASSERT(src_box.getLocalId() >= 0);
TBOX_ASSERT(coarsen_data != 0);
TBOX_ASSERT(item_id >= 0);
if (d_dst_patch_rank == dst_level->getBoxLevel()->getMPI().getRank()) {
d_dst_patch = dst_level->getPatch(dst_box.getGlobalId());
}
if (d_src_patch_rank == src_level->getBoxLevel()->getMPI().getRank()) {
d_src_patch = src_level->getPatch(src_box.getGlobalId());
}
}
void
PatchFaceDataNormOpsComplex::abs(
const std::shared_ptr<pdat::FaceData<double> >& dst,
const std::shared_ptr<pdat::FaceData<dcomplex> >& src,
const hier::Box& box) const
{
TBOX_ASSERT(dst && src);
TBOX_ASSERT_OBJDIM_EQUALITY3(*dst, *src, box);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
d_array_ops.abs(dst->getArrayData(d),
src->getArrayData(d),
pdat::FaceGeometry::toFaceBox(box, d));
}
}
double
PatchSideDataNormOpsComplex::weightedL2Norm(
const boost::shared_ptr<pdat::SideData<dcomplex> >& data,
const boost::shared_ptr<pdat::SideData<dcomplex> >& weight,
const hier::Box& box,
const boost::shared_ptr<pdat::SideData<double> >& cvol) const
{
TBOX_ASSERT(data && weight);
TBOX_ASSERT_OBJDIM_EQUALITY3(*data, *weight, box);
int dimVal = box.getDim().getValue();
double retval = 0.0;
const hier::IntVector& directions = data->getDirectionVector();
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, weight->getDirectionVector()));
if (!cvol) {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box side_box = pdat::SideGeometry::toSideBox(box, d);
double aval = d_array_ops.weightedL2Norm(data->getArrayData(d),
weight->getArrayData(d),
side_box);
retval += aval * aval;
}
}
} else {
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, cvol->getDirectionVector()));
TBOX_ASSERT_OBJDIM_EQUALITY2(*data, *cvol);
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box side_box = pdat::SideGeometry::toSideBox(box, d);
double aval = d_array_ops.weightedL2NormWithControlVolume(
data->getArrayData(d),
weight->getArrayData(d),
cvol->getArrayData(d),
side_box);
retval += aval * aval;
}
}
}
return sqrt(retval);
}
dcomplex
PatchFaceDataNormOpsComplex::integral(
const std::shared_ptr<pdat::FaceData<dcomplex> >& data,
const hier::Box& box,
const std::shared_ptr<pdat::FaceData<double> >& vol) const
{
TBOX_ASSERT(data);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
dcomplex retval = dcomplex(0.0, 0.0);
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
retval += d_array_ops.integral(data->getArrayData(d),
vol->getArrayData(d),
pdat::FaceGeometry::toFaceBox(box, d));
}
return retval;
}
int
PatchFaceDataNormOpsComplex::numberOfEntries(
const std::shared_ptr<pdat::FaceData<dcomplex> >& data,
const hier::Box& box) const
{
TBOX_ASSERT(data);
TBOX_ASSERT_OBJDIM_EQUALITY2(*data, box);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
int retval = 0;
const hier::Box ibox = box * data->getGhostBox();
const int data_depth = data->getDepth();
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
retval += static_cast<int>((pdat::FaceGeometry::toFaceBox(ibox, d).size()) * data_depth);
}
return retval;
}
double
PatchFaceDataNormOpsComplex::sumControlVolumes(
const std::shared_ptr<pdat::FaceData<dcomplex> >& data,
const std::shared_ptr<pdat::FaceData<double> >& cvol,
const hier::Box& box) const
{
TBOX_ASSERT(data && cvol);
tbox::Dimension::dir_t dimVal = box.getDim().getValue();
double retval = 0.0;
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
retval += d_array_ops.sumControlVolumes(data->getArrayData(d),
cvol->getArrayData(d),
pdat::FaceGeometry::toFaceBox(box, d));
}
return retval;
}
void MblkGeometry::setSShellMetrics(
const hier::Box& domain,
const int level_number)
{
int b = domain.getBlockId().getBlockValue();
//
// Set dx (drad, dth, dphi) for the level
//
d_dx.resize(level_number + 1);
d_dx[level_number].resize(d_nblocks);
d_dx[level_number][b].resize(d_dim.getValue());
double nrad = (domain.upper(0) - domain.lower(0) + 1);
double nth = (domain.upper(1) - domain.lower(1) + 1);
double nphi = 0;
if (d_dim == tbox::Dimension(3)) {
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][b][0] = (d_sshell_rmax - d_sshell_rmin) / nrad;
d_dx[level_number][b][1] =
2.0 * tbox::MathUtilities<double>::Abs(d_sangle_thmin) / nth;
if (d_dim == tbox::Dimension(3)) {
d_dx[level_number][b][2] =
2.0 * tbox::MathUtilities<double>::Abs(d_sangle_thmin) / nphi;
}
} else {
d_dx[level_number][b][0] = 0.0001;
d_dx[level_number][b][1] = 0.0001;
if (d_dim == tbox::Dimension(3)) {
d_dx[level_number][b][2] = 0.0001;
}
}
/*
* If its an OCTANT shell, then everything is set in the
* computeUnitSphereOctant() method so all we do here is allocate
* space for d_dx.
*/
d_metrics_set[level_number][0] = true;
}
void
PatchSideDataOpsComplex::copyData(
const std::shared_ptr<pdat::SideData<dcomplex> >& dst,
const std::shared_ptr<pdat::SideData<dcomplex> >& src,
const hier::Box& box) const
{
TBOX_ASSERT(dst && src);
TBOX_ASSERT(dst->getDirectionVector() == src->getDirectionVector());
TBOX_ASSERT_OBJDIM_EQUALITY3(*dst, *src, box);
int dimVal = box.getDim().getValue();
const hier::IntVector& directions = dst->getDirectionVector();
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
dst->getArrayData(d).copy(src->getArrayData(d),
pdat::SideGeometry::toSideBox(box, d));
}
}
}
dcomplex
PatchSideDataNormOpsComplex::dot(
const boost::shared_ptr<pdat::SideData<dcomplex> >& data1,
const boost::shared_ptr<pdat::SideData<dcomplex> >& data2,
const hier::Box& box,
const boost::shared_ptr<pdat::SideData<double> >& cvol) const
{
TBOX_ASSERT(data1 && data2);
TBOX_ASSERT(data1->getDirectionVector() == data2->getDirectionVector());
int dimVal = box.getDim().getValue();
dcomplex retval = dcomplex(0.0, 0.0);
const hier::IntVector& directions = data1->getDirectionVector();
if (!cvol) {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box side_box = pdat::SideGeometry::toSideBox(box, d);
retval += d_array_ops.dot(data1->getArrayData(d),
data2->getArrayData(d),
side_box);
}
}
} else {
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, cvol->getDirectionVector()));
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box side_box = pdat::SideGeometry::toSideBox(box, d);
retval += d_array_ops.dotWithControlVolume(
data1->getArrayData(d),
data2->getArrayData(d),
cvol->getArrayData(d),
side_box);
}
}
}
return retval;
}
/*
*************************************************************************
*
* Compute BoxOverlap that specifies data to be filled by refinement
* operator.
*
*************************************************************************
*/
std::shared_ptr<hier::BoxOverlap>
FirstLayerCellVariableFillPattern::computeFillBoxesOverlap(
const hier::BoxContainer& fill_boxes,
const hier::BoxContainer& node_fill_boxes,
const hier::Box& patch_box,
const hier::Box& data_box,
const hier::PatchDataFactory& pdf) const
{
NULL_USE(pdf);
NULL_USE(node_fill_boxes);
hier::BoxContainer stencil_boxes;
computeStencilBoxes(stencil_boxes, patch_box);
hier::BoxContainer overlap_boxes(fill_boxes);
overlap_boxes.intersectBoxes(data_box);
overlap_boxes.intersectBoxes(stencil_boxes);
return std::make_shared<CellOverlap>(
overlap_boxes,
hier::Transformation(hier::IntVector::getZero(patch_box.getDim())));
}
double
PatchSideDataNormOpsComplex::maxNorm(
const boost::shared_ptr<pdat::SideData<dcomplex> >& data,
const hier::Box& box,
const boost::shared_ptr<pdat::SideData<double> >& cvol) const
{
TBOX_ASSERT(data);
int dimVal = box.getDim().getValue();
double retval = 0.0;
const hier::IntVector& directions = data->getDirectionVector();
if (!cvol) {
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box side_box =
pdat::SideGeometry::toSideBox(box, d);
retval = tbox::MathUtilities<double>::Max(retval,
d_array_ops.maxNorm(data->getArrayData(d), side_box));
}
}
} else {
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, cvol->getDirectionVector()));
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
const hier::Box side_box =
pdat::SideGeometry::toSideBox(box, d);
retval = tbox::MathUtilities<double>::Max(retval,
d_array_ops.maxNormWithControlVolume(
data->getArrayData(d),
cvol->getArrayData(d), side_box));
}
}
}
return retval;
}
double
PatchSideDataNormOpsComplex::sumControlVolumes(
const boost::shared_ptr<pdat::SideData<dcomplex> >& data,
const boost::shared_ptr<pdat::SideData<double> >& cvol,
const hier::Box& box) const
{
TBOX_ASSERT(data && cvol);
double retval = 0.0;
const hier::IntVector& directions = data->getDirectionVector();
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, cvol->getDirectionVector()));
int dimVal = box.getDim().getValue();
for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) {
if (directions(d)) {
retval += d_array_ops.sumControlVolumes(data->getArrayData(d),
cvol->getArrayData(d),
pdat::SideGeometry::toSideBox(box, d));
}
}
return retval;
}
void MblkGeometry::setWedgeMetrics(
const hier::Box& domain,
const int level_number)
{
int b = domain.getBlockId().getBlockValue();
//
// Set dx (dr, dth, dz) for the level
//
d_dx.resize(level_number + 1);
d_dx[level_number].resize(d_nblocks);
d_dx[level_number][b].resize(d_dim.getValue());
double nr = (domain.upper(0) - domain.lower(0) + 1);
double nth = (domain.upper(1) - domain.lower(1) + 1);
d_dx[level_number][b][0] = (d_wedge_rmax[0] - d_wedge_rmin[0]) / nr;
d_dx[level_number][b][1] = (d_wedge_thmax - d_wedge_thmin) / nth;
if (d_dim == tbox::Dimension(3)) {
double nz = (domain.upper(2) - domain.lower(2) + 1);
d_dx[level_number][b][2] = (d_wedge_zmax - d_wedge_zmin) / nz;
}
d_metrics_set[level_number][b] = true;
}
RefineCopyTransaction::RefineCopyTransaction(
const std::shared_ptr<hier::PatchLevel>& dst_level,
const std::shared_ptr<hier::PatchLevel>& src_level,
const std::shared_ptr<hier::BoxOverlap>& overlap,
const hier::Box& dst_box,
const hier::Box& src_box,
const RefineClasses::Data** refine_data,
int item_id):
d_dst_patch_rank(dst_box.getOwnerRank()),
d_src_patch_rank(src_box.getOwnerRank()),
d_overlap(overlap),
d_refine_data(refine_data),
d_item_id(item_id),
d_incoming_bytes(0),
d_outgoing_bytes(0)
{
TBOX_ASSERT(dst_level);
TBOX_ASSERT(src_level);
TBOX_ASSERT(overlap);
TBOX_ASSERT(dst_box.getLocalId() >= 0);
TBOX_ASSERT(src_box.getLocalId() >= 0);
TBOX_ASSERT(item_id >= 0);
TBOX_ASSERT(refine_data[item_id] != 0);
TBOX_ASSERT_OBJDIM_EQUALITY4(*dst_level,
*src_level,
dst_box,
src_box);
// Note: s_num_coarsen_items cannot be used at this point!
if (d_dst_patch_rank == dst_level->getBoxLevel()->getMPI().getRank()) {
d_dst_patch = dst_level->getPatch(dst_box.getGlobalId());
}
if (d_src_patch_rank == dst_level->getBoxLevel()->getMPI().getRank()) {
d_src_patch = src_level->getPatch(src_box.getGlobalId());
}
}
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);
}
}
}
}
void
CellComplexLinearTimeInterpolateOp::timeInterpolate(
hier::PatchData& dst_data,
const hier::Box& where,
const hier::PatchData& src_data_old,
const hier::PatchData& src_data_new) const
{
const tbox::Dimension& dim(where.getDim());
const CellData<dcomplex>* old_dat =
CPP_CAST<const CellData<dcomplex> *>(&src_data_old);
const CellData<dcomplex>* new_dat =
CPP_CAST<const CellData<dcomplex> *>(&src_data_new);
CellData<dcomplex>* dst_dat =
CPP_CAST<CellData<dcomplex> *>(&dst_data);
TBOX_ASSERT(old_dat != 0);
TBOX_ASSERT(new_dat != 0);
TBOX_ASSERT(dst_dat != 0);
TBOX_ASSERT((where * old_dat->getGhostBox()).isSpatiallyEqual(where));
TBOX_ASSERT((where * new_dat->getGhostBox()).isSpatiallyEqual(where));
TBOX_ASSERT((where * dst_dat->getGhostBox()).isSpatiallyEqual(where));
TBOX_ASSERT_OBJDIM_EQUALITY4(dst_data, where, src_data_old, src_data_new);
const hier::Index& old_ilo = old_dat->getGhostBox().lower();
const hier::Index& old_ihi = old_dat->getGhostBox().upper();
const hier::Index& new_ilo = new_dat->getGhostBox().lower();
const hier::Index& new_ihi = new_dat->getGhostBox().upper();
const hier::Index& dst_ilo = dst_dat->getGhostBox().lower();
const hier::Index& dst_ihi = dst_dat->getGhostBox().upper();
const hier::Index& ifirst = where.lower();
const hier::Index& ilast = where.upper();
const double old_time = old_dat->getTime();
const double new_time = new_dat->getTime();
const double dst_time = dst_dat->getTime();
TBOX_ASSERT((old_time < dst_time ||
tbox::MathUtilities<double>::equalEps(old_time, dst_time)) &&
(dst_time < new_time ||
tbox::MathUtilities<double>::equalEps(dst_time, new_time)));
double tfrac = dst_time - old_time;
double denom = new_time - old_time;
if (denom > tbox::MathUtilities<double>::getMin()) {
tfrac /= denom;
} else {
tfrac = 0.0;
}
for (int d = 0; d < dst_dat->getDepth(); ++d) {
if (dim == tbox::Dimension(1)) {
SAMRAI_F77_FUNC(lintimeintcellcmplx1d, LINTIMEINTCELLCMPLX1D) (ifirst(0),
ilast(0),
old_ilo(0), old_ihi(0),
new_ilo(0), new_ihi(0),
dst_ilo(0), dst_ihi(0),
tfrac,
old_dat->getPointer(d),
new_dat->getPointer(d),
dst_dat->getPointer(d));
} else if (dim == tbox::Dimension(2)) {
SAMRAI_F77_FUNC(lintimeintcellcmplx2d, LINTIMEINTCELLCMPLX2D) (ifirst(0),
ifirst(1), ilast(0), ilast(1),
old_ilo(0), old_ilo(1), old_ihi(0), old_ihi(1),
new_ilo(0), new_ilo(1), new_ihi(0), new_ihi(1),
dst_ilo(0), dst_ilo(1), dst_ihi(0), dst_ihi(1),
tfrac,
old_dat->getPointer(d),
new_dat->getPointer(d),
dst_dat->getPointer(d));
} else if (dim == tbox::Dimension(3)) {
SAMRAI_F77_FUNC(lintimeintcellcmplx3d, LINTIMEINTCELLCMPLX3D) (ifirst(0),
ifirst(1), ifirst(2),
ilast(0), ilast(1), ilast(2),
old_ilo(0), old_ilo(1), old_ilo(2),
old_ihi(0), old_ihi(1), old_ihi(2),
new_ilo(0), new_ilo(1), new_ilo(2),
new_ihi(0), new_ihi(1), new_ihi(2),
dst_ilo(0), dst_ilo(1), dst_ilo(2),
dst_ihi(0), dst_ihi(1), dst_ihi(2),
tfrac,
old_dat->getPointer(d),
new_dat->getPointer(d),
dst_dat->getPointer(d));
} else {
TBOX_ERROR(
"CellComplexLinearTimeInterpolateOp::TimeInterpolate dim > 3 not supported"
<< std::endl);
}
}
}
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 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 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);
}
}
}
