void
kappaDivergence(EBCellFAB& a_divF,
const EBFluxFAB& a_flux,
const EBISBox& a_ebisBox,
const Box& a_box,
const Real& a_dx)
{
//set the divergence initially to zero
//then loop through directions and increment the divergence
//with each directions flux difference.
a_divF.setVal(0.0);
BaseFab<Real>& regDivF = a_divF.getSingleValuedFAB();
regDivF.setVal(0.);
for (int idir = 0; idir < SpaceDim; idir++)
{
//update for the regular vofs in the nonconservative
//case works for all single valued vofs.
/* do the regular vofs */
/**/
const EBFaceFAB& fluxDir = a_flux[idir];
const BaseFab<Real>& regFluxDir = fluxDir.getSingleValuedFAB();
int ncons = 1;
FORT_DIVERGEF( CHF_BOX(a_box),
CHF_FRA(regDivF),
CHF_CONST_FRA(regFluxDir),
CHF_CONST_INT(idir),
CHF_CONST_INT(ncons),
CHF_CONST_REAL(a_dx));
/**/
}
//update the irregular vofs using conservative diff
IntVectSet ivsIrreg = a_ebisBox.getIrregIVS(a_box);
for (VoFIterator vofit(ivsIrreg, a_ebisBox.getEBGraph()); vofit.ok(); ++vofit)
{
const VolIndex& vof = vofit();
//divergence was set in regular update. we reset it
// to zero and recalc.
Real update = 0.;
for ( int idir = 0; idir < SpaceDim; idir++)
{
const EBFaceFAB& fluxDir = a_flux[idir];
for (SideIterator sit; sit.ok(); ++sit)
{
int isign = sign(sit());
Vector<FaceIndex> faces =
a_ebisBox.getFaces(vof, idir, sit());
for (int iface = 0; iface < faces.size(); iface++)
{
const FaceIndex& face = faces[iface];
Real areaFrac = a_ebisBox.areaFrac(face);
Real faceFlux =fluxDir(face, 0);
update += isign*areaFrac*faceFlux;
}
}
}
//add EB boundary condtions in divergence
const IntVect& iv = vof.gridIndex();
Real bndryArea = a_ebisBox.bndryArea(vof);
RealVect bndryCent = a_ebisBox.bndryCentroid(vof);
RealVect normal = a_ebisBox.normal(vof);
RealVect bndryLoc;
RealVect exactF;
for (int idir = 0; idir < SpaceDim; idir++)
{
bndryLoc[idir] = a_dx*(iv[idir] + 0.5 + bndryCent[idir]);
}
for (int idir = 0; idir < SpaceDim; idir++)
{
exactF[idir] = exactFlux(bndryLoc, idir);
}
Real bndryFlux = PolyGeom::dot(exactF, normal);
update -= bndryFlux*bndryArea;
update /= a_dx; //note NOT divided by volfrac
a_divF(vof, 0) = update;
}
}
void
EBLevelTransport::
doRegularUpdate(LevelData<EBCellFAB>& a_divF,
LevelData<EBCellFAB>& a_cons,
const LevelData<EBCellFAB>& a_normalVel,
const LevelData<EBFluxFAB>& a_advVel,
const LayoutData< Vector <BaseIVFAB<Real> * > >& a_coveredAdvVelMinu,
const LayoutData< Vector <BaseIVFAB<Real> * > >& a_coveredAdvVelPlus,
EBFluxRegister& a_fineFluxRegister,
EBFluxRegister& a_coarFluxRegister,
const LevelData<EBCellFAB>& a_source,
Real a_time, Real a_dt)
{
bool verbose = false;
int ibox = 0;
Interval consInterv(0, m_nCons-1);
Interval fluxInterv(0, m_nFlux-1);
for (DataIterator dit = m_thisGrids.dataIterator(); dit.ok(); ++dit, ibox++)
{
const Box& cellBox = m_thisGrids.get(dit());
const EBISBox& ebisBox = m_thisEBISL[dit()];
if(!ebisBox.isAllCovered())
{
const IntVectSet& cfivs = m_cfIVS[dit()];
EBCellFAB& consState = a_cons[dit()];
m_ebPatchGodunov->setValidBox(cellBox, ebisBox, cfivs, a_time, a_dt);
//begin debug
//int here = 0;
//if(cellBox.contains(EBPatchGodunov::s_debugIV) && (EBPatchGodunov::s_whichLev==1))
// {
// here = 1;
// }
//end debug
const EBCellFAB& source = a_source[dit()];
const EBCellFAB& normalVel = a_normalVel[dit()];
const EBFluxFAB& advVel = a_advVel[dit()];
const Vector<BaseIVFAB <Real>* >& coveredAdvVelMinu = a_coveredAdvVelMinu[dit()];
const Vector<BaseIVFAB <Real>* >& coveredAdvVelPlus = a_coveredAdvVelPlus[dit()];
m_ebPatchGodunov->setVelocities(normalVel, advVel, coveredAdvVelMinu, coveredAdvVelPlus);
EBFluxFAB flux(ebisBox, cellBox, m_nFlux);
BaseIVFAB<Real>& nonConsDiv = m_nonConsDivergence[dit()];
BaseIVFAB<Real>& ebIrregFlux = m_ebIrregFaceFlux[dit()];
flux.setVal(7.89);
ebIrregFlux.setVal(7.89);
const IntVectSet& ivsIrreg = m_irregSetsSmall[dit()];
const EBCellFAB& flatteningFAB = m_flattening[dit()];
BaseIVFAB<Real> coveredPrimMinu[SpaceDim];
BaseIVFAB<Real> coveredPrimPlus[SpaceDim];
Vector<VolIndex> coveredFaceMinu[SpaceDim];
Vector<VolIndex> coveredFacePlus[SpaceDim];
EBFluxFAB facePrim;
EBCellFAB& divFFAB = a_divF[dit()];
// EBPatchTransport& patchTrans = (EBPatchTransport&) (*m_ebPatchGodunov);
EBPatchGodunov::setCurComp(0);
EBPatchGodunov::setDoingVel(0);
EBPatchGodunov::setDoingAdvVel(0);
m_ebPatchGodunov->primitivesAndDivergences(divFFAB, consState,
facePrim,
coveredPrimMinu,
coveredPrimPlus,
coveredFaceMinu,
coveredFacePlus,
flux, ebIrregFlux,
nonConsDiv,flatteningFAB,
source, cellBox, ivsIrreg,
dit(),verbose);
//do fluxregister cha-cha
/*
Coarse flux register is flux register with the coarse level.
Fine flux register is the flux register with the fine level.
To the finer level FR, this level is the coarse level.
To the coarser level FR, this level is the fine level.
*/
for(int idir = 0; idir < SpaceDim; idir++)
{
Real scale = a_dt;
EBFaceFAB fluxRegFlux;
if(m_hasFiner)
{
a_fineFluxRegister.incrementCoarseRegular(flux[idir], scale,dit(),
consInterv, idir);
}
if(m_hasCoarser)
{
for(SideIterator sit; sit.ok(); ++sit)
{
a_coarFluxRegister.incrementFineRegular(flux[idir],scale, dit(),
consInterv, idir,sit());
}
}
}
//copy fluxes into sparse interpolant
for(int faceDir = 0; faceDir < SpaceDim; faceDir++)
{
IntVectSet ivsIrregGrown = m_irregSetsGrown[faceDir][dit()];
ivsIrregGrown &= cellBox;
FaceStop::WhichFaces stopCrit = FaceStop::SurroundingWithBoundary;
BaseIFFAB<Real>& interpol = m_fluxInterpolants[faceDir][dit()];
interpol.setVal(7.7777e7);
EBFaceFAB& fluxDir = flux[faceDir];
for(FaceIterator faceit(ivsIrregGrown, ebisBox.getEBGraph(),
faceDir, stopCrit);
faceit.ok(); ++faceit)
{
for(int ivar = 0; ivar < m_nFlux; ivar++)
{
interpol(faceit(), ivar) = fluxDir(faceit(), ivar);
}
}
}
}
}
for(int faceDir = 0; faceDir < SpaceDim; faceDir++)
{
m_fluxInterpolants[faceDir].exchange(fluxInterv);
}
}
