void
getError(LevelData<EBCellFAB>& a_error,
const EBISLayout& a_ebisl,
const DisjointBoxLayout& a_dbl,
const Real& a_dx)
{
EBCellFactory ebcellfact(a_ebisl);
EBFluxFactory ebfluxfact(a_ebisl);
a_error.define(a_dbl, 1, IntVect::Zero, ebcellfact);
LevelData<EBCellFAB> divFCalc(a_dbl, 1, IntVect::Zero, ebcellfact);
LevelData<EBCellFAB> divFExac(a_dbl, 1, IntVect::Zero, ebcellfact);
LevelData<EBFluxFAB> faceFlux(a_dbl, 1, IntVect::Zero, ebfluxfact);
for (DataIterator dit = a_dbl.dataIterator(); dit.ok(); ++dit)
{
a_error[dit()].setVal(0.);
divFCalc[dit()].setVal(0.);
divFExac[dit()].setVal(0.);
}
setToExactDivFLD(divFExac, a_ebisl, a_dbl, a_dx);
setToExactFluxLD(faceFlux, a_ebisl, a_dbl, a_dx);
Interval interv(0, 0);
faceFlux.exchange(interv);
kappaDivergenceLD(divFCalc, faceFlux, a_ebisl, a_dbl, a_dx);
for (DataIterator dit = a_dbl.dataIterator(); dit.ok(); ++dit)
{
EBCellFAB& errorFAB = a_error[dit()];
EBCellFAB& exactFAB = divFExac[dit()];
EBCellFAB& calcuFAB = divFCalc[dit()];
errorFAB += calcuFAB;
errorFAB -= exactFAB;
}
}
EBCompositeCCProjector::
EBCompositeCCProjector(const Vector<EBLevelGrid>& a_eblg,
const Vector<int>& a_refRat,
const Vector<RefCountedPtr<EBQuadCFInterp> >& a_quadCFI,
const RealVect& a_coarsestDx,
const RealVect& a_origin,
const RefCountedPtr<BaseDomainBCFactory>& a_baseDomainBCVel,
const RefCountedPtr<BaseDomainBCFactory>& a_baseDomainBCPhi,
const RefCountedPtr<BaseEBBCFactory>& a_ebbcPhi,
const bool& a_subtractOffMean,
const int& a_numLevels,
const int& a_verbosity,
const int& a_numPreCondIters,
const Real& a_time,
const int& a_relaxType,
const int& a_bottomSolverType,
EBCompositeMACProjector* a_inputMAC)
{
CH_TIME("EBCompositeCCProjector::EBCompositeCCProjector");
if (a_numLevels < 0)
{
m_numLevels = a_eblg.size();
}
else
{
CH_assert(a_numLevels <= a_eblg.size());
m_numLevels = a_numLevels;
}
CH_assert(a_refRat.size() >= m_numLevels);
m_eblg = a_eblg;
m_quadCFI = a_quadCFI;
m_refRat = a_refRat;
m_pwlCFI.resize(m_numLevels);
int nvarquad = 1;
int radius =1;
for (int ilev = 1; ilev < m_numLevels; ilev++)
{
m_pwlCFI[ilev] = RefCountedPtr<EBPWLFillPatch>(new EBPWLFillPatch(m_eblg[ilev].getDBL(),
m_eblg[ilev-1].getDBL(),
m_eblg[ilev].getEBISL(),
m_eblg[ilev-1].getEBISL(),
m_eblg[ilev-1].getDomain(),
m_refRat[ilev-1],
nvarquad,
radius,
m_eblg[ilev].getEBISL().getEBIS()));
}
m_dx.resize(m_numLevels);
m_dx[0] = a_coarsestDx;
for (int ilev = 1; ilev < m_numLevels; ilev++)
{
m_dx[ilev] = m_dx[ilev-1]/m_refRat[ilev-1];
}
if (a_inputMAC != NULL)
{
m_macProjector = a_inputMAC;
m_externMAC = true;
}
else
{
m_externMAC = false;
m_macProjector = new EBCompositeMACProjector(a_eblg, a_refRat, a_quadCFI,
a_coarsestDx, a_origin,
a_baseDomainBCVel,
a_baseDomainBCPhi,
a_ebbcPhi,
a_subtractOffMean,
a_numLevels,
a_verbosity,
a_numPreCondIters,
a_time,
a_relaxType,
a_bottomSolverType);
//default values
int numSmooth = 4;
int itermax = 77;
int mgCycle = 1;
Real hang = 1.0e-20;
Real tolerance = 1.0e-12;
Real normThresh= 1.0e-12;
setSolverParams(numSmooth, itermax, mgCycle, hang, tolerance, a_verbosity,normThresh);
}
m_macVelo.resize(m_numLevels, NULL);
m_macGrad.resize(m_numLevels, NULL);
for (int ilev = 0; ilev < m_numLevels; ilev++)
{
EBFluxFactory ebfluxfact(m_eblg[ilev].getEBISL());
m_macVelo[ilev] = new LevelData<EBFluxFAB>(m_eblg[ilev].getDBL(), 1, IntVect::Unit, ebfluxfact);
m_macGrad[ilev] = new LevelData<EBFluxFAB>(m_eblg[ilev].getDBL(), 1, 2*IntVect::Unit, ebfluxfact);
}
}
EBGradDivFilter::
EBGradDivFilter(const DisjointBoxLayout& a_gridsFine,
const DisjointBoxLayout* a_gridsCoarPtr,
const EBISLayout& a_ebislFine,
const EBISLayout* a_ebislCoarPtr,
const ProblemDomain& a_domainFine,
const RealVect& a_dxFine,
const int& a_refRat,
const Real& a_lambdaScale,
const EBIndexSpace* const a_ebisPtr)
{
CH_TIME("EBGradDivFilter::EBGradDivFilter");
m_gridsFine = a_gridsFine ;
m_gridsCoarPtr= a_gridsCoarPtr ;
m_ebislFine = a_ebislFine ;
m_eblgFine.define(m_gridsFine, m_ebislFine, m_domainFine);
m_ebislCoarPtr= a_ebislCoarPtr ;
m_domainFine = a_domainFine ;
m_refRat = a_refRat ;
m_dxFine = a_dxFine;
m_hasCoarser = (m_gridsCoarPtr != NULL);
EBCellFactory ebcellfact(m_ebislFine);
EBFluxFactory ebfluxfact(m_ebislFine);
m_gradVel.define(m_gridsFine, SpaceDim*SpaceDim, IntVect::Unit, ebcellfact);
m_lambda.define( m_gridsFine, 1, IntVect::Zero, ebcellfact);
m_faceDivCell.define(m_gridsFine, 1,4*IntVect::Unit, ebfluxfact);
m_dropOrder.define( m_gridsFine);
m_johanStencil.define(m_gridsFine);
m_distanceAlongLine.define(m_gridsFine);
for (DataIterator dit = m_gridsFine.dataIterator(); dit.ok(); ++dit)
{
BaseIVFAB<VoFStencil>& curJohanStencil = m_johanStencil[dit()];
BaseIVFAB<char>& curDropOrder = m_dropOrder[dit()];
BaseIVFAB<Real>& curDistanceAlongLine = m_distanceAlongLine[dit()];
EBGraph ebgraph = m_ebislFine[dit()].getEBGraph();
IntVectSet ivsIrreg = m_ebislFine[dit()].getIrregIVS(m_gridsFine.get(dit()));
curJohanStencil.define( ivsIrreg,ebgraph, 2);
curDistanceAlongLine.define(ivsIrreg,ebgraph, 2);
curDropOrder.define( ivsIrreg,ebgraph, 1);
for (VoFIterator vofit(ivsIrreg, ebgraph); vofit.ok(); ++vofit)
{
Vector<VoFStencil> pointStencils;
Vector<Real> distanceAlongLine;
bool dropOrder = false;
EBArith::johanStencil(dropOrder,
pointStencils,
distanceAlongLine,
vofit(), m_ebislFine[dit()], m_dxFine,
(*m_eblgFine.getCFIVS())[dit()]);
curDropOrder(vofit(), 0) = dropOrder;
if (!dropOrder)
{
for (int ipoint = 0; ipoint < 2; ipoint++)
{
curJohanStencil(vofit(), ipoint) = pointStencils[ipoint];
curDistanceAlongLine(vofit(), ipoint) = distanceAlongLine[ipoint];
}
}
}
}
m_tensorCFI = NULL;
if (m_hasCoarser)
{
Real dx = a_dxFine[0];
m_domainCoar = coarsen(m_domainFine, m_refRat);
m_tensorCFI= new EBTensorCFInterp(m_gridsFine, *m_gridsCoarPtr,
m_ebislFine, *m_ebislCoarPtr,
m_domainCoar, m_refRat, SpaceDim, dx,
*m_eblgFine.getCFIVS(), a_ebisPtr);
}
m_lambdaScale = a_lambdaScale;
fillLambda();
}
