void
MCMultiGrid::relax (MultiFab& solL,
MultiFab& rhsL,
int level,
Real eps_rel,
Real eps_abs,
MCBC_Mode bc_mode)
{
//
// Recursively relax system. Equivalent to multigrid V-cycle.
// At coarsest grid, call coarsestSmooth.
//
if (level < numlevels - 1 ) {
for (int i = preSmooth() ; i > 0 ; i--) {
Lp.smooth(solL, rhsL, level, bc_mode);
}
Lp.residual(*res[level], rhsL, solL, level, bc_mode);
prepareForLevel(level+1);
average(*rhs[level+1], *res[level]);
cor[level+1]->setVal(0.0);
for (int i = cntRelax(); i > 0 ; i--) {
relax(*cor[level+1],*rhs[level+1],level+1,eps_rel,eps_abs,bc_mode);
}
interpolate(solL, *cor[level+1]);
for (int i = postSmooth(); i > 0 ; i--) {
Lp.smooth(solL, rhsL, level, bc_mode);
}
} else {
coarsestSmooth(solL, rhsL, level, eps_rel, eps_abs, bc_mode);
}
}
void
MultiGrid::solve (MultiFab& _sol,
const MultiFab& _rhs,
Real _eps_rel,
Real _eps_abs,
LinOp::BC_Mode bc_mode)
{
//
// Prepare memory for new level, and solve the general boundary
// value problem to within relative error _eps_rel. Customized
// to solve at level=0.
//
const int level = 0;
prepareForLevel(level);
//
// Copy the initial guess, which may contain inhomogeneous boundray conditions,
// into both "initialsolution" (to be added back later) and into "cor[0]" which
// we will only use here to compute the residual, then will set back to 0 below
//
initialsolution->copy(_sol);
cor[level]->copy(_sol);
//
// Put the problem in residual-correction form: we will now use "rhs[level
// the initial residual (rhs[0]) rather than the initial RHS (_rhs)
// to begin the solve.
//
Lp.residual(*rhs[level],_rhs,*cor[level],level,bc_mode);
//
// Now initialize correction to zero at this level (auto-filled at levels below)
//
(*cor[level]).setVal(0.0); //
//
// Elide a reduction by doing these together.
//
Real tmp[2] = { norm_inf(_rhs,true), norm_inf(*rhs[level],true) };
ParallelDescriptor::ReduceRealMax(tmp,2);
if ( ParallelDescriptor::IOProcessor() && verbose > 0)
{
Spacer(std::cout, level);
std::cout << "MultiGrid: Initial rhs = " << tmp[0] << '\n';
std::cout << "MultiGrid: Initial residual = " << tmp[1] << '\n';
}
if (tmp[1] == 0.0)
return;
//
// We can now use homogeneous bc's because we have put the problem into residual-correction form.
//
if ( !solve_(_sol, _eps_rel, _eps_abs, LinOp::Homogeneous_BC, tmp[0], tmp[1]) )
BoxLib::Error("MultiGrid:: failed to converge!");
}
void
MCMultiGrid::solve (MultiFab& _sol,
const MultiFab& _rhs,
Real _eps_rel,
Real _eps_abs,
MCBC_Mode bc_mode)
{
BL_ASSERT(numcomps == _sol.nComp());
//
// Prepare memory for new level, and solve the general boundary
// value problem to within relative error _eps_rel. Customized
// to solve at level=0
//
int level = 0;
prepareForLevel(level);
residualCorrectionForm(*rhs[level],_rhs,*cor[level],_sol,bc_mode,level);
if (!solve_(_sol, _eps_rel, _eps_abs, MCHomogeneous_BC, level))
BoxLib::Error("MCMultiGrid::solve(): failed to converge!");
}
void
MCMultiGrid::coarsestSmooth (MultiFab& solL,
MultiFab& rhsL,
int level,
Real eps_rel,
Real eps_abs,
MCBC_Mode bc_mode)
{
prepareForLevel(level);
if (usecg == 0)
{
for (int i = finalSmooth(); i > 0; i--)
Lp.smooth(solL, rhsL, level, bc_mode);
}
else
{
bool use_mg_precond = false;
MCCGSolver cg(Lp, use_mg_precond, level);
cg.solve(solL, rhsL, rtol_b, atol_b, bc_mode);
for(int i=0; i<nu_b; i++)
Lp.smooth(solL, rhsL, level, bc_mode);
}
}
void
MultiGrid::coarsestSmooth (MultiFab& solL,
MultiFab& rhsL,
int level,
Real eps_rel,
Real eps_abs,
LinOp::BC_Mode bc_mode,
int local_usecg,
Real& cg_time)
{
BL_PROFILE("MultiGrid::coarsestSmooth()");
prepareForLevel(level);
if ( local_usecg == 0 )
{
Real error0 = 0;
if ( verbose > 0 )
{
error0 = errorEstimate(level, bc_mode);
if ( ParallelDescriptor::IOProcessor() )
std::cout << " Bottom Smoother: Initial error (error0) = "
<< error0 << '\n';
}
for (int i = finalSmooth(); i > 0; i--)
{
Lp.smooth(solL, rhsL, level, bc_mode);
if ( verbose > 1 || (i == 1 && verbose) )
{
Real error = errorEstimate(level, bc_mode);
const Real rel_error = (error0 != 0) ? error/error0 : 0;
if ( ParallelDescriptor::IOProcessor() )
std::cout << " Bottom Smoother: Iteration "
<< i
<< " error/error0 = "
<< rel_error << '\n';
}
}
}
else
{
bool use_mg_precond = false;
CGSolver cg(Lp, use_mg_precond, level);
cg.setMaxIter(maxiter_b);
const Real stime = ParallelDescriptor::second();
int ret = cg.solve(solL, rhsL, rtol_b, atol_b, bc_mode);
//
// The whole purpose of cg_time is to accumulate time spent in CGSolver.
//
cg_time += (ParallelDescriptor::second() - stime);
if ( ret != 0 )
{
if ( smooth_on_cg_unstable )
{
//
// If the CG solver returns a nonzero value indicating
// the problem is unstable. Assume this is not an accuracy
// issue and pound on it with the smoother.
// if ret == 8, then you have failure to converge
//
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
std::cout << "MultiGrid::coarsestSmooth(): CGSolver returns nonzero. Smoothing ...\n";
coarsestSmooth(solL, rhsL, level, eps_rel, eps_abs, bc_mode, 0, cg_time);
}
else
{
//
// cg failure probably indicates loss of precision accident.
// if ret == 8, then you have failure to converge
// setting solL to 0 should be ok.
//
solL.setVal(0);
if ( ParallelDescriptor::IOProcessor() && (verbose > 0) )
{
std::cout << "MultiGrid::coarsestSmooth(): setting coarse corr to zero" << '\n';
}
}
}
for (int i = 0; i < nu_b; i++)
{
Lp.smooth(solL, rhsL, level, bc_mode);
}
}
}
void
MultiGrid::relax (MultiFab& solL,
MultiFab& rhsL,
int level,
Real eps_rel,
Real eps_abs,
LinOp::BC_Mode bc_mode,
Real& cg_time)
{
BL_PROFILE("MultiGrid::relax()");
//
// Recursively relax system. Equivalent to multigrid V-cycle.
// At coarsest grid, call coarsestSmooth.
//
if ( level < numlevels - 1 )
{
if ( verbose > 2 )
{
Real rnorm = errorEstimate(level, bc_mode);
if (ParallelDescriptor::IOProcessor())
{
std::cout << " AT LEVEL " << level << '\n';
std::cout << " DN:Norm before smooth " << rnorm << '\n';;
}
}
for (int i = preSmooth() ; i > 0 ; i--)
{
Lp.smooth(solL, rhsL, level, bc_mode);
}
Lp.residual(*res[level], rhsL, solL, level, bc_mode);
if ( verbose > 2 )
{
Real rnorm = norm_inf(*res[level]);
if (ParallelDescriptor::IOProcessor())
std::cout << " DN:Norm after smooth " << rnorm << '\n';
}
prepareForLevel(level+1);
average(*rhs[level+1], *res[level]);
cor[level+1]->setVal(0.0);
for (int i = cntRelax(); i > 0 ; i--)
{
relax(*cor[level+1],*rhs[level+1],level+1,eps_rel,eps_abs,bc_mode,cg_time);
}
interpolate(solL, *cor[level+1]);
if ( verbose > 2 )
{
Lp.residual(*res[level], rhsL, solL, level, bc_mode);
Real rnorm = norm_inf(*res[level]);
if ( ParallelDescriptor::IOProcessor() )
{
std::cout << " AT LEVEL " << level << '\n';
std::cout << " UP:Norm before smooth " << rnorm << '\n';
}
}
for (int i = postSmooth(); i > 0 ; i--)
{
Lp.smooth(solL, rhsL, level, bc_mode);
}
if ( verbose > 2 )
{
Lp.residual(*res[level], rhsL, solL, level, bc_mode);
Real rnorm = norm_inf(*res[level]);
if ( ParallelDescriptor::IOProcessor() )
std::cout << " UP:Norm after smooth " << rnorm << '\n';
}
}
else
{
if ( verbose > 2 )
{
Real rnorm = norm_inf(rhsL);
if ( ParallelDescriptor::IOProcessor() )
{
std::cout << " AT LEVEL " << level << '\n';
std::cout << " DN:Norm before bottom " << rnorm << '\n';
}
}
coarsestSmooth(solL, rhsL, level, eps_rel, eps_abs, bc_mode, usecg, cg_time);
if ( verbose > 2 )
{
Lp.residual(*res[level], rhsL, solL, level, bc_mode);
Real rnorm = norm_inf(*res[level]);
if ( ParallelDescriptor::IOProcessor() )
std::cout << " UP:Norm after bottom " << rnorm << '\n';
}
}
}
void
MCLinOp::applyBC (MultiFab& inout,
int level,
MCBC_Mode bc_mode)
{
//
// The inout MultiFab must have at least MCLinOp_grow ghost cells
// for applyBC()
//
BL_ASSERT(inout.nGrow() >= MCLinOp_grow);
//
// The inout MultiFab must have at least Periodic_BC_grow cells for the
// algorithms taking care of periodic boundary conditions.
//
BL_ASSERT(inout.nGrow() >= MCLinOp_grow);
//
// No coarsened boundary values, cannot apply inhomog at lev>0.
//
BL_ASSERT(!(level>0 && bc_mode == MCInhomogeneous_BC));
int flagden = 1; // fill in the bndry data and undrrelxr
int flagbc = 1; // with values
if (bc_mode == MCHomogeneous_BC)
flagbc = 0; // nodata if homog
int nc = inout.nComp();
BL_ASSERT(nc == numcomp );
inout.setBndry(-1.e30);
inout.FillBoundary();
prepareForLevel(level);
geomarray[level].FillPeriodicBoundary(inout,0,nc);
//
// Fill boundary cells.
//
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(inout); mfi.isValid(); ++mfi)
{
const int gn = mfi.index();
BL_ASSERT(gbox[level][gn] == inout.box(gn));
const BndryData::RealTuple& bdl = bgb.bndryLocs(gn);
const Array< Array<BoundCond> >& bdc = bgb.bndryConds(gn);
const MaskTuple& msk = maskvals[level][gn];
for (OrientationIter oitr; oitr; ++oitr)
{
const Orientation face = oitr();
FabSet& f = (*undrrelxr[level])[face];
FabSet& td = (*tangderiv[level])[face];
int cdr(face);
const FabSet& fs = bgb.bndryValues(face);
Real bcl = bdl[face];
const Array<BoundCond>& bc = bdc[face];
const int *bct = (const int*) bc.dataPtr();
const FArrayBox& fsfab = fs[gn];
const Real* bcvalptr = fsfab.dataPtr();
//
// Way external derivs stored.
//
const Real* exttdptr = fsfab.dataPtr(numcomp);
const int* fslo = fsfab.loVect();
const int* fshi = fsfab.hiVect();
FArrayBox& inoutfab = inout[gn];
FArrayBox& denfab = f[gn];
FArrayBox& tdfab = td[gn];
#if BL_SPACEDIM==2
int cdir = face.coordDir(), perpdir = -1;
if (cdir == 0)
perpdir = 1;
else if (cdir == 1)
perpdir = 0;
else
BoxLib::Abort("MCLinOp::applyBC(): bad logic");
const Mask& m = *msk[face];
const Mask& mphi = *msk[Orientation(perpdir,Orientation::high)];
const Mask& mplo = *msk[Orientation(perpdir,Orientation::low)];
FORT_APPLYBC(
&flagden, &flagbc, &maxorder,
inoutfab.dataPtr(),
ARLIM(inoutfab.loVect()), ARLIM(inoutfab.hiVect()),
&cdr, bct, &bcl,
bcvalptr, ARLIM(fslo), ARLIM(fshi),
m.dataPtr(), ARLIM(m.loVect()), ARLIM(m.hiVect()),
mphi.dataPtr(), ARLIM(mphi.loVect()), ARLIM(mphi.hiVect()),
mplo.dataPtr(), ARLIM(mplo.loVect()), ARLIM(mplo.hiVect()),
denfab.dataPtr(),
ARLIM(denfab.loVect()), ARLIM(denfab.hiVect()),
exttdptr, ARLIM(fslo), ARLIM(fshi),
tdfab.dataPtr(),ARLIM(tdfab.loVect()),ARLIM(tdfab.hiVect()),
inout.box(gn).loVect(), inout.box(gn).hiVect(),
&nc, h[level]);
#elif BL_SPACEDIM==3
const Mask& mn = *msk[Orientation(1,Orientation::high)];
const Mask& me = *msk[Orientation(0,Orientation::high)];
const Mask& mw = *msk[Orientation(0,Orientation::low)];
const Mask& ms = *msk[Orientation(1,Orientation::low)];
const Mask& mt = *msk[Orientation(2,Orientation::high)];
const Mask& mb = *msk[Orientation(2,Orientation::low)];
FORT_APPLYBC(
&flagden, &flagbc, &maxorder,
inoutfab.dataPtr(),
ARLIM(inoutfab.loVect()), ARLIM(inoutfab.hiVect()),
&cdr, bct, &bcl,
bcvalptr, ARLIM(fslo), ARLIM(fshi),
mn.dataPtr(),ARLIM(mn.loVect()),ARLIM(mn.hiVect()),
me.dataPtr(),ARLIM(me.loVect()),ARLIM(me.hiVect()),
mw.dataPtr(),ARLIM(mw.loVect()),ARLIM(mw.hiVect()),
ms.dataPtr(),ARLIM(ms.loVect()),ARLIM(ms.hiVect()),
mt.dataPtr(),ARLIM(mt.loVect()),ARLIM(mt.hiVect()),
mb.dataPtr(),ARLIM(mb.loVect()),ARLIM(mb.hiVect()),
denfab.dataPtr(),
ARLIM(denfab.loVect()), ARLIM(denfab.hiVect()),
exttdptr, ARLIM(fslo), ARLIM(fshi),
tdfab.dataPtr(),ARLIM(tdfab.loVect()),ARLIM(tdfab.hiVect()),
inout.box(gn).loVect(), inout.box(gn).hiVect(),
&nc, h[level]);
#endif
}
}
#if 0
// This "probably" works, but is not strictly needed just because of the way Bill
// coded up the tangential derivative stuff. It's handy code though, so I want to
// keep it around/
// Clean up corners:
// The problem here is that APPLYBC fills only grow cells normal to the boundary.
// As a result, any corner cell on the boundary (either coarse-fine or fine-fine)
// is not filled. For coarse-fine, the operator adjusts itself, sliding away from
// the box edge to avoid referencing that corner point. On the physical boundary
// though, the corner point is needed. Particularly if a fine-fine boundary intersects
// the physical boundary, since we want the stencil to be independent of the box
// blocking. FillBoundary operations wont fix the problem because the "good"
// data we need is living in the grow region of adjacent fabs. So, here we play
// the usual games to treat the newly filled grow cells as "valid" data.
// Note that we only need to do something where the grids touch the physical boundary.
const Geometry& geomlev = geomarray[level];
const BoxArray& grids = inout.boxArray();
const Box& domain = geomlev.Domain();
int nGrow = 1;
int src_comp = 0;
int num_comp = BL_SPACEDIM;
// Lets do a quick check to see if we need to do anything at all here
BoxArray BIGba = BoxArray(grids).grow(nGrow);
if (! (domain.contains(BIGba.minimalBox())) ) {
BoxArray boundary_pieces;
Array<int> proc_idxs;
Array<Array<int> > old_to_new(grids.size());
const DistributionMapping& dmap=inout.DistributionMap();
for (int d=0; d<BL_SPACEDIM; ++d) {
if (! (geomlev.isPeriodic(d)) ) {
BoxArray gba = BoxArray(grids).grow(d,nGrow);
for (int i=0; i<gba.size(); ++i) {
BoxArray new_pieces = BoxLib::boxComplement(gba[i],domain);
int size_new = new_pieces.size();
if (size_new>0) {
int size_old = boundary_pieces.size();
boundary_pieces.resize(size_old+size_new);
proc_idxs.resize(boundary_pieces.size());
for (int j=0; j<size_new; ++j) {
boundary_pieces.set(size_old+j,new_pieces[j]);
proc_idxs[size_old+j] = dmap[i];
old_to_new[i].push_back(size_old+j);
}
}
}
}
}
proc_idxs.push_back(ParallelDescriptor::MyProc());
MultiFab boundary_data(boundary_pieces,num_comp,nGrow,
DistributionMapping(proc_idxs));
for (MFIter mfi(inout); mfi.isValid(); ++mfi) {
const FArrayBox& src_fab = inout[mfi];
for (int j=0; j<old_to_new[mfi.index()].size(); ++j) {
int new_box_idx = old_to_new[mfi.index()][j];
boundary_data[new_box_idx].copy(src_fab,src_comp,0,num_comp);
}
}
boundary_data.FillBoundary();
// Use a hacked Geometry object to handle the periodic intersections for us.
// Here, the "domain" is the plane of cells on non-periodic boundary faces.
// and there may be cells over the periodic boundary in the remaining directions.
// We do a Geometry::PFB on each non-periodic face to sync these up.
if (geomlev.isAnyPeriodic()) {
Array<int> is_per(BL_SPACEDIM,0);
for (int d=0; d<BL_SPACEDIM; ++d) {
is_per[d] = geomlev.isPeriodic(d);
}
for (int d=0; d<BL_SPACEDIM; ++d) {
if (! is_per[d]) {
Box tmpLo = BoxLib::adjCellLo(geomlev.Domain(),d,1);
Geometry tmpGeomLo(tmpLo,&(geomlev.ProbDomain()),(int)geomlev.Coord(),is_per.dataPtr());
tmpGeomLo.FillPeriodicBoundary(boundary_data);
Box tmpHi = BoxLib::adjCellHi(geomlev.Domain(),d,1);
Geometry tmpGeomHi(tmpHi,&(geomlev.ProbDomain()),(int)geomlev.Coord(),is_per.dataPtr());
tmpGeomHi.FillPeriodicBoundary(boundary_data);
}
}
}
for (MFIter mfi(inout); mfi.isValid(); ++mfi) {
int idx = mfi.index();
FArrayBox& dst_fab = inout[mfi];
for (int j=0; j<old_to_new[idx].size(); ++j) {
int new_box_idx = old_to_new[mfi.index()][j];
const FArrayBox& src_fab = boundary_data[new_box_idx];
const Box& src_box = src_fab.box();
BoxArray pieces_outside_domain = BoxLib::boxComplement(src_box,domain);
for (int k=0; k<pieces_outside_domain.size(); ++k) {
const Box& outside = pieces_outside_domain[k] & dst_fab.box();
if (outside.ok()) {
dst_fab.copy(src_fab,outside,0,outside,src_comp,num_comp);
}
}
}
}
}
#endif
}
void
LinOp::applyBC (MultiFab& inout,
int src_comp,
int num_comp,
int level,
LinOp::BC_Mode bc_mode,
bool local,
int bndry_comp)
{
BL_PROFILE("LinOp::applyBC()");
//
// The inout MultiFab needs at least LinOp_grow ghost cells for applyBC.
//
BL_ASSERT(inout.nGrow() >= LinOp_grow);
//
// No coarsened boundary values, cannot apply inhomog at lev>0.
//
BL_ASSERT(level < numLevels());
BL_ASSERT(!(level > 0 && bc_mode == Inhomogeneous_BC));
int flagden = 1; // Fill in undrrelxr.
int flagbc = 1; // Fill boundary data.
if (bc_mode == LinOp::Homogeneous_BC)
//
// No data if homogeneous.
//
flagbc = 0;
const bool cross = true;
inout.FillBoundary(src_comp,num_comp,local,cross);
prepareForLevel(level);
//
// Do periodic fixup.
//
BL_ASSERT(level<geomarray.size());
geomarray[level].FillPeriodicBoundary(inout,src_comp,num_comp,false,local);
//
// Fill boundary cells.
//
// OMP over boxes
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(inout); mfi.isValid(); ++mfi)
{
const int gn = mfi.index();
BL_ASSERT(gbox[level][gn] == inout.box(gn));
BL_ASSERT(level<maskvals.size() && maskvals[level].local_index(gn)>=0);
BL_ASSERT(level<lmaskvals.size() && lmaskvals[level].local_index(gn)>=0);
BL_ASSERT(level<undrrelxr.size());
const MaskTuple& ma = maskvals[level][gn];
const MaskTuple& lma = lmaskvals[level][gn];
const BndryData::RealTuple& bdl = bgb->bndryLocs(gn);
const Array< Array<BoundCond> >& bdc = bgb->bndryConds(gn);
for (OrientationIter oitr; oitr; ++oitr)
{
const Orientation o = oitr();
FabSet& f = (*undrrelxr[level])[o];
int cdr = o;
const FabSet& fs = bgb->bndryValues(o);
const Mask& m = local ? (*lma[o]) : (*ma[o]);
Real bcl = bdl[o];
BL_ASSERT(bdc[o].size()>bndry_comp);
int bct = bdc[o][bndry_comp];
const Box& vbx = inout.box(gn);
FArrayBox& iofab = inout[mfi];
BL_ASSERT(f.size()>gn);
BL_ASSERT(fs.size()>gn);
FArrayBox& ffab = f[mfi];
const FArrayBox& fsfab = fs[mfi];
FORT_APPLYBC(&flagden, &flagbc, &maxorder,
iofab.dataPtr(src_comp),
ARLIM(iofab.loVect()), ARLIM(iofab.hiVect()),
&cdr, &bct, &bcl,
fsfab.dataPtr(bndry_comp),
ARLIM(fsfab.loVect()), ARLIM(fsfab.hiVect()),
m.dataPtr(),
ARLIM(m.loVect()), ARLIM(m.hiVect()),
ffab.dataPtr(),
ARLIM(ffab.loVect()), ARLIM(ffab.hiVect()),
vbx.loVect(),
vbx.hiVect(), &num_comp, h[level]);
}
}
}
void
ABec4::applyBC (MultiFab& inout,
int src_comp,
int num_comp,
int level,
LinOp::BC_Mode bc_mode,
bool local,
int bndry_comp)
{
//
// The inout MultiFab needs enough ghost cells for applyBC.
//
BL_ASSERT(inout.nGrow() >= NumGrow(level));
//
// No coarsened boundary values, cannot apply inhomog at lev>0.
//
BL_ASSERT(level < numLevelsHO());
BL_ASSERT(!(level > 0 && bc_mode == Inhomogeneous_BC));
int flagden = 1; // Fill in undrrelxr.
int flagbc = 1; // Fill boundary data.
if (bc_mode == LinOp::Homogeneous_BC)
//
// No data if homogeneous.
//
flagbc = 0;
prepareForLevel(level);
const bool cross = false;
inout.FillBoundary(src_comp,num_comp,geomarray[level].periodicity(),cross);
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(inout); mfi.isValid(); ++mfi)
{
const int gn = mfi.index();
BL_ASSERT(gbox[level][gn] == inout.box(gn));
BL_ASSERT(level<undrrelxr.size());
const BndryData::RealTuple& bdl = bgb->bndryLocs(gn);
const Array< Array<BoundCond> >& bdc = bgb->bndryConds(gn);
for (OrientationIter oitr; oitr; ++oitr)
{
const Orientation o = oitr();
FabSet& f = (*undrrelxr[level])[o];
int cdr = o;
const FabSet& fs = bgb->bndryValues(o);
const Mask& m = local ? lmaskvals[level][o][mfi] : maskvals[level][o][mfi];
Real bcl = bdl[o];
BL_ASSERT(bdc[o].size()>bndry_comp);
int bct = bdc[o][bndry_comp];
const Box& vbx = inout.box(gn);
FArrayBox& iofab = inout[gn];
BL_ASSERT(f.size()>gn);
BL_ASSERT(fs.size()>gn);
FArrayBox& ffab = f[gn];
const FArrayBox& fsfab = fs[gn];
FORT_APPLYBC4(&flagden, &flagbc, &maxorder,
iofab.dataPtr(src_comp),
ARLIM(iofab.loVect()), ARLIM(iofab.hiVect()),
&cdr, &bct, &bcl,
fsfab.dataPtr(bndry_comp),
ARLIM(fsfab.loVect()), ARLIM(fsfab.hiVect()),
m.dataPtr(),
ARLIM(m.loVect()), ARLIM(m.hiVect()),
ffab.dataPtr(),
ARLIM(ffab.loVect()), ARLIM(ffab.hiVect()),
vbx.loVect(),
vbx.hiVect(), &num_comp, h[level]);
}
}
// Clean up corners:
// The problem here is that APPLYBC fills only grow cells normal to the boundary.
// As a result, any corner cell on the boundary (either coarse-fine or fine-fine)
// is not filled. For coarse-fine, the operator adjusts itself, sliding away from
// the box edge to avoid referencing that corner point. On the physical boundary
// though, the corner point is needed. Particularly if a fine-fine boundary intersects
// the physical boundary, since we want the stencil to be independent of the box
// blocking.
inout.EnforcePeriodicity(geomarray[level].periodicity());
#ifdef _OPENMP
#pragma omp parallel
#endif
for (MFIter mfi(inout); mfi.isValid(); ++mfi) {
const int gn = mfi.index();
BL_ASSERT(gbox[level][gn] == inout.box(gn));
const Box& vbx = inout.box(gn);
FArrayBox& iofab = inout[gn];
FORT_APPLYBC4_TOUCHUP(
iofab.dataPtr(src_comp),ARLIM(iofab.loVect()), ARLIM(iofab.hiVect()),
vbx.loVect(), vbx.hiVect(), &num_comp);
}
}
const MultiFab&
ABec4::bCoefficients (int level)
{
prepareForLevel(level);
return *bcoefs[level];
}
