TYPE PatchSideDataNormOpsReal<TYPE>::integral( const boost::shared_ptr<pdat::SideData<TYPE> >& data, const hier::Box& box, const boost::shared_ptr<pdat::SideData<double> >& vol) const { TBOX_ASSERT(data); TBOX_ASSERT(vol); TBOX_ASSERT_OBJDIM_EQUALITY3(*data, box, *vol); tbox::Dimension::dir_t dimVal = data->getDim().getValue(); TYPE retval = 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)) { const hier::Box side_box = pdat::SideGeometry::toSideBox(box, d); retval += d_array_ops.integral( data->getArrayData(d), vol->getArrayData(d), side_box); } } return retval; }
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); }
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)); } } }
void PatchSideDataNormOpsReal<TYPE>::abs( const boost::shared_ptr<pdat::SideData<TYPE> >& dst, const boost::shared_ptr<pdat::SideData<TYPE> >& src, const hier::Box& box) const { TBOX_ASSERT(dst && src); TBOX_ASSERT(dst->getDirectionVector() == src->getDirectionVector()); TBOX_ASSERT_OBJDIM_EQUALITY3(*dst, *src, box); tbox::Dimension::dir_t dimVal = dst->getDim().getValue(); const hier::IntVector& directions = dst->getDirectionVector(); for (tbox::Dimension::dir_t d = 0; d < dimVal; ++d) { if (directions(d)) { const hier::Box side_box = pdat::SideGeometry::toSideBox(box, d); d_array_ops.abs(dst->getArrayData(d), src->getArrayData(d), side_box); } } }
double PatchFaceDataNormOpsComplex::weightedL2Norm( const std::shared_ptr<pdat::FaceData<dcomplex> >& data, const std::shared_ptr<pdat::FaceData<dcomplex> >& weight, const hier::Box& box, const std::shared_ptr<pdat::FaceData<double> >& cvol) const { TBOX_ASSERT(data && weight); TBOX_ASSERT_OBJDIM_EQUALITY3(*data, *weight, 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); double aval = d_array_ops.weightedL2Norm(data->getArrayData(d), weight->getArrayData(d), face_box); retval += aval * aval; } } 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); double aval = d_array_ops.weightedL2NormWithControlVolume( data->getArrayData(d), weight->getArrayData(d), cvol->getArrayData(d), face_box); retval += aval * aval; } } return sqrt(retval); }
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); } } } } }
TYPE ArrayDataMiscellaneousOpsReal<TYPE>::minPointwiseDivide( const pdat::ArrayData<TYPE>& numer, const pdat::ArrayData<TYPE>& denom, const hier::Box& box) const { TBOX_ASSERT_OBJDIM_EQUALITY3(numer, denom, box); TBOX_ASSERT(denom.getDepth() == numer.getDepth()); tbox::Dimension::dir_t dimVal = numer.getDim().getValue(); TYPE min = tbox::MathUtilities<TYPE>::getMax(); TYPE quot = tbox::MathUtilities<TYPE>::getMax(); const hier::Box n_box = numer.getBox(); const hier::Box d_box = denom.getBox(); const hier::Box ibox = box * d_box * n_box; if (!ibox.empty()) { const int ddepth = denom.getDepth(); int box_w[SAMRAI::MAX_DIM_VAL]; int n_w[SAMRAI::MAX_DIM_VAL]; int d_w[SAMRAI::MAX_DIM_VAL]; int dim_counter[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t i = 0; i < dimVal; ++i) { box_w[i] = ibox.numberCells(i); n_w[i] = n_box.numberCells(i); d_w[i] = d_box.numberCells(i); dim_counter[i] = 0; } const size_t n_offset = numer.getOffset(); const size_t d_offset = denom.getOffset(); const int num_d0_blocks = static_cast<int>(ibox.size() / box_w[0]); size_t n_begin = n_box.offset(ibox.lower()); size_t d_begin = d_box.offset(ibox.lower()); const TYPE* nd = numer.getPointer(); const TYPE* dd = denom.getPointer(); for (int d = 0; d < ddepth; ++d) { size_t n_counter = n_begin; size_t d_counter = d_begin; int n_b[SAMRAI::MAX_DIM_VAL]; int d_b[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t nm = 0; nm < dimVal; ++nm) { n_b[nm] = static_cast<int>(n_counter); d_b[nm] = static_cast<int>(d_counter); } for (int nb = 0; nb < num_d0_blocks; ++nb) { for (int i0 = 0; i0 < box_w[0]; ++i0) { if (dd[d_counter + i0] != 0.0) { quot = nd[n_counter + i0] / dd[d_counter + i0]; } if (quot < min) min = quot; } int dim_jump = 0; for (tbox::Dimension::dir_t j = 1; j < dimVal; ++j) { if (dim_counter[j] < box_w[j] - 1) { ++dim_counter[j]; dim_jump = j; break; } else { dim_counter[j] = 0; } } if (dim_jump > 0) { int n_step = 1; int d_step = 1; for (int k = 0; k < dim_jump; ++k) { n_step *= n_w[k]; d_step *= d_w[k]; } n_counter = n_b[dim_jump - 1] + n_step; d_counter = d_b[dim_jump - 1] + d_step; for (int m = 0; m < dim_jump; ++m) { n_b[m] = static_cast<int>(n_counter); d_b[m] = static_cast<int>(d_counter); } } } n_begin += n_offset; d_begin += d_offset; } } return min; }
int ArrayDataMiscellaneousOpsReal<TYPE>::testReciprocal( pdat::ArrayData<TYPE>& dst, const pdat::ArrayData<TYPE>& src, const hier::Box& box) const { // Ignore Intel warning about floating point comparisons #ifdef __INTEL_COMPILER #pragma warning (disable:1572) #endif TBOX_ASSERT_OBJDIM_EQUALITY3(dst, src, box); TBOX_ASSERT(dst.getDepth() == src.getDepth()); tbox::Dimension::dir_t dimVal = dst.getDim().getValue(); int test = 1; const hier::Box d_box = dst.getBox(); const hier::Box s_box = src.getBox(); const hier::Box ibox = box * d_box * s_box; if (!ibox.empty()) { const int ddepth = dst.getDepth(); int box_w[SAMRAI::MAX_DIM_VAL]; int d_w[SAMRAI::MAX_DIM_VAL]; int s_w[SAMRAI::MAX_DIM_VAL]; int dim_counter[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t i = 0; i < dimVal; ++i) { box_w[i] = ibox.numberCells(i); d_w[i] = d_box.numberCells(i); s_w[i] = s_box.numberCells(i); dim_counter[i] = 0; } const size_t d_offset = dst.getOffset(); const size_t s_offset = src.getOffset(); const int num_d0_blocks = static_cast<int>(ibox.size() / box_w[0]); size_t d_begin = d_box.offset(ibox.lower()); size_t s_begin = s_box.offset(ibox.lower()); TYPE* dd = dst.getPointer(); const TYPE* sd = src.getPointer(); for (int d = 0; d < ddepth; ++d) { int d_counter = static_cast<int>(d_begin); int s_counter = static_cast<int>(s_begin); int d_b[SAMRAI::MAX_DIM_VAL]; int s_b[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t nd = 0; nd < dimVal; ++nd) { d_b[nd] = d_counter; s_b[nd] = s_counter; } for (int nb = 0; nb < num_d0_blocks; ++nb) { for (int i0 = 0; i0 < box_w[0]; ++i0) { if (sd[s_counter + i0] == 0.0) { test = 0; dd[d_counter + i0] = 0.0F; } else { dd[d_counter + i0] = 1.0F / sd[s_counter + i0]; } } int dim_jump = 0; for (tbox::Dimension::dir_t j = 1; j < dimVal; ++j) { if (dim_counter[j] < box_w[j] - 1) { ++dim_counter[j]; dim_jump = j; break; } else { dim_counter[j] = 0; } } if (dim_jump > 0) { int d_step = 1; int s_step = 1; for (int k = 0; k < dim_jump; ++k) { d_step *= d_w[k]; s_step *= s_w[k]; } d_counter = d_b[dim_jump - 1] + d_step; s_counter = s_b[dim_jump - 1] + s_step; for (int m = 0; m < dim_jump; ++m) { d_b[m] = d_counter; s_b[m] = s_counter; } } } d_begin += d_offset; s_begin += s_offset; } } return test; }
void ArrayDataMiscellaneousOpsReal<TYPE>::compareToScalar( pdat::ArrayData<TYPE>& dst, const pdat::ArrayData<TYPE>& src, const TYPE& alpha, const hier::Box& box) const { TBOX_ASSERT_OBJDIM_EQUALITY3(dst, src, box); TBOX_ASSERT(dst.getDepth() == src.getDepth()); tbox::Dimension::dir_t dimVal = dst.getDim().getValue(); const hier::Box d_box = dst.getBox(); const hier::Box s_box = src.getBox(); const hier::Box ibox = box * d_box * s_box; if (!ibox.empty()) { const int ddepth = dst.getDepth(); int box_w[SAMRAI::MAX_DIM_VAL]; int d_w[SAMRAI::MAX_DIM_VAL]; int s_w[SAMRAI::MAX_DIM_VAL]; int dim_counter[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t i = 0; i < dimVal; ++i) { box_w[i] = ibox.numberCells(i); d_w[i] = d_box.numberCells(i); s_w[i] = s_box.numberCells(i); dim_counter[i] = 0; } const size_t d_offset = dst.getOffset(); const size_t s_offset = src.getOffset(); const int num_d0_blocks = static_cast<int>(ibox.size() / box_w[0]); size_t d_begin = d_box.offset(ibox.lower()); size_t s_begin = s_box.offset(ibox.lower()); TYPE* dd = dst.getPointer(); const TYPE* sd = src.getPointer(); for (int d = 0; d < ddepth; ++d) { size_t d_counter = d_begin; size_t s_counter = s_begin; int d_b[SAMRAI::MAX_DIM_VAL]; int s_b[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t nd = 0; nd < dimVal; ++nd) { d_b[nd] = static_cast<int>(d_counter); s_b[nd] = static_cast<int>(s_counter); } for (int nb = 0; nb < num_d0_blocks; ++nb) { for (int i0 = 0; i0 < box_w[0]; ++i0) { dd[d_counter + i0] = ( (tbox::MathUtilities<TYPE>::Abs(sd[s_counter + i0]) >= alpha) ? 1.0F : 0.0F); } int dim_jump = 0; for (tbox::Dimension::dir_t j = 1; j < dimVal; ++j) { if (dim_counter[j] < box_w[j] - 1) { ++dim_counter[j]; dim_jump = j; break; } else { dim_counter[j] = 0; } } if (dim_jump > 0) { int d_step = 1; int s_step = 1; for (int k = 0; k < dim_jump; ++k) { d_step *= d_w[k]; s_step *= s_w[k]; } d_counter = d_b[dim_jump - 1] + d_step; s_counter = s_b[dim_jump - 1] + s_step; for (int m = 0; m < dim_jump; ++m) { d_b[m] = static_cast<int>(d_counter); s_b[m] = static_cast<int>(s_counter); } } } d_begin += d_offset; s_begin += s_offset; } } }
int ArrayDataMiscellaneousOpsReal<TYPE>::computeConstrProdPos( const pdat::ArrayData<TYPE>& data1, const pdat::ArrayData<TYPE>& data2, const hier::Box& box) const { TBOX_ASSERT_OBJDIM_EQUALITY3(data1, data2, box); TBOX_ASSERT(data1.getDepth() == data2.getDepth()); tbox::Dimension::dir_t dimVal = data1.getDim().getValue(); int test = 1; const hier::Box d1_box = data1.getBox(); const hier::Box d2_box = data2.getBox(); const hier::Box ibox = box * d1_box * d2_box; if (!ibox.empty()) { const int ddepth = data1.getDepth(); int box_w[SAMRAI::MAX_DIM_VAL]; int d1_w[SAMRAI::MAX_DIM_VAL]; int d2_w[SAMRAI::MAX_DIM_VAL]; int dim_counter[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t i = 0; i < dimVal; ++i) { box_w[i] = ibox.numberCells(i); d1_w[i] = d1_box.numberCells(i); d2_w[i] = d2_box.numberCells(i); dim_counter[i] = 0; } const size_t d1_offset = data1.getOffset(); const size_t d2_offset = data2.getOffset(); const int num_d0_blocks = static_cast<int>(ibox.size() / box_w[0]); size_t d1_begin = d1_box.offset(ibox.lower()); size_t d2_begin = d2_box.offset(ibox.lower()); const TYPE* dd1 = data1.getPointer(); const TYPE* dd2 = data2.getPointer(); for (int d = 0; d < ddepth; ++d) { int d1_counter = static_cast<int>(d1_begin); int d2_counter = static_cast<int>(d2_begin); int d1_b[SAMRAI::MAX_DIM_VAL]; int d2_b[SAMRAI::MAX_DIM_VAL]; for (tbox::Dimension::dir_t nd = 0; nd < dimVal; ++nd) { d1_b[nd] = d1_counter; d2_b[nd] = d2_counter; } for (int nb = 0; nb < num_d0_blocks; ++nb) { for (int i0 = 0; i0 < box_w[0]; ++i0) { if (tbox::MathUtilities<TYPE>::Abs(dd2[d2_counter + i0]) > 0.0 && (dd1[d1_counter + i0] * dd2[d2_counter + i0] <= 0.0)) { test = 0; } } int dim_jump = 0; for (tbox::Dimension::dir_t j = 1; j < dimVal; ++j) { if (dim_counter[j] < box_w[j] - 1) { ++dim_counter[j]; dim_jump = j; break; } else { dim_counter[j] = 0; } } if (dim_jump > 0) { int d1_step = 1; int d2_step = 1; for (int k = 0; k < dim_jump; ++k) { d1_step *= d1_w[k]; d2_step *= d2_w[k]; } d1_counter = d1_b[dim_jump - 1] + d1_step; d2_counter = d2_b[dim_jump - 1] + d1_step; for (int m = 0; m < dim_jump; ++m) { d1_b[m] = d1_counter; d2_b[m] = d2_counter; } } } d1_begin += d1_offset; d2_begin += d2_offset; } } return test; }