void EBCellFAB::setInvalidData(const Real& a_val, const int& a_comp) { CH_assert(a_comp >= 0); CH_assert(a_comp < m_nComp); if (m_ebisBox.isAllRegular()) { return; } else if (m_ebisBox.isAllCovered()) { m_regFAB.setVal(a_val, a_comp); } else { for (BoxIterator bit(m_region); bit.ok(); ++bit) { const IntVect& iv = bit(); if (m_ebisBox.isCovered(iv)) { m_regFAB(iv, a_comp) = a_val; } } //also set the multivalued cells for (IVSIterator ivsit(getMultiCells()); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); m_regFAB(iv, a_comp) = a_val; } //also set the multivalued cells } }
EBCellFAB& EBCellFAB::divide(const EBCellFAB& a_src, int a_srccomp, int a_destcomp, int a_numcomp) { CH_assert(isDefined()); CH_assert(a_src.isDefined()); // Dan G. feels strongly that the assert below should NOT be commented out // Brian feels that a weaker version of the CH_assert (if possible) is needed // Terry is just trying to get his code to work //CH_assert(m_ebisBox == a_src.m_ebisBox); CH_assert(a_srccomp + a_numcomp <= a_src.m_nComp); CH_assert(a_destcomp + a_numcomp <= m_nComp); bool sameRegBox = (a_src.m_regFAB.box() == m_regFAB.box()); Box locRegion = a_src.m_region & m_region; if (!locRegion.isEmpty()) { FORT_DIVIDETWOFAB(CHF_FRA(m_regFAB), CHF_CONST_FRA(a_src.m_regFAB), CHF_BOX(locRegion), CHF_INT(a_srccomp), CHF_INT(a_destcomp), CHF_INT(a_numcomp)); if (sameRegBox && (locRegion == m_region && locRegion == a_src.m_region)) { Real* l = m_irrFAB.dataPtr(a_destcomp); const Real* r = a_src.m_irrFAB.dataPtr(a_srccomp); int nvof = m_irrFAB.numVoFs(); CH_assert(nvof == a_src.m_irrFAB.numVoFs()); for (int i=0; i<a_numcomp*nvof; i++) l[i]/=r[i]; } else { IntVectSet ivsMulti = a_src.getMultiCells(); ivsMulti &= getMultiCells(); ivsMulti &= locRegion; IVSIterator ivsit(ivsMulti); for (ivsit.reset(); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); Vector<VolIndex> vofs = m_ebisBox.getVoFs(iv); for (int ivof = 0; ivof < vofs.size(); ivof++) { const VolIndex& vof = vofs[ivof]; for (int icomp = 0; icomp < a_numcomp; ++icomp) { m_irrFAB(vof, a_destcomp+icomp) /= a_src.m_irrFAB(vof, a_srccomp+icomp); } } } } } return *this; }
EBCellFAB& EBCellFAB::plus(const EBCellFAB& a_src, const Box& a_region, int a_srccomp, int a_destcomp, int a_numcomp) { CH_assert(isDefined()); CH_assert(a_src.isDefined()); CH_assert(a_srccomp + a_numcomp <= a_src.m_nComp); CH_assert(a_destcomp + a_numcomp <= m_nComp); const Box& locRegion = a_region; bool sameRegBox = (a_src.m_regFAB.box() == m_regFAB.box()); if (!locRegion.isEmpty()) { FORT_ADDTWOFAB(CHF_FRA(m_regFAB), CHF_CONST_FRA(a_src.m_regFAB), CHF_BOX(locRegion), CHF_INT(a_srccomp), CHF_INT(a_destcomp), CHF_INT(a_numcomp)); if (sameRegBox && (locRegion == m_region && locRegion == a_src.m_region)) { Real* l = m_irrFAB.dataPtr(a_destcomp); const Real* r = a_src.m_irrFAB.dataPtr(a_srccomp); int nvof = m_irrFAB.numVoFs(); CH_assert(nvof == a_src.m_irrFAB.numVoFs()); for (int i=0; i<a_numcomp*nvof; i++) l[i]+=r[i]; } else { IntVectSet ivsMulti = a_src.getMultiCells(); ivsMulti &= getMultiCells(); ivsMulti &= locRegion; IVSIterator ivsit(ivsMulti); for (ivsit.reset(); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); Vector<VolIndex> vofs = m_ebisBox.getVoFs(iv); for (int ivof = 0; ivof < vofs.size(); ivof++) { const VolIndex& vof = vofs[ivof]; for (int icomp = 0; icomp < a_numcomp; ++icomp) { m_irrFAB(vof, a_destcomp+icomp) += a_src.m_irrFAB(vof, a_srccomp+icomp); } } } } } return *this; }
bool IntVectSet::contains(const IntVectSet& ivs) const { if (&ivs == this) return true; for (IVSIterator ivsit(ivs); ivsit.ok(); ++ivsit) { if (!contains(ivsit())) return false; } //return true for empty input return true; }
void FourthOrderPatchInterp::interpToFine(/// interpolated solution on this level FArrayBox& a_fine, /// coarse solution const FArrayBox& a_coarse, /// stencils const BaseFab<IntVect>& a_stencils, /// we fill in fine cells within these coarse cells const IntVectSet& a_ivs) { CH_assert(m_defined); // CH_assert(m_isCoarseBoxSet); for (IVSIterator ivsit(a_ivs); ivsit.ok(); ++ivsit) { const IntVect& ivc = ivsit(); const IntVect& stencilIndex = a_stencils(ivc, 0); const FourthOrderInterpStencil& stencil = *m_stencils(stencilIndex, 0); // Using coarseFab, fill fine cells of fineFab within ivc. stencil.fillFine(a_fine, a_coarse, ivc); } }
void SlabService::fillGraph(BaseFab<int>& a_regIrregCovered, Vector<IrregNode>& a_nodes, const Box& a_validRegion, const Box& a_ghostRegion, const ProblemDomain& a_domain, const RealVect& a_origin, const Real& a_dx) const { Box grownCovBox = grow(m_coveredRegion, 1); grownCovBox &= a_ghostRegion; IntVectSet ivsIrreg(grownCovBox); ivsIrreg -= m_coveredRegion; ivsIrreg &= a_domain; //set regirregcoverred flags CH_assert(a_regIrregCovered.box().contains(a_ghostRegion)); //set every cell to regular a_regIrregCovered.setVal(1); for (BoxIterator bit(a_ghostRegion); bit.ok(); ++bit) { if (m_coveredRegion.contains(bit())) { //set covered cells to -1 a_regIrregCovered(bit(), 0) = -1; } else if (ivsIrreg.contains(bit())) { //set irreg cells to 0 a_regIrregCovered(bit(), 0) = 0; } } //now loop through irreg cells and make Nodes for them a_nodes.resize(0); for (IVSIterator ivsit(ivsIrreg); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); if (a_validRegion.contains(iv)) { IrregNode node; //first the obvious node.m_cell = iv; node.m_volFrac = 1.0; node.m_cellIndex = 0; node.m_volCentroid = RealVect::Zero; //any time the next cell over is in the covered //region, there is no face. If there is a cell //but it is outside the domain, the arc=-1 to signify //a boundary face. Otherwise, the arc is -2 if it //is to a regular cell and 0 if it is to an irregular cell for (int idir = 0; idir < SpaceDim; idir++) { for (SideIterator sit; sit.ok(); ++sit) { int arcIndex = node.index(idir, sit()); Vector<int>& arcs = node.m_arc[arcIndex]; Vector<Real>& areaFracs= node.m_areaFrac[arcIndex]; Vector<RealVect>& faceCents= node.m_faceCentroid[arcIndex]; IntVect otherIV = iv + sign(sit())*BASISV(idir); if (m_coveredRegion.contains(otherIV)) { //do nothing, covered face. leave the vector empty } else { int otherCellIndex; if (ivsIrreg.contains(otherIV)) { //arc irregular cell inside the domain otherCellIndex = 0; } else if (!a_domain.contains(otherIV)) { //boundary face otherCellIndex = -1; } else { //arc to regular cell otherCellIndex = -2; } arcs.push_back(otherCellIndex); Real areaFrac = 1.0; RealVect faceCent = RealVect::Zero; areaFracs.push_back(areaFrac); faceCents.push_back(faceCent); } //end otherIV not covered } } //the boundary centroid and normal //depend on which side is covered for (int idir = 0; idir < SpaceDim; idir++) { for (SideIterator sit; sit.ok(); ++sit) { int arcIndex = node.index(idir, sit()); Vector<int>& arcs = node.m_arc[arcIndex]; if (arcs.size() == 0) { int isign = sign(sit()); node.m_bndryCentroid[idir] = Real(isign)*0.5; } } } a_nodes.push_back(node); } } }
EBCellFAB& EBCellFAB::axby(const EBCellFAB& a_X, const EBCellFAB& a_Y, const Real& a_A, const Real& a_B, const int& a_destComp,const int& a_xComp,const int& a_yComp) { CH_assert(isDefined()); CH_assert(a_X.isDefined()); CH_assert(a_Y.isDefined()); // Dan G. feels strongly that the assert below should NOT be commented out // Brian feels that a weaker version of the CH_assert (if possible) is needed // Terry is just trying to get his code to work //CH_assert(m_ebisBox == a_X.m_ebisBox); CH_assert(m_nComp > a_destComp); CH_assert(a_X.m_nComp > a_xComp); CH_assert(a_Y.m_nComp > a_yComp); Box locRegion = a_X.m_region & m_region & a_Y.m_region; bool sameRegBox = (a_X.m_regFAB.box() == a_Y.m_regFAB.box()) && (a_X.m_regFAB.box() == m_regFAB.box()); if (!locRegion.isEmpty()) { FORT_AXBYFABCOMP(CHF_FRA(m_regFAB), CHF_CONST_FRA(a_X.m_regFAB), CHF_CONST_FRA(a_Y.m_regFAB), CHF_CONST_REAL(a_A), CHF_CONST_REAL(a_B), CHF_CONST_INT(a_destComp), CHF_CONST_INT(a_xComp), CHF_CONST_INT(a_yComp), CHF_BOX(locRegion)); bool nvofTest = false; bool regionTest = false; //CP: we do a thorough test here to see if all VoFs are the same, just being cautious const Vector<VolIndex>& vofs = m_irrFAB.getVoFs(); const Vector<VolIndex>& vofs_x = a_X.m_irrFAB.getVoFs(); const Vector<VolIndex>& vofs_y = a_Y.m_irrFAB.getVoFs(); if (vofs.size() == vofs_x.size() && vofs.size()==vofs_y.size()) { nvofTest = true; for (int i=0; i<vofs.size(); i++) { if (vofs[i] != vofs_x[i] || vofs[i] != vofs_y[i]) { nvofTest = false; break; } } } if (locRegion == a_X.m_region && locRegion == a_Y.m_region && locRegion == m_region) regionTest = true; if (sameRegBox && regionTest && nvofTest) { const Real* l = a_X.m_irrFAB.dataPtr(a_xComp); const Real* r = a_Y.m_irrFAB.dataPtr(a_yComp); Real* c = m_irrFAB.dataPtr(a_destComp); int nvof = a_X.m_irrFAB.numVoFs(); int numComp = 1; for (int i=0; i< numComp*nvof; i++) c[i] = l[i] * a_A + r[i] * a_B; } else { IntVectSet ivsMulti = a_X.getMultiCells(); ivsMulti &= a_Y.getMultiCells(); ivsMulti &= getMultiCells(); // opt might be to take this out ivsMulti &= locRegion; IVSIterator ivsit(ivsMulti); for (ivsit.reset(); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); Vector<VolIndex> vofs = m_ebisBox.getVoFs(iv); for (int ivof = 0; ivof < vofs.size(); ivof++) { const VolIndex& vof = vofs[ivof]; if (locRegion.contains(vof.gridIndex())) { m_irrFAB(vof, a_destComp) = a_X.m_irrFAB(vof, a_xComp) * a_A + a_Y.m_irrFAB(vof, a_yComp) * a_B; } } } } } return *this; }
EBCellFAB& EBCellFAB::mult(const EBCellFAB& a_src, int a_srccomp, int a_destcomp, int a_numcomp) { CH_assert(isDefined()); CH_assert(a_src.isDefined()); // Dan G. feels strongly that the assert below should NOT be commented out // Brian feels that a weaker version of the CH_assert (if possible) is needed // Terry is just trying to get his code to work //CH_assert(m_ebisBox == a_src.m_ebisBox); CH_assert(a_srccomp + a_numcomp <= a_src.m_nComp); CH_assert(a_destcomp + a_numcomp <= m_nComp); if (s_verbose) { IntVect ivdebug(D_DECL(964,736,0)); VolIndex vof(ivdebug, 0); pout() << "EBCellFAB phi(vof) = " << (*this)(vof, 0); pout() << ", a(vof) = " << a_src(vof, 0); Real aphi = (*this)(vof, 0) * a_src(vof, 0); pout() << ", aphi(calc) = " << aphi << endl; } Box locRegion = a_src.m_region & m_region; bool sameRegBox = (a_src.m_regFAB.box() == m_regFAB.box()); if (!locRegion.isEmpty()) { FORT_MULTIPLYTWOFAB(CHF_FRA(m_regFAB), CHF_CONST_FRA(a_src.m_regFAB), CHF_BOX(locRegion), CHF_INT(a_srccomp), CHF_INT(a_destcomp), CHF_INT(a_numcomp)); if (sameRegBox && (locRegion == m_region && locRegion == a_src.m_region)) { Real* l = m_irrFAB.dataPtr(a_destcomp); const Real* r = a_src.m_irrFAB.dataPtr(a_srccomp); int nvof = m_irrFAB.numVoFs(); CH_assert(nvof == a_src.m_irrFAB.numVoFs()); for (int i=0; i<a_numcomp*nvof; i++) l[i]*=r[i]; } else { IntVectSet ivsMulti = a_src.getMultiCells(); ivsMulti &= getMultiCells(); ivsMulti &= locRegion; IVSIterator ivsit(ivsMulti); for (ivsit.reset(); ivsit.ok(); ++ivsit) { const IntVect& iv = ivsit(); Vector<VolIndex> vofs = m_ebisBox.getVoFs(iv); for (int ivof = 0; ivof < vofs.size(); ivof++) { const VolIndex& vof = vofs[ivof]; for (int icomp = 0; icomp < a_numcomp; ++icomp) { m_irrFAB(vof, a_destcomp+icomp) *= a_src.m_irrFAB(vof, a_srccomp+icomp); } } } } } if (s_verbose) { IntVect ivdebug(D_DECL(964,736,0)); VolIndex vof(ivdebug, 0); pout() << ", aphi(aft) = " << (*this)(vof, 0) << endl; } return *this; }
void EBPoissonOp:: getOpFaceStencil(VoFStencil& a_stencil, const Vector<VolIndex>& a_allMonotoneVoFs, const EBISBox& a_ebisbox, const VolIndex& a_VoF, int a_dir, const Side::LoHiSide& a_side, const FaceIndex& a_face, const bool& a_lowOrder) { a_stencil.clear(); const RealVect& faceCentroid = a_ebisbox.centroid(a_face); const IntVect& origin = a_VoF.gridIndex(); IntVect dirs = IntVect::Zero; for (int idir = 0; idir < SpaceDim; idir++) { if (idir != a_dir) { IntVect ivPlus = origin; ivPlus[idir] += 1; if (faceCentroid[idir] < 0.0) { dirs[idir] = -1; } else if (faceCentroid[idir] > 0.0) { dirs[idir] = 1; } else if (m_eblg.getDomain().contains(ivPlus)) { dirs[idir] = 1; } else { dirs[idir] = -1; } } } bool orderOne = true; if (m_orderEB == 0 || a_lowOrder) { orderOne = false; } else { IntVect loVect = dirs; loVect.min(IntVect::Zero); IntVect hiVect = dirs; hiVect.max(IntVect::Zero); Box fluxBox(loVect,hiVect); IntVectSet fluxIVS(fluxBox); IVSIterator ivsit(fluxIVS); for (ivsit.begin(); ivsit.ok(); ++ivsit) { bool curOkay; IntVect ivDelta = ivsit(); IntVect iv1 = ivDelta; iv1 += origin; VolIndex VoF1; curOkay = EBArith::isVoFHere(VoF1,a_allMonotoneVoFs,iv1); IntVect iv2 = iv1; iv2[a_dir] += sign(a_side); VolIndex VoF2; curOkay = curOkay && EBArith::isVoFHere(VoF2,a_allMonotoneVoFs,iv2); orderOne = orderOne && curOkay; if (curOkay) { VoFStencil curPair; curPair.add(VoF1,-m_invDx2[a_dir]); curPair.add(VoF2, m_invDx2[a_dir]); for (int idir = 0; idir < SpaceDim; idir++) { if (idir != a_dir) { if (ivDelta[idir] == 0) { curPair *= 1 - abs(faceCentroid[idir]); } else { curPair *= abs(faceCentroid[idir]); } } } a_stencil += curPair; } } } if (!orderOne) { VolIndex VoF1 = a_VoF; VolIndex VoF2 = a_face.getVoF(a_side); if (a_ebisbox.getRegion().contains(VoF2.gridIndex())) { a_stencil.clear(); a_stencil.add(VoF1,-m_invDx2[a_dir]); a_stencil.add(VoF2, m_invDx2[a_dir]); } } if (!a_lowOrder) { a_stencil *= a_ebisbox.areaFrac(a_face); } }