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;
}
