ERFFillPatcher Class Reference

#include <ERF_FillPatcher.H>

Collaboration diagram for ERFFillPatcher:

Public Member Functions
	ERFFillPatcher (amrex::BoxArray const &fba, amrex::DistributionMapping const &fdm, amrex::Geometry const &fgeom, amrex::BoxArray const &cba, amrex::DistributionMapping const &cdm, amrex::Geometry const &cgeom, int nghost, int nghost_set, int ncomp, amrex::InterpBase *interp)
void	Define (amrex::BoxArray const &fba, amrex::DistributionMapping const &fdm, amrex::Geometry const &fgeom, amrex::BoxArray const &cba, amrex::DistributionMapping const &cdm, amrex::Geometry const &cgeom, int nghost, int nghost_set, int ncomp, amrex::InterpBase *interp)
void	BuildMask (amrex::BoxArray const &fba, int nghost, int nghost_set)
void	RegisterCoarseData (amrex::Vector< amrex::MultiFab const * > const &crse_data, amrex::Vector< amrex::Real > const &crse_time)
void	InterpFace (amrex::MultiFab &fine, amrex::MultiFab const &crse, int mask_val)
void	InterpCell (amrex::MultiFab &fine, amrex::MultiFab const &crse, amrex::Vector< amrex::BCRec > const &bcr, int mask_val)
int	GetSetMaskVal ()
int	GetRelaxMaskVal ()
amrex::iMultiFab *	GetMask ()
template<typename BC >
void	FillSet (amrex::MultiFab &mf, amrex::Real time, BC &cbc, amrex::Vector< amrex::BCRec > const &bcs)
template<typename BC >
void	FillRelax (amrex::MultiFab &mf, amrex::Real time, BC &cbc, amrex::Vector< amrex::BCRec > const &bcs)
template<typename BC >
void	Fill (amrex::MultiFab &mf, amrex::Real time, BC &cbc, amrex::Vector< amrex::BCRec > const &bcs, int mask_val)

Private Attributes
amrex::BoxArray	m_fba
amrex::BoxArray	m_cba
amrex::DistributionMapping	m_fdm
amrex::DistributionMapping	m_cdm
amrex::Geometry	m_fgeom
amrex::Geometry	m_cgeom
int	m_nghost
int	m_nghost_subset
int	m_ncomp
amrex::InterpBase *	m_interp
amrex::IntVect	m_ratio
std::unique_ptr< amrex::MultiFab >	m_cf_crse_data_old
std::unique_ptr< amrex::MultiFab >	m_cf_crse_data_new
std::unique_ptr< amrex::iMultiFab >	m_cf_mask
amrex::Vector< amrex::Real >	m_crse_times
amrex::Real	m_dt_crse
int	m_set_mask {2}
int	m_relax_mask {1}

Constructor & Destructor Documentation

ERFFillPatcher()

ERFFillPatcher::ERFFillPatcher	(	amrex::BoxArray const &	fba,
		amrex::DistributionMapping const &	fdm,
		amrex::Geometry const &	fgeom,
		amrex::BoxArray const &	cba,
		amrex::DistributionMapping const &	cdm,
		amrex::Geometry const &	cgeom,
		int	nghost,
		int	nghost_set,
		int	ncomp,
		amrex::InterpBase *	interp
	)

    : m_fba(fba),
      m_cba(cba),
      m_fdm(fdm),
      m_cdm(cdm),
      m_fgeom(fgeom),
      m_cgeom(cgeom)
{
    AMREX_ALWAYS_ASSERT(fba.ixType() == cba.ixType());
 
    // Vector to hold times for coarse data
    m_crse_times.resize(2);
 
    // Define the coarse and fine MFs
    Define(fba, fdm, fgeom, cba, cdm, cgeom,nghost, nghost_set, ncomp, interp);
}

Here is the call graph for this function:

Member Function Documentation

BuildMask()

void ERFFillPatcher::BuildMask	(	amrex::BoxArray const &	fba,
		int	nghost,
		int	nghost_set
	)

{
    // Minimal bounding box of fine BA plus a halo cell
    Box fba_bnd = grow(fba.minimalBox(), IntVect(1,1,1));
 
    BoxArray fba_per;
    Box fdomain = m_fgeom.Domain();
    // Here we add additional boxes that are periodic wraparounds of existing boxes
    if (m_fgeom.isAnyPeriodic())
    {
        Box domain_cc(fdomain); domain_cc.enclosedCells();
        BoxList bl_mf = fba.boxList();
        BoxList bl_mf_new;
        for (auto& b : bl_mf) {
            for (int dim = 0; dim < AMREX_SPACEDIM; dim++) {
                if (m_fgeom.isPeriodic(dim)) {
                    int n = domain_cc.length(dim);
                    if (b.smallEnd(dim) == fdomain.smallEnd(dim)) {
                        Box bb_lo(b); bb_lo.enclosedCells(); bb_lo.shift(dim,n); bb_lo.setType(b.ixType());
                        bb_lo &= fba_bnd;
                        bl_mf_new.push_back(bb_lo);
                    }
                    Box bb_hi(b); bb_hi.enclosedCells();
                    if (bb_hi.bigEnd(dim) == fdomain.bigEnd(dim)) {
                        bb_hi.shift(dim,-n); bb_hi.setType(b.ixType());
                        bb_hi &= fba_bnd;
                        bl_mf_new.push_back(bb_hi);
                    }
               } // periodic
            } // dim
        } // bl_mf
 
        for (auto& b : bl_mf_new) {
            bl_mf.push_back(b);
        } // bl_mf
        fba_per.define(std::move(bl_mf));
 
    } else {
        fba_per = fba;
    }
 
    // BoxList and BoxArray to store complement
    BoxList com_bl; BoxArray com_ba;
 
    // Compute the complement
    fba_per.complementIn(com_bl,fba_bnd);
 
    // com_bl cannot be null since we grew with halo cells
    AMREX_ALWAYS_ASSERT(com_bl.size() > 0);
 
    IntVect box_grow_vect(-nghost,-nghost,0);
 
    // cf_set_width = cf_width = 0 is a special case
    // In this case we set only the normal velocities
    // (not any cell-centered quantities) and only
    // on the coarse-fine boundary itself
    if (nghost == 0) {
        if (fba.ixType()[0] == IndexType::NODE) {
            box_grow_vect = IntVect(1,0,0);
        } else if (fba.ixType()[1] == IndexType::NODE) {
            box_grow_vect = IntVect(0,1,0);
        } else if (fba.ixType()[2] == IndexType::NODE) {
            box_grow_vect = IntVect(0,0,1);
        }
    }
 
    // Grow the complement boxes and trim with the bounding box
    Vector<Box>& com_bl_v = com_bl.data();
    for (int i(0); i<com_bl.size(); ++i) {
        Box& bx = com_bl_v[i];
        bx.grow(box_grow_vect);
        bx &= fba_bnd;
    }
 
 
    // Do second complement with the grown boxes
    com_ba.define(std::move(com_bl));
    com_ba.complementIn(com_bl, fba_bnd);
 
    // Fill mask based upon the com_bl BoxList
    for (MFIter mfi(*m_cf_mask); mfi.isValid(); ++mfi) {
        const Box& vbx = mfi.validbox();
        const Array4<int>& mask_arr = m_cf_mask->array(mfi);
 
        for (auto const& b : com_bl) {
            Box com_bx = vbx & b;
            ParallelFor(com_bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
            {
                mask_arr(i,j,k) = mask_val;
            });
        }
    }
}

Referenced by Define().

Here is the caller graph for this function:

Define()

void ERFFillPatcher::Define	(	amrex::BoxArray const &	fba,
		amrex::DistributionMapping const &	fdm,
		amrex::Geometry const &	fgeom,
		amrex::BoxArray const &	cba,
		amrex::DistributionMapping const &	cdm,
		amrex::Geometry const &	cgeom,
		int	nghost,
		int	nghost_set,
		int	ncomp,
		amrex::InterpBase *	interp
	)

{
    AMREX_ALWAYS_ASSERT(nghost <= 0);
    AMREX_ALWAYS_ASSERT(nghost_set <= 0);
    AMREX_ALWAYS_ASSERT(nghost <= nghost_set);
 
    // Set data members
    m_fba = fba; m_cba = cba;
    m_fdm = fdm; m_cdm = cdm;
    m_fgeom  = fgeom;  m_cgeom = cgeom;
    m_nghost = nghost; m_nghost_subset = nghost_set;
    m_ncomp  = ncomp;  m_interp = interp;
 
    // Delete old MFs if they exist
    if (m_cf_crse_data_old) m_cf_crse_data_old.reset();
    if (m_cf_crse_data_new) m_cf_crse_data_new.reset();
    if (m_cf_mask) m_cf_mask.reset();
 
    // Index type for the BL/BA
    IndexType m_ixt = fba.ixType();
 
    // Refinement ratios
    for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
        m_ratio[idim] = m_fgeom.Domain().length(idim) / m_cgeom.Domain().length(idim);
    }
 
    // Coarse box list
    // NOTE: if we use face_cons_linear_interp then CoarseBox returns the grown box
    //       so we don't need to manually grow it here
    BoxList cbl;
    cbl.set(m_ixt);
    cbl.reserve(fba.size());
    for (int i(0); i < fba.size(); ++i) {
        Box coarse_box(interp->CoarseBox(fba[i], m_ratio));
        cbl.push_back(coarse_box);
    }
 
    // Box arrays for the coarse data
    BoxArray cf_cba(std::move(cbl));
 
    // Two coarse patches to hold the data to be interpolated
    m_cf_crse_data_old = std::make_unique<MultiFab> (cf_cba, fdm, m_ncomp, 0);
    m_cf_crse_data_new = std::make_unique<MultiFab> (cf_cba, fdm, m_ncomp, 0);
 
    // Integer masking array
    m_cf_mask = std::make_unique<iMultiFab> (fba, fdm, 1, 0);
 
    // Populate mask array
    if (nghost_set <= 0) {
        m_cf_mask->setVal(m_set_mask);
        BuildMask(fba,nghost_set,m_set_mask-1);
    } else {
        m_cf_mask->setVal(m_relax_mask);
        BuildMask(fba,nghost,m_relax_mask-1);
    }
}

Referenced by ERFFillPatcher().

Here is the call graph for this function:

Here is the caller graph for this function:

Fill()

template<typename BC >

void ERFFillPatcher::Fill	(	amrex::MultiFab &	mf,
		amrex::Real	time,
		BC &	cbc,
		amrex::Vector< amrex::BCRec > const &	bcs,
		int	mask_val
	)

{
    constexpr amrex::Real eps = std::numeric_limits<float>::epsilon();
 
    AMREX_ALWAYS_ASSERT((time >= m_crse_times[0]-eps) && (time <= m_crse_times[1]+eps));
 
    // Time interpolation factors
    amrex::Real fac_new = (time - m_crse_times[0]) / m_dt_crse;
    amrex::Real fac_old = 1.0 - fac_new;
 
    // Boundary condition operator
    cbc(*(m_cf_crse_data_old), 0, m_ncomp, amrex::IntVect(0), time, 0);
 
    // Coarse MF to hold time interpolated data
    amrex::MultiFab crse_data_time_interp(m_cf_crse_data_old->boxArray(),
                                          m_cf_crse_data_old->DistributionMap(),
                                          m_ncomp, amrex::IntVect{0});
 
    // Time interpolate the coarse data
    amrex::MultiFab::LinComb(crse_data_time_interp,
                             fac_old, *(m_cf_crse_data_old), 0,
                             fac_new, *(m_cf_crse_data_new), 0,
                             0, m_ncomp, amrex::IntVect{0});
 
    // Call correct spatial interpolation type
    amrex::IndexType m_ixt = mf.boxArray().ixType();
    int ixt_sum = m_ixt[0]+m_ixt[1]+m_ixt[2];
    if (ixt_sum == 0) {
        InterpCell(mf,crse_data_time_interp,bcs,mask_val);
    } else if (ixt_sum == 1) {
        InterpFace(mf,crse_data_time_interp,mask_val);
    } else {
        amrex::Abort("ERF_FillPatcher only supports face linear and cell cons linear interp!");
    }
}

Referenced by FillRelax(), and FillSet().

Here is the call graph for this function:

Here is the caller graph for this function:

FillRelax()

template<typename BC >

void ERFFillPatcher::FillRelax	(	amrex::MultiFab &	mf,
		amrex::Real	time,
		BC &	cbc,
		amrex::Vector< amrex::BCRec > const &	bcs
	)

{
    Fill(mf,time,cbc,bcs,m_relax_mask);
}

Referenced by fine_compute_interior_ghost_rhs().

Here is the call graph for this function:

Here is the caller graph for this function:

FillSet()

template<typename BC >

void ERFFillPatcher::FillSet	(	amrex::MultiFab &	mf,
		amrex::Real	time,
		BC &	cbc,
		amrex::Vector< amrex::BCRec > const &	bcs
	)

{
    Fill(mf,time,cbc,bcs,m_set_mask);
}

Here is the call graph for this function:

GetMask()

amrex::iMultiFab* ERFFillPatcher::GetMask ( )

inline

{ return m_cf_mask.get(); }

Referenced by fine_compute_interior_ghost_rhs().

Here is the caller graph for this function:

GetRelaxMaskVal()

int ERFFillPatcher::GetRelaxMaskVal ( )

inline

{ return m_relax_mask; }

Referenced by fine_compute_interior_ghost_rhs().

Here is the caller graph for this function:

GetSetMaskVal()

int ERFFillPatcher::GetSetMaskVal ( )

inline

{ return m_set_mask; }

Referenced by fine_compute_interior_ghost_rhs().

Here is the caller graph for this function:

InterpCell()

void ERFFillPatcher::InterpCell	(	amrex::MultiFab &	fine,
		amrex::MultiFab const &	crse,
		amrex::Vector< amrex::BCRec > const &	bcr,
		int	mask_val
	)

{
    int ncomp = m_ncomp;
    IntVect ratio = m_ratio;
    IndexType m_ixt = fine.boxArray().ixType();
    Box const& cdomain = convert(m_cgeom.Domain(), m_ixt);
 
    for (MFIter mfi(fine); mfi.isValid(); ++mfi) {
        Box const& fbx = mfi.validbox();
 
        Array4<Real> const&       fine_arr = fine.array(mfi);
        Array4<Real const> const& crse_arr = crse.const_array(mfi);
        Array4<int const> const&  mask_arr = m_cf_mask->const_array(mfi);
 
        bool run_on_gpu = Gpu::inLaunchRegion();
        amrex::ignore_unused(run_on_gpu);
 
        amrex::ignore_unused(m_fgeom);
 
        const Box& crse_region = m_interp->CoarseBox(fbx,ratio);
        Box cslope_bx(crse_region);
        for (int dim = 0; dim < AMREX_SPACEDIM; dim++) {
            if (ratio[dim] > 1) {
                cslope_bx.grow(dim,-1);
            }
        }
 
        FArrayBox ccfab(cslope_bx, ncomp*AMREX_SPACEDIM, The_Async_Arena());
        Array4<Real> const& tmp = ccfab.array();
        Array4<Real const> const& ctmp = ccfab.const_array();
 
#ifdef AMREX_USE_GPU
        AsyncArray<BCRec> async_bcr(bcr.data(), (run_on_gpu) ? ncomp : 0);
        BCRec const* bcrp = (run_on_gpu) ? async_bcr.data() : bcr.data();
#else
        BCRec const* bcrp = bcr.data();
#endif
 
        AMREX_HOST_DEVICE_PARALLEL_FOR_4D_FLAG(RunOn::Gpu, cslope_bx, ncomp, i, j, k, n,
        {
            mf_cell_cons_lin_interp_mcslope(i,j,k,n, tmp, crse_arr, 0, ncomp,
                                            cdomain, ratio, bcrp);
        });
 
        AMREX_HOST_DEVICE_PARALLEL_FOR_4D_FLAG(RunOn::Gpu, fbx, ncomp, i, j, k, n,
        {
            if (mask_arr(i,j,k) == mask_val) mf_cell_cons_lin_interp(i,j,k,n, fine_arr, 0, ctmp,
                                                                     crse_arr, 0, ncomp, ratio);
        });
    } // MFIter
}

Referenced by Fill().

Here is the caller graph for this function:

InterpFace()

void ERFFillPatcher::InterpFace	(	amrex::MultiFab &	fine,
		amrex::MultiFab const &	crse,
		int	mask_val
	)

{
    int ncomp = 1;
    IntVect ratio = m_ratio;
 
    FArrayBox slope;
 
    //
    // This box is only used to make sure we don't look outside
    //     the domain for computing the slopes in the interpolation
    // We need it to be of the type of the faces being filled
    //
    // IndexType ixt = fine.boxArray().ixType();
    // Box const& domface = convert(m_cgeom.Domain(), ixt);
 
    // We don't need to worry about face-based domain because this is only used in the tangential interpolation
    Box per_grown_domain = m_cgeom.Domain();
    for (int dim = 0; dim < AMREX_SPACEDIM; dim++) {
        if (m_cgeom.isPeriodic(dim)) {
            per_grown_domain.grow(dim,1);
        }
    }
 
    for (MFIter mfi(fine); mfi.isValid(); ++mfi)
    {
        Box const& fbx = mfi.validbox();
 
        slope.resize(fbx,ncomp,The_Async_Arena());
 
        Array4<Real> const&       fine_arr = fine.array(mfi);
        Array4<Real> const&      slope_arr = slope.array();
        Array4<Real const> const& crse_arr = crse.const_array(mfi);
        Array4<int const> const&  mask_arr = m_cf_mask->const_array(mfi);
 
        if (fbx.type(0) == IndexType::NODE) // x-faces
        {
            // Here do interpolation in the tangential directions
            AMREX_HOST_DEVICE_PARALLEL_FOR_3D_FLAG(RunOn::Gpu,fbx,i,j,k,
            {
                if (mask_arr(i,j,k) == mask_val) { // x-faces
                    const int ii = coarsen(i,ratio[0]);
                    if (i-ii*ratio[0] == 0) {
                        interp_face_reg(i,j,k,ratio,fine_arr,0,crse_arr,slope_arr,ncomp,per_grown_domain,0);
                    }
                }
            });
 
            // Here do interpolation in the normal direction
            //    using the fine values that have already been filled
            AMREX_HOST_DEVICE_PARALLEL_FOR_3D_FLAG(RunOn::Gpu,fbx,i,j,k,
            {
                if (mask_arr(i,j,k) == mask_val) {
                    const int ii = coarsen(i,ratio[0]);
                    if (i-ii*ratio[0] != 0) {
                        Real const w = static_cast<Real>(i-ii*ratio[0]) * (Real(1.)/Real(ratio[0]));
                        fine_arr(i,j,k,0) = (Real(1.)-w) * fine_arr(ii*ratio[0],j,k,0) + w * fine_arr((ii+1)*ratio[0],j,k,0);
                    }
                }
            });
 
        }
        else if (fbx.type(1) == IndexType::NODE) // y-faces
        {
            // Here do interpolation in the tangential directions
            AMREX_HOST_DEVICE_PARALLEL_FOR_3D_FLAG(RunOn::Gpu,fbx,i,j,k,
            {
                if (mask_arr(i,j,k) == mask_val) {
                    const int jj = coarsen(j,ratio[1]);
                    if (j-jj*ratio[1] == 0) {
                        interp_face_reg(i,j,k,ratio,fine_arr,0,crse_arr,slope_arr,ncomp,per_grown_domain,1);
                    }
                }
            });
 
            // Here do interpolation in the normal direction
            //    using the fine values that have already been filled
            AMREX_HOST_DEVICE_PARALLEL_FOR_3D_FLAG(RunOn::Gpu,fbx,i,j,k,
            {
                if (mask_arr(i,j,k) == mask_val) {
                    const int jj = coarsen(j,ratio[1]);
                    if (j-jj*ratio[1] != 0) {
                        Real const w = static_cast<Real>(j-jj*ratio[1]) * (Real(1.)/Real(ratio[1]));
                        fine_arr(i,j,k,0) = (Real(1.)-w) * fine_arr(i,jj*ratio[1],k,0) + w * fine_arr(i,(jj+1)*ratio[1],k,0);
                    }
                }
            });
        }
        else // z-faces
        {
            // Here do interpolation in the tangential directions
            AMREX_HOST_DEVICE_PARALLEL_FOR_3D_FLAG(RunOn::Gpu,fbx,i,j,k,
            {
                if (mask_arr(i,j,k) == mask_val) {
                    const int kk = coarsen(k,ratio[2]);
                    if (k-kk*ratio[2] == 0) {
                        interp_face_reg(i,j,k,ratio,fine_arr,0,crse_arr,slope_arr,1,per_grown_domain,2);
                    }
                }
            });
 
            // Here do interpolation in the normal direction
            //    using the fine values that have already been filled
            AMREX_HOST_DEVICE_PARALLEL_FOR_3D_FLAG(RunOn::Gpu,fbx,i,j,k,
            {
                if (mask_arr(i,j,k) == mask_val) {
                    const int kk = coarsen(k,ratio[2]);
                    if (k-kk*ratio[2] != 0) {
                        Real const w = static_cast<Real>(k-kk*ratio[2]) * (Real(1.)/Real(ratio[2]));
                        fine_arr(i,j,k,0) = (Real(1.)-w) * fine_arr(i,j,kk*ratio[2],0) + w * fine_arr(i,j,(kk+1)*ratio[2],0);
                    }
                }
            });
        } // IndexType::NODE
    } // MFiter
}

Referenced by Fill().

Here is the caller graph for this function:

RegisterCoarseData()

void ERFFillPatcher::RegisterCoarseData	(	amrex::Vector< amrex::MultiFab const * > const &	crse_data,
		amrex::Vector< amrex::Real > const &	crse_time
	)

{
    AMREX_ALWAYS_ASSERT(crse_data.size() == 2); // old and new
    AMREX_ALWAYS_ASSERT(crse_time[1] >= crse_time[0]);
 
    // NOTE: CoarseBox with CellConsLinear interpolation grows the
    //       box by 1 in all directions. This pushes the domain for
    //       m_cf_crse_data into ghost cells in the z-dir. So we need
    //       to include ghost cells for crse_data when doing the copy
    IntVect src_ng = crse_data[0]->nGrowVect();
    IntVect dst_ng = m_cf_crse_data_old->nGrowVect();
 
    m_cf_crse_data_old->ParallelCopy(*(crse_data[0]), 0, 0, m_ncomp,
                                    src_ng, dst_ng, m_cgeom.periodicity()); // old data
    m_cf_crse_data_new->ParallelCopy(*(crse_data[1]), 0, 0, m_ncomp,
                                    src_ng, dst_ng, m_cgeom.periodicity()); // new data
 
    m_crse_times[0] = crse_time[0]; // time of "old" coarse data
    m_crse_times[1] = crse_time[1]; // time of "new" coarse data
 
    m_dt_crse = crse_time[1] - crse_time[0];
}

Member Data Documentation

m_cba

amrex::BoxArray ERFFillPatcher::m_cba

private

Referenced by Define().

m_cdm

amrex::DistributionMapping ERFFillPatcher::m_cdm

private

Referenced by Define().

m_cf_crse_data_new

std::unique_ptr<amrex::MultiFab> ERFFillPatcher::m_cf_crse_data_new

private

Referenced by Define(), Fill(), and RegisterCoarseData().

m_cf_crse_data_old

std::unique_ptr<amrex::MultiFab> ERFFillPatcher::m_cf_crse_data_old

private

Referenced by Define(), Fill(), and RegisterCoarseData().

m_cf_mask

std::unique_ptr<amrex::iMultiFab> ERFFillPatcher::m_cf_mask

private

Referenced by BuildMask(), Define(), GetMask(), InterpCell(), and InterpFace().

m_cgeom

amrex::Geometry ERFFillPatcher::m_cgeom

private

Referenced by Define(), InterpCell(), InterpFace(), and RegisterCoarseData().

m_crse_times

amrex::Vector<amrex::Real> ERFFillPatcher::m_crse_times

private

Referenced by ERFFillPatcher(), Fill(), and RegisterCoarseData().

m_dt_crse

amrex::Real ERFFillPatcher::m_dt_crse

private

Referenced by Fill(), and RegisterCoarseData().

m_fba

amrex::BoxArray ERFFillPatcher::m_fba

private

Referenced by Define().

m_fdm

amrex::DistributionMapping ERFFillPatcher::m_fdm

private

Referenced by Define().

m_fgeom

amrex::Geometry ERFFillPatcher::m_fgeom

private

Referenced by BuildMask(), Define(), and InterpCell().

m_interp

amrex::InterpBase* ERFFillPatcher::m_interp

private

Referenced by Define(), and InterpCell().

m_ncomp

int ERFFillPatcher::m_ncomp

private

Referenced by Define(), Fill(), InterpCell(), and RegisterCoarseData().

m_nghost

int ERFFillPatcher::m_nghost

private

Referenced by Define().

m_nghost_subset

int ERFFillPatcher::m_nghost_subset

private

Referenced by Define().

m_ratio

amrex::IntVect ERFFillPatcher::m_ratio

private

Referenced by Define(), InterpCell(), and InterpFace().

m_relax_mask

int ERFFillPatcher::m_relax_mask {1}

private

Referenced by Define(), FillRelax(), and GetRelaxMaskVal().

m_set_mask

int ERFFillPatcher::m_set_mask {2}

private

Referenced by Define(), FillSet(), and GetSetMaskVal().

---

The documentation for this class was generated from the following files:

• Source/BoundaryConditions/ERF_FillPatcher.H
• Source/BoundaryConditions/ERF_FillPatcher.cpp