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