本文整理汇总了C++中EBISBox类的典型用法代码示例。如果您正苦于以下问题：C++ EBISBox类的具体用法？C++ EBISBox怎么用？C++ EBISBox使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了EBISBox类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: setToExactFlux
void
setToExactFlux(EBFluxFAB& a_flux,
const EBISBox& a_ebisBox,
const Box& a_region,
const Real& a_dx)
{
IntVectSet ivsregion(a_region);
for (int faceDir = 0; faceDir < SpaceDim; faceDir++)
{
for (FaceIterator faceit(ivsregion, a_ebisBox.getEBGraph(), faceDir, FaceStop::SurroundingWithBoundary); faceit.ok(); ++faceit)
{
RealVect xval;
IntVect iv = faceit().gridIndex(Side::Hi);
RealVect centroid = a_ebisBox.centroid(faceit());
for (int idir = 0; idir < SpaceDim; idir++)
{
if (idir == faceDir)
{
xval[idir] = (Real(iv[idir]))*a_dx;
}
else
{
xval[idir] = (Real(iv[idir]) + 0.5 + centroid[idir])*a_dx;
}
}
Real fluxDir = exactFlux(xval, faceDir);
a_flux[faceDir](faceit(), 0) = fluxDir;
}
} //end loop over face directions
}示例2: fluxBC
void
NoFlowAdvectBC::
fluxBC(EBFluxFAB& a_primGdnv,
const EBCellFAB& a_primCenter,
const EBCellFAB& a_primExtrap,
const Side::LoHiSide& a_side,
const Real& a_time,
const EBISBox& a_ebisBox,
const DataIndex& a_dit,
const Box& a_box,
const Box& a_faceBox,
const int& a_dir)
{
CH_assert(m_isDefined);
Box FBox = a_faceBox;
Box cellBox = FBox;
CH_assert(a_primGdnv[a_dir].nComp()==1);
// Determine which side and thus shifting directions
int isign = sign(a_side);
cellBox.shiftHalf(a_dir,isign);
// Is there a domain boundary next to this grid
if (!m_domain.contains(cellBox))
{
cellBox &= m_domain;
// Find the strip of cells next to the domain boundary
Box bndryBox = adjCellBox(cellBox, a_dir, a_side, 1);
// Shift things to all line up correctly
bndryBox.shift(a_dir,-isign);
IntVectSet ivs(bndryBox);
for (VoFIterator vofit(ivs, a_ebisBox.getEBGraph()); vofit.ok(); ++vofit)
{
const VolIndex& vof = vofit();
Vector<FaceIndex> bndryFaces = a_ebisBox.getFaces(vof, a_dir, a_side);
for (int iface= 0; iface < bndryFaces.size(); iface++)
{
const FaceIndex& face = bndryFaces[iface];
//set all fluxes to zero then fix momentum flux
//solid wall
if (a_dir == m_velComp)
{
a_primGdnv[a_dir](face, 0) = 0.0;
}
else
{
a_primGdnv[a_dir](face, 0) = a_primExtrap(vof, 0);
}
}
}
}
}示例3: copyBIFFToEBFF
bool
EBFluxRegister::
copyBIFFToEBFF(EBFaceFAB& a_dst,
const BaseIFFAB<Real>& a_src,
const Box & a_box,
const EBISBox& a_ebisBox)
{
IntVectSet ivs = a_src.getIVS();
ivs &= a_box;
bool hasCells = !(ivs.isEmpty());
if (hasCells)
{
a_dst.define(a_ebisBox, a_box, a_src.direction(), a_src.nComp());
a_dst.setVal(0.);
for (FaceIterator faceit(ivs, a_ebisBox.getEBGraph(),
a_src.direction(),
FaceStop::SurroundingWithBoundary);
faceit.ok(); ++faceit)
{
for (int icomp = 0; icomp < a_src.nComp(); icomp++)
{
a_dst(faceit(), icomp) = a_src(faceit(), icomp);
}
}
}
return (hasCells);
}示例4: getOpVoFStencil
void EBPoissonOp::
getOpVoFStencil(VoFStencil& a_stencil,
const int& a_idir,
const Vector<VolIndex>& a_allMonotoneVoFs,
const EBISBox& a_ebisbox,
const VolIndex& a_VoF,
const bool& a_lowOrder)
{
for (SideIterator sit; sit.ok(); ++sit)
{
Side::LoHiSide side = sit();
Vector<FaceIndex> faces;
faces = a_ebisbox.getFaces(a_VoF,a_idir,side);
for (int iface = 0; iface < faces.size(); iface++)
{
FaceIndex face = faces[iface];
VoFStencil faceStencil;
getOpFaceStencil(faceStencil,a_allMonotoneVoFs,a_ebisbox,a_VoF,
a_idir,side,face,a_lowOrder);
a_stencil += faceStencil;
}
}
}示例5: testEBFluxFAB
int
testEBFluxFAB(const EBISBox& a_ebisBox, const Box& a_box)
{
Interval comps(0,0);
IntVectSet ivs(a_box);
EBFluxFAB srcFab( a_ebisBox, a_box, 1);
EBFluxFAB dstFab( a_ebisBox, a_box, 1);
for (int idir = 0; idir < SpaceDim; idir++)
{
//set source fab to right ans
for (FaceIterator faceit(ivs, a_ebisBox.getEBGraph(), idir, FaceStop::SurroundingWithBoundary);
faceit.ok(); ++faceit)
{
srcFab[idir](faceit(), 0) = rightAns(faceit());
}
}
//linearize the data to dst
int sizeFab = srcFab.size(a_box, comps);
unsigned char* buf = new unsigned char[sizeFab];
srcFab.linearOut(buf, a_box, comps);
dstFab.linearIn( buf, a_box, comps);
delete[] buf;
//check the answer
int eekflag = 0;
for (int idir = 0; idir < SpaceDim; idir++)
{
Real tolerance = 0.001;
for (FaceIterator faceit(ivs, a_ebisBox.getEBGraph(), idir, FaceStop::SurroundingWithBoundary);
faceit.ok(); ++faceit)
{
Real correct = rightAns(faceit());
if (Abs(dstFab[idir](faceit(), 0) - correct) > tolerance)
{
pout() << "ivfab test failed at face "
<< faceit().gridIndex(Side::Lo)
<< faceit().gridIndex(Side::Hi) << endl;
eekflag = -4;
return eekflag;
}
}
}
return 0;
}示例6: getAreaFracs
void
EBGradDivFilter::
getAreaFracs(Vector<FaceIndex> a_facesLo[SpaceDim],
Vector<FaceIndex> a_facesHi[SpaceDim],
bool a_hasFacesLo[SpaceDim],
bool a_hasFacesHi[SpaceDim],
RealVect& a_areaFracLo,
RealVect& a_areaFracHi,
const VolIndex& a_vof,
const EBISBox& a_ebisBox)
{
for (int idir = 0; idir < SpaceDim; idir++)
{
Real areaSumLo = 0;
Real areaSumHi = 0;
a_facesLo[idir] = a_ebisBox.getFaces(a_vof, idir, Side::Lo);
a_facesHi[idir] = a_ebisBox.getFaces(a_vof, idir, Side::Hi);
a_hasFacesLo[idir] = ( ( a_facesLo[idir].size() > 0) &&
(!a_facesLo[idir][0].isBoundary()));
a_hasFacesHi[idir] = ( ( a_facesHi[idir].size() > 0) &&
(!a_facesHi[idir][0].isBoundary()));
//want boundary faces to look covered
if (a_hasFacesLo[idir])
{
for (int iface = 0; iface < a_facesLo[idir].size(); iface++)
{
areaSumLo += a_ebisBox.areaFrac(a_facesLo[idir][iface]);
}
}
//want boundary faces to look covered
if (a_hasFacesHi[idir])
{
for (int iface = 0; iface < a_facesHi[idir].size(); iface++)
{
areaSumHi += a_ebisBox.areaFrac(a_facesHi[idir][iface]);
}
}
a_areaFracLo[idir] = areaSumLo;
a_areaFracHi[idir] = areaSumHi;
}
}示例7: setToExactDivF
void
setToExactDivF(EBCellFAB& a_exactDivF,
const EBISBox& a_ebisBox,
const Box& a_region,
const Real& a_dx)
{
a_exactDivF.setVal(0.);
IntVectSet ivsregion(a_region);
for (VoFIterator vofit(ivsregion, a_ebisBox.getEBGraph()); vofit.ok(); ++vofit)
{
const VolIndex& vof = vofit();
RealVect xval;
IntVect iv = vof.gridIndex();
for (int idir = 0; idir < SpaceDim; idir++)
{
xval[idir] = (Real(iv[idir]) + 0.5)*a_dx;
}
Real solnrv = exactDivergence(xval);
Real kappa = a_ebisBox.volFrac(vof);
a_exactDivF(vof,0) = kappa*solnrv;
}
}示例8: testIVFAB
int
testIVFAB(const EBISBox& a_ebisBox, const Box& a_box)
{
IntVectSet ivs = a_ebisBox.getIrregIVS(a_box);
if (ivs.isEmpty()) return 0;
Interval comps(0,0);
BaseIVFAB<Real> srcFab(ivs, a_ebisBox.getEBGraph(), 1);
BaseIVFAB<Real> dstFab(ivs, a_ebisBox.getEBGraph(), 1);
//set source fab to right ans
for (VoFIterator vofit(ivs, a_ebisBox.getEBGraph()); vofit.ok(); ++vofit)
{
srcFab(vofit(), 0) = rightAns(vofit());
}
//linearize the data to dst
int sizeFab = srcFab.size(a_box, comps);
unsigned char* buf = new unsigned char[sizeFab];
srcFab.linearOut(buf, a_box, comps);
dstFab.linearIn( buf, a_box, comps);
delete[] buf;
//check the answer
int eekflag = 0;
Real tolerance = 0.001;
for (VoFIterator vofit(ivs, a_ebisBox.getEBGraph()); vofit.ok(); ++vofit)
{
Real correct = rightAns(vofit());
if (Abs(dstFab(vofit(), 0) - correct) > tolerance)
{
pout() << "ivfab test failed at vof " << vofit().gridIndex() << endl;
eekflag = -1;
return eekflag;
}
}
return 0;
}示例9: divergence
Real
divergence(const EBFluxFAB& a_func,
const RealVect& a_bndryFlux,
const EBISBox& a_ebisBox,
const VolIndex& a_vof,
const Real& a_dx)
{
Real retval = 0;
Real bndryArea = a_ebisBox.bndryArea(a_vof);
RealVect normal = a_ebisBox.normal(a_vof);
for (int idir = 0; idir < SpaceDim; idir++)
{
Real bndryFlux = a_bndryFlux[idir]; //normal already dealt with
Real bndryContrib = -bndryFlux*bndryArea*normal[idir];
Real openContrib = 0;
if (bndryArea > 1.0e-3)
{
openContrib = 0;
}
for (SideIterator sit; sit.ok(); ++sit)
{
int isign = sign(sit());
Real rsign = isign;
Vector<FaceIndex> faces = a_ebisBox.getFaces(a_vof, idir, sit());
for (int iface = 0; iface < faces.size(); ++iface)
{
Real areaFrac = a_ebisBox.areaFrac(faces[iface]);
Real faceFlux = a_func[idir](faces[iface], 0);
openContrib += rsign*faceFlux*areaFrac;
}
}
retval += openContrib + bndryContrib;
}
retval /= a_dx;
return retval;
}示例10: advectToFacesBCG
void
EBLevelAdvect::
advectToFacesBCG(EBFluxFAB& a_extrapState,
BaseIVFAB<Real>& a_boundaryPrim,
const EBCellFAB & a_consState,
const EBCellFAB & a_normalVel,
const EBFluxFAB & a_advectionVel,
const Box& a_cellBox,
const EBISBox& a_ebisBox,
const Real& a_dt,
const Real& a_time,
const EBCellFAB & a_source,
const DataIndex& a_dit,
bool a_doBoundaryPrim)
{
CH_TIME("EBLevelAdvect::advectToFacesBCG (fluxfab)");
IntVectSet cfivs; //not used here. only used in flux interpolation
m_ebPatchAdvect[a_dit]->setTimeAndDt(a_time, a_dt);
// EBCellFAB& primState = m_ebPatchAdvect[a_dit]->getPrimState();
m_ebPatchAdvect[a_dit]->setVelocities(a_normalVel, a_advectionVel);
//placeholder (no flattening used here)
EBCellFAB flattening;
//not reused
EBCellFAB slopesPrim[SpaceDim];
EBCellFAB slopesSeco[SpaceDim];
bool verbose = false;
m_ebPatchAdvect[a_dit]->extrapolateBCG(a_extrapState,
// primState,
slopesPrim,
slopesSeco,
flattening,
a_consState,
a_source,
a_cellBox,
a_dit,
verbose);
if (a_doBoundaryPrim)
{
IntVectSet irregIVS = a_ebisBox.getIrregIVS(a_cellBox);
m_ebPatchAdvect[a_dit]->computeEBIrregFlux(a_boundaryPrim,
// primState,
a_consState,
slopesPrim,
irregIVS,
a_source);
}
}示例11: setBorkedFlux
void setBorkedFlux(EBFluxFAB& a_flux,
const EBISBox& a_ebisBox,
const Box& a_box,
const RealVect& a_fluxVal,
const BaseFab<int>& a_map)
{
for (int idir = 0; idir < SpaceDim; idir++)
{
Real bogval = 0;
//the bogus value will be zero so it will not
//do to have the correct value be zero
if (Abs(a_fluxVal[idir]) < 1.0e-3) bogval = 1.0;
a_flux[idir].setVal(a_fluxVal[idir]);
//if i am in a 1d box and the box next to me
//is 2d, set the border flux to
for (SideIterator sit; sit.ok(); ++sit)
{
Box borderBox;
if (sit() == Side::Lo)
{
borderBox = adjCellLo(a_box, idir, -1);
}
else
{
borderBox = adjCellHi(a_box, idir, -1);
}
for (BoxIterator bit(borderBox); bit.ok(); ++bit)
{
const IntVect& thisIV = bit();
IntVect thatIV = thisIV + sign(sit())*BASISV(idir);
if ((a_map(thisIV, 0) == 1) && (a_map(thatIV, 0) == 2))
{
Vector<FaceIndex> faces = a_ebisBox.getAllFaces(thisIV, idir, sit());
for (int iface = 0; iface < faces.size(); iface++)
{
a_flux[idir](faces[iface],0) = bogval;
}
}
}
}
}
}示例12: getEBCFIVSGrid
void EBCFData::
getEBCFIVSGrid(IntVectSet& a_ebcfivs,
const Box& a_grid,
const int& a_idir,
const Side::LoHiSide& a_side,
const IntVect& a_diagGrow,
const ProblemDomain& a_domain,
const IntVectSet& a_cfivs,
const EBISBox& a_ebisBox)
{
Box gridSide = adjCellBox(a_grid, a_idir, a_side, 1);
Box grownBoxSide = gridSide;
grownBoxSide &= a_domain;
for (int jdir = 0; jdir < SpaceDim; jdir++)
{
if (jdir != a_idir)
{
grownBoxSide.grow(jdir, a_diagGrow[jdir]);
}
}
grownBoxSide &= a_domain;
a_ebcfivs = a_cfivs;
for (int jdir = 0; jdir < SpaceDim; jdir++)
{
if (jdir != a_idir)
{
a_ebcfivs.grow(jdir, a_diagGrow[jdir]);
}
}
IntVectSet ivsIrreg = a_ebisBox.getIrregIVS(grownBoxSide);
ivsIrreg.grow(3);
ivsIrreg &= a_domain;
a_ebcfivs &= ivsIrreg;
a_ebcfivs &= gridSide;
}示例13: correctTangentialVelocity
void
EBCompositeMACProjector::
correctTangentialVelocity(EBFaceFAB& a_velocity,
const EBFaceFAB& a_gradient,
const Box& a_grid,
const EBISBox& a_ebisBox,
const IntVectSet& a_cfivs)
{
CH_TIME("EBCompositeMACProjector::correctTangentialVelocity");
int velDir = a_velocity.direction();
int gradDir = a_gradient.direction();
//veldir is the face on which the velocity lives
//graddir is the direction of the component
//and the face on which the mac gradient lives
CH_assert(velDir != gradDir);
CH_assert(a_velocity.nComp() == 1);
CH_assert(a_gradient.nComp() == 1);
//updating in place in fortran so we have to save a acopy
EBFaceFAB velSave(a_ebisBox, a_velocity.getCellRegion(), velDir, 1);
velSave.copy(a_velocity);
//interior box is the box where all of the stencil can be reached
//without going out of the domain
ProblemDomain domainBox = a_ebisBox.getDomain();
Box interiorBox = a_grid;
interiorBox.grow(1);
interiorBox &= domainBox;
interiorBox.grow(-1);
Box interiorFaceBox = surroundingNodes(interiorBox, velDir);
if (!interiorBox.isEmpty())
{
BaseFab<Real>& regVel = a_velocity.getSingleValuedFAB();
const BaseFab<Real>& regGrad = a_gradient.getSingleValuedFAB();
FORT_REGCORRECTTANVEL(CHF_FRA1(regVel,0),
CHF_CONST_FRA1(regGrad,0),
CHF_BOX(interiorFaceBox),
CHF_INT(velDir),
CHF_INT(gradDir));
}
//do only irregular and boundary cells pointwise
IntVectSet ivsIrreg = a_ebisBox.getIrregIVS(a_grid);
IntVectSet ivsGrid(a_grid);
ivsGrid -= interiorBox;
ivsGrid |= ivsIrreg;
FaceIterator faceit(ivsGrid, a_ebisBox.getEBGraph(), velDir, FaceStop::SurroundingWithBoundary);
for (faceit.reset(); faceit.ok(); ++faceit)
{
//average neighboring grads in grad dir direction
int numGrads = 0;
Real gradAve = 0.0;
const FaceIndex& velFace = faceit();
for (SideIterator sitVel; sitVel.ok(); ++sitVel)
{
const VolIndex& vofSide = velFace.getVoF(sitVel());
const IntVect& ivSide = vofSide.gridIndex();
//do not include stuff over coarse-fine interface and inside the domain
//cfivs includes cells just outside domain
if (!a_cfivs.contains(ivSide) && domainBox.contains(ivSide))
{
for (SideIterator sitGrad; sitGrad.ok(); ++sitGrad)
{
Vector<FaceIndex> gradFaces = a_ebisBox.getFaces(vofSide, gradDir, sitGrad());
for (int iface = 0; iface < gradFaces.size(); iface++)
{
if (!gradFaces[iface].isBoundary())
{
numGrads++;
gradAve += a_gradient(gradFaces[iface], 0);
}
}
}//end loop over gradient sides
}//end cfivs check
else
{
// inside coarse/fine interface or at domain boundary. extrapolate from neighboring vofs to get the gradient
const Side::LoHiSide inSide = flip(sitVel());
const VolIndex& inSideVof = velFace.getVoF(inSide);
const IntVect& inSideIV = inSideVof.gridIndex();
IntVect inSideFarIV = inSideIV;
inSideFarIV[velDir] += sign(inSide);
if (domainBox.contains(inSideIV) && domainBox.contains(inSideFarIV))
{
Vector<VolIndex> farVofs = a_ebisBox.getVoFs(inSideFarIV);
if (farVofs.size() == 1)
{
const VolIndex& inSideFarVof = farVofs[0];
for (SideIterator sitGrad; sitGrad.ok(); ++sitGrad)
{
//get the grad for the face adjoining inSideVof on the sitGrad side, in the gradDir direction
Vector<FaceIndex> gradFaces = a_ebisBox.getFaces(inSideVof , gradDir, sitGrad());
Vector<FaceIndex> gradFarFaces = a_ebisBox.getFaces(inSideFarVof, gradDir, sitGrad());
if ( (gradFaces.size() == 1) && (gradFarFaces.size() == 1) )
{
// if ( (!gradFaces[0].isBoundary()) && (!gradFarFaces[0].isBoundary()) )
// {
const Real& inSideGrad = a_gradient(gradFaces[0], 0);
//.........这里部分代码省略.........
示例14: correctVelocityComponent
void
EBCompositeMACProjector::
correctVelocityComponent(BaseIVFAB<Real> & a_coveredVel,
const Vector<VolIndex>& a_coveredFace,
const IntVectSet & a_coveredSets,
const EBFluxFAB & a_macGradient,
const EBISBox & a_ebisBox,
int a_coveredFaceDir, Side::LoHiSide a_sd, int a_faceGradComp)
{
CH_TIME("EBCompositeMACProjector::correctVelocityComponent");
//if a_coveredFaceDir == faceGradComp, just linearly extrapolate gradient and subtract.
//if a_coveredFaceDir != faceGradComp, need to average to cell centers then extrapolate and subtract
CH_assert(a_coveredVel.nComp() == 1);
CH_assert(a_macGradient.nComp() == 1);
const EBFaceFAB& macGradFAB = a_macGradient[a_faceGradComp];
for (int ivof = 0; ivof < a_coveredFace.size(); ivof++)
{
const VolIndex& vof = a_coveredFace[ivof];
Vector<FaceIndex> nearFaces, farFaces;
bool hasNearFaces = false;
bool hasFarFaces = false;
VolIndex nearVoF, farVoF;
FaceIndex nearFace, farFace;
nearFaces = a_ebisBox.getFaces(vof, a_coveredFaceDir, flip(a_sd));
hasNearFaces = (nearFaces.size()==1) && (!nearFaces[0].isBoundary());
if (hasNearFaces)
{
nearFace = nearFaces[0];
nearVoF = nearFace.getVoF(flip(a_sd));
farFaces = a_ebisBox.getFaces(nearVoF, a_coveredFaceDir, flip(a_sd));
hasFarFaces = (farFaces.size()==1) && (!farFaces[0].isBoundary());
if (hasFarFaces)
{
farFace = farFaces[0];
farVoF = farFace.getVoF(flip(a_sd));
}
}
Real extrapGrad;
if (a_coveredFaceDir == a_faceGradComp)
{
//if a_coveredFaceDir == faceGradComp, just linearly extrapolate gradient and subtract.
if (hasNearFaces && hasFarFaces)
{
Real nearGrad = macGradFAB(nearFace, 0);
Real farGrad = macGradFAB(farFace, 0);
extrapGrad = 2.0*nearGrad - farGrad;
}
else if (hasNearFaces)
{
extrapGrad = macGradFAB(nearFace, 0);
}
else
{
extrapGrad = 0.0;
}
}
else
{
//if a_coveredFaceDir != faceGradComp, need to average to cell centers then extrapolate and subtract
Real nearGrad = getAverageFaceGrad(vof, macGradFAB, a_ebisBox, a_faceGradComp);
if (hasNearFaces)
{
Real farGrad = getAverageFaceGrad(nearVoF, macGradFAB, a_ebisBox, a_faceGradComp);
extrapGrad = 1.5*nearGrad - 0.5*farGrad;
}
else
{
extrapGrad = nearGrad;
}
}
a_coveredVel(vof, 0) -= extrapGrad;
}
}示例15: getAverageFaceGrad
Real
getAverageFaceGrad(const VolIndex& a_vof,
const EBFaceFAB& a_macGradient,
const EBISBox& a_ebisBox,
int a_faceDir)
{
CH_TIME("EBCompositeMACProjector::getAverageFaceGrad");
Vector<FaceIndex> hiFaces = a_ebisBox.getFaces(a_vof, a_faceDir, Side::Hi);
Vector<FaceIndex> loFaces = a_ebisBox.getFaces(a_vof, a_faceDir, Side::Lo);
bool hasHiFaces = (hiFaces.size() > 0);
bool hasLoFaces = (loFaces.size() > 0);
Real hiVal = 0.0;
Real loVal = 0.0;
if (hasHiFaces)
{
for (int iface = 0; iface < hiFaces.size(); iface++)
{
hiVal += a_macGradient(hiFaces[iface], 0);
}
hiVal /= hiFaces.size();
}
if (hasLoFaces)
{
for (int iface = 0; iface < loFaces.size(); iface++)
{
loVal += a_macGradient(loFaces[iface], 0);
}
loVal /= loFaces.size();
}
if (!hasLoFaces && hasHiFaces)
{
//only want to do the wacky extrapolation thing if not multivalued
if ((hiFaces.size() == 1) && (!hiFaces[0].isBoundary()))
{
const VolIndex& hiVoF = hiFaces[0].getVoF(Side::Hi);
Vector<FaceIndex> farFaces = a_ebisBox.getFaces(hiVoF, a_faceDir, Side::Hi);
if (farFaces.size() > 0)
{
Real farVal = 0.0;
for (int iface = 0; iface < farFaces.size(); iface++)
{
farVal += a_macGradient(farFaces[iface], 0);
}
farVal /= farFaces.size();
loVal = 2*hiVal - farVal;
}
else
{
loVal = hiVal;
}
}
else
{
loVal = hiVal;
}
}
if (!hasHiFaces && hasLoFaces)
{
//only want to do the wacky extrapolation thing if not multivalued
if ((loFaces.size() == 1) && (!loFaces[0].isBoundary()))
{
const VolIndex& hiVoF = loFaces[0].getVoF(Side::Lo);
Vector<FaceIndex> farFaces = a_ebisBox.getFaces(hiVoF, a_faceDir, Side::Lo);
if (farFaces.size() > 0)
{
Real farVal = 0.0;
for (int iface = 0; iface < farFaces.size(); iface++)
{
farVal += a_macGradient(farFaces[iface], 0);
}
farVal /= farFaces.size();
hiVal = 2*loVal - farVal;
}
else
{
hiVal = loVal;
}
}
else
{
hiVal = loVal;
}
}
Real retval = 0.5*(hiVal + loVal);
return retval;
}