/* ************************************************************************* * * 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); } } }