/*
*************************************************************************
*
* 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;
}
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;
}
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;
}
}
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;
}
}
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;
}
}
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;
}
void
CartesianFaceDoubleWeightedAverage::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, coarse_box, ratio);
std::shared_ptr<pdat::FaceData<double> > fdata(
SAMRAI_SHARED_PTR_CAST<pdat::FaceData<double>, hier::PatchData>(
fine.getPatchData(src_component)));
std::shared_ptr<pdat::FaceData<double> > cdata(
SAMRAI_SHARED_PTR_CAST<pdat::FaceData<double>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
const hier::Index& cilo = cdata->getGhostBox().lower();
const hier::Index& cihi = cdata->getGhostBox().upper();
const std::shared_ptr<CartesianPatchGeometry> fgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
const std::shared_ptr<CartesianPatchGeometry> cgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
TBOX_ASSERT(fgeom);
TBOX_ASSERT(cgeom);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
for (int d = 0; d < cdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub1d, CARTWGTAVGFACEDOUB1D) (ifirstc(0),
ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
} else if ((dim == tbox::Dimension(2))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub2d0, CARTWGTAVGFACEDOUB2D0) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub2d1, CARTWGTAVGFACEDOUB2D1) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
} else if ((dim == tbox::Dimension(3))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub3d0, CARTWGTAVGFACEDOUB3D0) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub3d1, CARTWGTAVGFACEDOUB3D1) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub3d2, CARTWGTAVGFACEDOUB3D2) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(2, d),
cdata->getPointer(2, d));
} else if ((dim == tbox::Dimension(4))) {
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d0, CARTWGTAVGFACEDOUB4D0) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d1, CARTWGTAVGFACEDOUB4D1) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d2, CARTWGTAVGFACEDOUB4D2) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(2, d),
cdata->getPointer(2, d));
SAMRAI_F77_FUNC(cartwgtavgfacedoub4d3, CARTWGTAVGFACEDOUB4D3) (ifirstc(0),
ifirstc(1), ifirstc(2), ifirstc(3),
ilastc(0), ilastc(1), ilastc(2), ilastc(3),
filo(0), filo(1), filo(2), filo(3),
fihi(0), fihi(1), fihi(2), fihi(3),
cilo(0), cilo(1), cilo(2), cilo(3),
cihi(0), cihi(1), cihi(2), cihi(3),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(3, d),
cdata->getPointer(3, d));
} else {
TBOX_ERROR("CartesianFaceDoubleWeightedAverage error...\n"
<< "dim > 4 not supported." << std::endl);
}
}
}
void
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 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);
}
}
}
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>::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;
}
int
ArrayDataMiscellaneousOpsReal<TYPE>::computeConstrProdPosWithControlVolume(
const pdat::ArrayData<TYPE>& data1,
const pdat::ArrayData<TYPE>& data2,
const pdat::ArrayData<double>& cvol,
const hier::Box& box) const
{
TBOX_ASSERT_OBJDIM_EQUALITY4(data1, data2, cvol, 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 cv_box = cvol.getBox();
const hier::Box ibox = box * d1_box * d2_box * cv_box;
if (!ibox.empty()) {
const int ddepth = data1.getDepth();
const int cvdepth = cvol.getDepth();
TBOX_ASSERT((ddepth == cvdepth) || (cvdepth == 1));
int box_w[SAMRAI::MAX_DIM_VAL];
int d1_w[SAMRAI::MAX_DIM_VAL];
int d2_w[SAMRAI::MAX_DIM_VAL];
int cv_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);
cv_w[i] = cv_box.numberCells(i);
dim_counter[i] = 0;
}
const size_t d1_offset = data1.getOffset();
const size_t d2_offset = data2.getOffset();
const size_t cv_offset = ((cvdepth == 1) ? 0 : cvol.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());
size_t cv_begin = cv_box.offset(ibox.lower());
const TYPE* dd1 = data1.getPointer();
const TYPE* dd2 = data2.getPointer();
const double* cvd = cvol.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 cv_counter = static_cast<int>(cv_begin);
int d1_b[SAMRAI::MAX_DIM_VAL];
int d2_b[SAMRAI::MAX_DIM_VAL];
int cv_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;
cv_b[nd] = cv_counter;
}
for (int nb = 0; nb < num_d0_blocks; ++nb) {
for (int i0 = 0; i0 < box_w[0]; ++i0) {
if (cvd[cv_counter + i0] > 0.0) {
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;
int cv_step = 1;
for (int k = 0; k < dim_jump; ++k) {
d1_step *= d1_w[k];
d2_step *= d2_w[k];
cv_step *= cv_w[k];
}
d1_counter = d1_b[dim_jump - 1] + d1_step;
d2_counter = d2_b[dim_jump - 1] + d1_step;
cv_counter = cv_b[dim_jump - 1] + cv_step;
for (int m = 0; m < dim_jump; ++m) {
d1_b[m] = d1_counter;
d2_b[m] = d2_counter;
cv_b[m] = cv_counter;
}
}
}
d1_begin += d1_offset;
d2_begin += d2_offset;
cv_begin += cv_offset;
}
}
return test;
}
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
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
OuternodeDoubleInjection::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
boost::shared_ptr<OuternodeData<double> > fdata(
BOOST_CAST<OuternodeData<double>, hier::PatchData>(
fine.getPatchData(src_component)));
boost::shared_ptr<OuternodeData<double> > cdata(
BOOST_CAST<OuternodeData<double>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
TBOX_ASSERT_OBJDIM_EQUALITY4(coarse, fine, coarse_box, ratio);
const hier::Index filo = fine.getBox().lower();
const hier::Index fihi = fine.getBox().upper();
const hier::Index cilo = coarse.getBox().lower();
const hier::Index cihi = coarse.getBox().upper();
const hier::Index ifirstc = coarse_box.lower();
const hier::Index ilastc = coarse_box.upper();
for (int i = 0; i < 2; ++i) {
for (int axis = 0; axis < dim.getValue(); ++axis) {
if (cdata->dataExists(axis)) {
for (int d = 0; d < cdata->getDepth(); ++d) {
if (dim == tbox::Dimension(1)) {
SAMRAI_F77_FUNC(conavgouternodedoub1d,
CONAVGOUTERNODEDOUB1D) (ifirstc(0), ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
} else if (dim == tbox::Dimension(2)) {
if (axis == 0) {
SAMRAI_F77_FUNC(conavgouternodedoub2d0,
CONAVGOUTERNODEDOUB2D0) (ifirstc(0), ifirstc(1),
ilastc(0), ilastc(1),
filo(0), filo(1),
fihi(0), fihi(1),
cilo(0), cilo(1),
cihi(0), cihi(1),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
if (axis == 1) {
SAMRAI_F77_FUNC(conavgouternodedoub2d1,
CONAVGOUTERNODEDOUB2D1) (ifirstc(0), ifirstc(1),
ilastc(0), ilastc(1),
filo(0), filo(1),
fihi(0), fihi(1),
cilo(0), cilo(1),
cihi(0), cihi(1),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
} else if (dim == tbox::Dimension(3)) {
if (axis == 0) {
SAMRAI_F77_FUNC(conavgouternodedoub3d0,
CONAVGOUTERNODEDOUB3D0) (ifirstc(0), ifirstc(1),
ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
if (axis == 1) {
SAMRAI_F77_FUNC(conavgouternodedoub3d1,
CONAVGOUTERNODEDOUB3D1) (ifirstc(0), ifirstc(1),
ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
if (axis == 2) {
SAMRAI_F77_FUNC(conavgouternodedoub3d2,
CONAVGOUTERNODEDOUB3D2) (ifirstc(0), ifirstc(1),
ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fdata->getPointer(axis, i, d),
cdata->getPointer(axis, i, d));
}
}
}
}
}
}
}
void
CartesianSideFloatWeightedAverage::coarsen(
hier::Patch& coarse,
const hier::Patch& fine,
const int dst_component,
const int src_component,
const hier::Box& coarse_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, coarse_box, ratio);
std::shared_ptr<pdat::SideData<float> > fdata(
SAMRAI_SHARED_PTR_CAST<pdat::SideData<float>, hier::PatchData>(
fine.getPatchData(src_component)));
std::shared_ptr<pdat::SideData<float> > cdata(
SAMRAI_SHARED_PTR_CAST<pdat::SideData<float>, hier::PatchData>(
coarse.getPatchData(dst_component)));
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::IntVector& directions = cdata->getDirectionVector();
TBOX_ASSERT(directions ==
hier::IntVector::min(directions, fdata->getDirectionVector()));
const hier::Index& filo = fdata->getGhostBox().lower();
const hier::Index& fihi = fdata->getGhostBox().upper();
const hier::Index& cilo = cdata->getGhostBox().lower();
const hier::Index& cihi = cdata->getGhostBox().upper();
const std::shared_ptr<CartesianPatchGeometry> fgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
const std::shared_ptr<CartesianPatchGeometry> cgeom(
SAMRAI_SHARED_PTR_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
TBOX_ASSERT(fgeom);
TBOX_ASSERT(cgeom);
const hier::Index& ifirstc = coarse_box.lower();
const hier::Index& ilastc = coarse_box.upper();
for (int d = 0; d < cdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
if (directions(0)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot1d, CARTWGTAVGSIDEFLOT1D) (ifirstc(0),
ilastc(0),
filo(0), fihi(0),
cilo(0), cihi(0),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
}
} else if ((dim == tbox::Dimension(2))) {
if (directions(0)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot2d0, CARTWGTAVGSIDEFLOT2D0) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
}
if (directions(1)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot2d1, CARTWGTAVGSIDEFLOT2D1) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
filo(0), filo(1), fihi(0), fihi(1),
cilo(0), cilo(1), cihi(0), cihi(1),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
}
} else if ((dim == tbox::Dimension(3))) {
if (directions(0)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot3d0, CARTWGTAVGSIDEFLOT3D0) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(0, d),
cdata->getPointer(0, d));
}
if (directions(1)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot3d1, CARTWGTAVGSIDEFLOT3D1) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(1, d),
cdata->getPointer(1, d));
}
if (directions(2)) {
SAMRAI_F77_FUNC(cartwgtavgsideflot3d2, CARTWGTAVGSIDEFLOT3D2) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
&ratio[0],
fgeom->getDx(),
cgeom->getDx(),
fdata->getPointer(2, d),
cdata->getPointer(2, d));
}
} else {
TBOX_ERROR("CartesianSideFloatWeightedAverage error...\n"
<< "dim > 3 not supported." << std::endl);
}
}
}
void
CartesianNodeComplexLinearRefine::refine(
hier::Patch& fine,
const hier::Patch& coarse,
const int dst_component,
const int src_component,
const hier::Box& fine_box,
const hier::IntVector& ratio) const
{
const tbox::Dimension& dim(fine.getDim());
TBOX_ASSERT_DIM_OBJDIM_EQUALITY3(dim, coarse, fine_box, ratio);
boost::shared_ptr<pdat::NodeData<dcomplex> > cdata(
BOOST_CAST<pdat::NodeData<dcomplex>, hier::PatchData>(
coarse.getPatchData(src_component)));
boost::shared_ptr<pdat::NodeData<dcomplex> > fdata(
BOOST_CAST<pdat::NodeData<dcomplex>, hier::PatchData>(
fine.getPatchData(dst_component)));
TBOX_ASSERT(cdata);
TBOX_ASSERT(fdata);
TBOX_ASSERT(cdata->getDepth() == fdata->getDepth());
const hier::Box cgbox(cdata->getGhostBox());
const hier::Index cilo = cgbox.lower();
const hier::Index cihi = cgbox.upper();
const hier::Index filo = fdata->getGhostBox().lower();
const hier::Index fihi = fdata->getGhostBox().upper();
const boost::shared_ptr<CartesianPatchGeometry> cgeom(
BOOST_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
coarse.getPatchGeometry()));
const boost::shared_ptr<CartesianPatchGeometry> fgeom(
BOOST_CAST<CartesianPatchGeometry, hier::PatchGeometry>(
fine.getPatchGeometry()));
TBOX_ASSERT(cgeom);
TBOX_ASSERT(fgeom);
const hier::Box coarse_box = hier::Box::coarsen(fine_box, ratio);
const hier::Index ifirstc = coarse_box.lower();
const hier::Index ilastc = coarse_box.upper();
const hier::Index ifirstf = fine_box.lower();
const hier::Index ilastf = fine_box.upper();
for (int d = 0; d < fdata->getDepth(); ++d) {
if ((dim == tbox::Dimension(1))) {
SAMRAI_F77_FUNC(cartlinrefnodecplx1d, CARTLINREFNODECPLX1D) (ifirstc(0),
ilastc(0),
ifirstf(0), ilastf(0),
cilo(0), cihi(0),
filo(0), fihi(0),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d));
} else if ((dim == tbox::Dimension(2))) {
SAMRAI_F77_FUNC(cartlinrefnodecplx2d, CARTLINREFNODECPLX2D) (ifirstc(0),
ifirstc(1), ilastc(0), ilastc(1),
ifirstf(0), ifirstf(1), ilastf(0), ilastf(1),
cilo(0), cilo(1), cihi(0), cihi(1),
filo(0), filo(1), fihi(0), fihi(1),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d));
} else if ((dim == tbox::Dimension(3))) {
SAMRAI_F77_FUNC(cartlinrefnodecplx3d, CARTLINREFNODECPLX3D) (ifirstc(0),
ifirstc(1), ifirstc(2),
ilastc(0), ilastc(1), ilastc(2),
ifirstf(0), ifirstf(1), ifirstf(2),
ilastf(0), ilastf(1), ilastf(2),
cilo(0), cilo(1), cilo(2),
cihi(0), cihi(1), cihi(2),
filo(0), filo(1), filo(2),
fihi(0), fihi(1), fihi(2),
&ratio[0],
cgeom->getDx(),
fgeom->getDx(),
cdata->getPointer(d),
fdata->getPointer(d));
} else {
TBOX_ERROR("CartesianNodeComplexLinearRefine error...\n"
<< "dim > 3 not supported." << std::endl);
}
}
}
void
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;
}