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< double > 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 ()
void	SetLogLawFill (bool on, amrex::Real z0, amrex::MultiFab const *wall_tblank)
int	GetRelaxMaskVal ()
amrex::iMultiFab *	GetMask ()
template<typename BC >
void	FillSet (amrex::MultiFab &mf, double time, BC &cbc, amrex::Vector< amrex::BCRec > const &bcs)
template<typename BC >
void	FillRelax (amrex::MultiFab &mf, double time, BC &cbc, amrex::Vector< amrex::BCRec > const &bcs)
template<typename BC >
void	Fill (amrex::MultiFab &mf, double time, BC &cbc, amrex::Vector< amrex::BCRec > const &bcs, int mask_val)
amrex::Vector< double > const &	crse_times () const
	The times of the coarse data last registered (RegisterCoarseData) More...

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
bool	m_loglaw = false
amrex::Real	m_loglaw_z0 = amrex::Real(0.1)
amrex::MultiFab const *	m_loglaw_tblank = nullptr
amrex::Vector< double >	m_crse_times
double	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
	)

Construct a coarse-fine fill patcher.

Parameters

[in]	fba	fine-level BoxArray
[in]	fdm	fine-level DistributionMapping
[in]	fgeom	fine-level Geometry
[in]	cba	coarse-level BoxArray
[in]	cdm	coarse-level DistributionMapping
[in]	cgeom	coarse-level Geometry
[in]	nghost	number of ghost cells in the fill region
[in]	nghost_set	number of ghost cells in the set region
[in]	ncomp	number of components
[in]	interp	interpolation operator

Fill valid and ghost data with the "state data" at the given time

Parameters

[in]	fba	BoxArray of data to be filled at fine level
[in]	fdm	DistributionMapping of data to be filled at fine level
[in]	fgeom	container of geometry information at fine level
[in]	cba	BoxArray of data to be filled at coarse level
[in]	cdm	DistributionMapping of data to be filled at coarse level
[in]	cgeom	container of geometry information at coarse level
[in]	nghost	number of ghost cells to be filled
[in]	nghost_set	number of ghost cells in the set region
[in]	ncomp	number of components to be filled
[in]	interp	interpolation operator to be used

    : 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
	)

Build the coarse-fine mask.

Parameters

[in]	fba	fine-level BoxArray
[in]	nghost	number of ghost cells in the fill region
[in]	nghost_set	number of ghost cells in the set region

Build the coarse-fine mask for set and relax regions.

Parameters

[in]	fba	BoxArray of data to be filled at fine level
[in]	nghost	number of ghost cells defining the region width
[in]	mask_val	value assigned to selected mask cells

{
    // 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) {
            Box bcc(b); bcc.enclosedCells();
 
            // Per direction, collect the periodic shifts that can bring this box back
            // into the bounding box.  A box only has an image across a face it actually
            // touches, and a box that spans the domain in a direction touches both.
            int shift[AMREX_SPACEDIM][3];
            int nshift[AMREX_SPACEDIM];
            for (int dim = 0; dim < AMREX_SPACEDIM; dim++) {
                int ns = 0;
                shift[dim][ns++] = 0;                       // the box where it already is
                if (m_fgeom.isPeriodic(dim)) {
                    int n = domain_cc.length(dim);
                    if (bcc.smallEnd(dim) == domain_cc.smallEnd(dim)) { shift[dim][ns++] =  n; }
                    if (bcc.bigEnd(dim)   == domain_cc.bigEnd(dim)  ) { shift[dim][ns++] = -n; }
                }
                nshift[dim] = ns;
            }
 
            // Every *combination* of those shifts, not one direction at a time.  In a
            // multiply periodic domain a fine patch sitting in a periodic corner also
            // has diagonal images, e.g. (+Lx,+Ly); shifting along single axes alone
            // never generates those, and complementIn then reports the corner cells as
            // uncovered coarse-fine boundary.
            for (int kk(0); kk < nshift[2]; ++kk) {
            for (int jj(0); jj < nshift[1]; ++jj) {
            for (int ii(0); ii < nshift[0]; ++ii) {
                if (ii == 0 && jj == 0 && kk == 0) { continue; }  // already in bl_mf
                Box bb(bcc);
                bb.shift(IntVect(shift[0][ii],shift[1][jj],shift[2][kk]));
                bb.setType(b.ixType());
                bb &= fba_bnd;
                if (bb.ok()) { bl_mf_new.push_back(bb); }
            }}} // shift combinations
        } // 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);
 
    // A band of width -nghost fine cells inside every coarse/fine face, including the top and
    // bottom faces of a level that does not reach the top or bottom of the domain (issue 4303)
    IntVect box_grow_vect(-nghost,-nghost,-nghost);
 
    // In z, only those coarse/fine faces start a band: drop the part of the complement that lies
    // above or below a non-periodic domain, so a level that does reach the top or bottom gets no
    // band at the physical boundary (in x and y the complement is used as it is)
    Box zdomain = convert(m_fgeom.Domain(), fba.ixType());
    zdomain.setRange(0, fba_bnd.smallEnd(0), fba_bnd.length(0));
    zdomain.setRange(1, fba_bnd.smallEnd(1), fba_bnd.length(1));
    const bool clip_z = (nghost != 0) && !m_fgeom.isPeriodic(2);
 
    // 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
    BoxList grown_bl(fba.ixType());
    for (Box bx : com_bl) {
        if (clip_z) {
            bx &= zdomain;
            if (!bx.ok()) { continue; }
        }
        bx.grow(box_grow_vect);
        bx &= fba_bnd;
        grown_bl.push_back(bx);
    }
    com_bl = std::move(grown_bl);
 
 
    // 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 call graph for this function:

Here is the caller graph for this function:

crse_times()

amrex::Vector<double> const& ERFFillPatcher::crse_times ( ) const

inline

The times of the coarse data last registered (RegisterCoarseData)

{ return m_crse_times; }

Referenced by ERF::cf_anelastic_stage_registration().

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
	)

Define the coarse-fine fill patcher.

Parameters

[in]	fba	fine-level BoxArray
[in]	fdm	fine-level DistributionMapping
[in]	fgeom	fine-level Geometry
[in]	cba	coarse-level BoxArray
[in]	cdm	coarse-level DistributionMapping
[in]	cgeom	coarse-level Geometry
[in]	nghost	number of ghost cells in the fill region
[in]	nghost_set	number of ghost cells in the set region
[in]	ncomp	number of components
[in]	interp	interpolation operator

Redefine the coarse and fine patch MultiFabs.

Parameters

[in]	fba	BoxArray of data to be filled at fine level
[in]	fdm	DistributionMapping of data to be filled at fine level
[in]	fgeom	container of geometry information at fine level
[in]	cba	BoxArray of data to be filled at coarse level
[in]	cdm	DistributionMapping of data to be filled at coarse level
[in]	cgeom	container of geometry information at coarse level
[in]	nghost	number of ghost cells to be filled
[in]	nghost_set	number of ghost cells in the set region
[in]	ncomp	number of components to be filled
[in]	interp	interpolation operator to be used

{
    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.  BuildMask(fba, n, val) sets val in every cell farther than
    //    -n cells (n <= 0) from the coarse-fine boundary, so after these three steps the band
    //    of width -nghost_set holds m_set_mask, the band out to -nghost holds m_relax_mask,
    //    and the rest of the fine level holds 0
    //
    // NOTE: the relax band is not currently used.  Nothing calls FillRelax, and
    //    ERF::ReadParameters requires cf_width = 0 with two-way coupling, so the band is
    //    empty there; with one-way coupling a cf_width > 0 builds it but nothing reads it.
    //    It is kept so that relaxation can be re-enabled.
    m_cf_mask->setVal(m_set_mask);
    BuildMask(fba,nghost_set,m_relax_mask);
    BuildMask(fba,nghost,0);
}

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,
		double	time_d,
		BC &	cbc,
		amrex::Vector< amrex::BCRec > const &	bcs,
		int	mask_val
	)

Fill fine data in the selected mask region.

Parameters

[in,out]	mf	MultiFab to be filled
[in]	time	time at which to fill data
[in]	cbc	coarse boundary condition
[in]	bcs	vector of boundary conditions
[in]	mask_val	mask value selecting cells to fill

Fill fine data in the relax region

Parameters

[in,out]	mf	MultiFab to be filled
[in]	time_d	Time at which to fill data
[in]	cbc	Coarse boundary condition
[in]	bcs	Vector of boundary conditions
[in]	mask_val	Mask value selecting cells to fill

{
    constexpr double eps = std::numeric_limits<float>::epsilon();
 
    AMREX_ALWAYS_ASSERT((time_d >= m_crse_times[0]-eps) && (time_d <= m_crse_times[1]+eps));
 
    amrex::Real time = static_cast<amrex::Real>(time_d);
 
    // Time interpolation factors
    amrex::Real fac_new = amrex::Real(0);
    amrex::Real fac_old = amrex::Real(1);
    if (amrex::Math::abs(m_dt_crse) > eps) {
        fac_new = static_cast<amrex::Real>((time_d - m_crse_times[0]) / m_dt_crse);
        fac_old = amrex::Real(1) - fac_new;
    }
 
    // 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});
 
    // Boundary condition operator, at the time it is asked for, on the data at that time.
    // Applied to the old coarse data before the interpolation it would be weighted by
    // fac_old -- and vanish at the new coarse time -- and would overwrite the registered
    // old data the next fill interpolates from.
    cbc(crse_data_time_interp, 0, m_ncomp, amrex::IntVect(0), time, 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,
		double	time,
		BC &	cbc,
		amrex::Vector< amrex::BCRec > const &	bcs
	)

Fill fine data in the relax region.

Not currently used: nothing calls it, and two-way coupling requires cf_width = 0, which leaves the relax region empty. Kept so that relaxation can be re-enabled.

Parameters

[in,out]	mf	MultiFab to be filled
[in]	time	time at which to fill data
[in]	cbc	coarse boundary condition
[in]	bcs	vector of boundary conditions

Fill fine data in the relax region

Parameters

[in,out]	mf	MultiFab to be filled
[in]	time	Time at which to fill data
[in]	cbc	Coarse boundary condition
[in]	bcs	Vector of boundary conditions

{
    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,
		double	time,
		BC &	cbc,
		amrex::Vector< amrex::BCRec > const &	bcs
	)

Fill fine data in the set region.

Parameters

[in,out]	mf	MultiFab to be filled
[in]	time	time at which to fill data
[in]	cbc	coarse boundary condition
[in]	bcs	vector of boundary conditions

Fill fine data in the set region

Parameters

[in,out]	mf	MultiFab to be filled
[in]	time	Time at which to fill data
[in]	cbc	Coarse boundary condition
[in]	bcs	Vector of boundary conditions

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

Referenced by fill_cf_momentum().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMask()

amrex::iMultiFab* ERFFillPatcher::GetMask ( )

inline

Return the coarse-fine mask.

{ 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 the mask value for the relax region.

{ 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 the mask value for the set region.

{ 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
	)

Interpolate coarse data to fine cell-centered data.

Parameters

[in,out]	fine	fine-level data to fill
[in]	crse	coarse-level source data
[in]	bcr	boundary-condition records
[in]	mask_val	mask value selecting cells to fill

Interpolate coarse data to fine cell-centered data selected by the mask.

Parameters

[in,out]	fine	fine-level data to fill
[in]	crse	coarse-level data to interpolate from
[in]	bcr	boundary-condition records used by the interpolater
[in]	mask_val	mask value selecting cells to fill

{
    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
	)

Interpolate coarse data to fine face data.

Parameters

[in,out]	fine	fine-level data to fill
[in]	crse	coarse-level source data
[in]	mask_val	mask value selecting cells to fill

Interpolate coarse data to fine face-centered data selected by the mask.

Parameters

[in,out]	fine	fine-level data to fill
[in]	crse	coarse-level data to interpolate from
[in]	mask_val	mask value selecting cells to fill

{
    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.0)/Real(ratio[0]));
                        fine_arr(i,j,k,0) = (Real(1.0)-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.0)/Real(ratio[1]));
                        fine_arr(i,j,k,0) = (Real(1.0)-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.0)/Real(ratio[2]));
                        fine_arr(i,j,k,0) = (Real(1.0)-w) * fine_arr(i,j,kk*ratio[2],0) + w * fine_arr(i,j,(kk+1)*ratio[2],0);
                    }
                }
            });
        } // IndexType::NODE
 
        // Log-law fill (erf.cf_loglaw_fill), lateral faces of a box that reaches the ground only.
        // The coarse face value next to a wall is a mean of a log profile, but the linear fill
        // above spreads it over the fine sub-faces with a slope that does not know the wall: the
        // fine sub-face at the wall gets too much flow and, at a surface-layer bottom (where the
        // slope is limited to about zero), the one above it too little. Share the flux F of the
        // first coarse face above the wall among its fine sub-faces in proportion to the integral
        // of ln(1 + z/z0) over the fluid part of each (cf_loglaw_weight), so a half-solid sub-face
        // carries its fluid share too. F is the sum of the sub-face values the linear fill put
        // there, the solid ones included, and the share returns F exactly, so the average down
        // of the c/f faces gives back the coarse values (moving flux between coarse faces would
        // drive a circulation in the coarse cells next to the fine box). The wall is the top of
        // the solid stack at the bottom of the column (the solid fraction, averaged over the two
        // cells of the face), or the bottom of the domain. A wall coarse face with no fluid
        // sub-face (the two columns' walls differ by a coarse cell or more) keeps the linear fill.
        // The option is set only around the set fills (ERF::set_cf_fill_options), so the relax
        // band keeps the linear fill.
        const int ldir = (fbx.type(0) == IndexType::NODE) ? 0 : ((fbx.type(1) == IndexType::NODE) ? 1 : 2);
        if (m_loglaw && ldir < 2 && fbx.smallEnd(2) == m_fgeom.Domain().smallEnd(2))
        {
            const int di = (ldir == 0), dj = (ldir == 1);
            const int rz = ratio[2];
            const Real dzf = m_fgeom.CellSize(2);
            const Real zlo = m_fgeom.ProbLo(2);
            const Real z0  = m_loglaw_z0;
            const int klo = fbx.smallEnd(2), khi = fbx.bigEnd(2);
            const bool have_tb = (m_loglaw_tblank != nullptr);
            if (have_tb) {
                // the solid fraction is read with the face array's MFIter: same boxes and ranks
                AMREX_ALWAYS_ASSERT(m_loglaw_tblank->DistributionMap() == fine.DistributionMap() &&
                                    m_loglaw_tblank->boxArray().size() == fine.boxArray().size());
            }
            Array4<Real const> const tb = have_tb ? m_loglaw_tblank->const_array(mfi) : Array4<Real const>{};
            Box colbx = fbx; colbx.setRange(2, klo);
            ParallelFor(colbx, [=] AMREX_GPU_DEVICE (int i, int j, int) noexcept
            {
                // the surface height of the face (the mean of its two columns; the neighbour
                // column across the coarse/fine boundary is a ghost cell of the fine blanking,
                // which holds the geometry there), and the wall cell: the first cell up the
                // column whose face is not next to a fully solid cell, found in integer
                // arithmetic so that a wall on a cell face does not round to the cell below
                const Real zs = have_tb ? Real(0.5) * (cf_wall_height(tb,i,j,klo,khi,zlo,dzf) +
                                                       cf_wall_height(tb,i-di,j-dj,klo,khi,zlo,dzf))
                                        : zlo + dzf * static_cast<Real>(klo);
                int kf = klo;
                if (have_tb) {
                    while (kf <= khi && cf_face_solid(tb,i,j,kf,di,dj,0)) { ++kf; }
                }
                const int kc0 = coarsen(kf, rz) * rz;
                if (kc0 < klo || kc0 + rz - 1 > khi) { return; }
                for (int kk = kc0; kk < kc0+rz; ++kk) {
                    if (mask_arr(i,j,kk) != mask_val) { return; }
                }
                Real F = Real(0.0), W = Real(0.0);
                for (int kk = kc0; kk < kc0+rz; ++kk) {
                    F += fine_arr(i,j,kk,0);
                    if (have_tb && cf_face_solid(tb,i,j,kk,di,dj,0)) { continue; }
                    const Real zb = zlo + dzf * static_cast<Real>(kk);
                    W += cf_loglaw_weight(zs, zb, dzf, z0);
                }
                if (W <= Real(0.0)) { return; }
                // the solid sub-faces of the wall face carry nothing; the fluid ones share the
                // whole flux of the coarse face
                for (int kk = kc0; kk < kc0+rz; ++kk) {
                    if (have_tb && cf_face_solid(tb,i,j,kk,di,dj,0)) { fine_arr(i,j,kk,0) = Real(0.0); continue; }
                    const Real zb = zlo + dzf * static_cast<Real>(kk);
                    fine_arr(i,j,kk,0) = F * cf_loglaw_weight(zs, zb, dzf, z0) / W;
                }
            });
        }
    } // MFiter
}

Referenced by Fill().

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterCoarseData()

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

Register coarse data bracketing the fill time.

Parameters

[in]	crse_data	coarse MultiFabs
[in]	crse_time	times associated with crse_data

Register the coarse data to be used by the ERFFillPatcher

Parameters

[in]	crse_data	data at old and new time at coarse level
[in]	crse_time	times at which crse_data is defined

{
    AMREX_ALWAYS_ASSERT(crse_data.size() == 2); // old and new
    AMREX_ALWAYS_ASSERT(crse_time[1] >= crse_time[0]);
 
    // NOTE: CoarseBox grows the coarsened fine box by one cell in each direction whose
    //       refinement ratio is > 1 (and, for face_cons_linear_interp, that is cell-centered).
    //       Where the fine level touches the domain boundary, the grown box reaches past the
    //       coarse domain (e.g. in z when the vertical ratio is > 1), so include the ghost
    //       cells of crse_data in 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];
}

Referenced by ERF::cf_anelastic_stage_registration().

Here is the call graph for this function:

Here is the caller graph for this function:

SetLogLawFill()

void ERFFillPatcher::SetLogLawFill ( bool  on, amrex::Real  z0, amrex::MultiFab const *  wall_tblank  )

inline

Log-law fill of the lateral coarse/fine faces next to a wall (erf.cf_loglaw_fill): the flux of the first coarse face above the wall is shared among its fine sub-faces in proportion to the integral of ln(1 + z/z0) over the fluid part of each, so the flux of every coarse face is kept. Acts on the set fills of fine boxes that reach the bottom of the domain.

Parameters

[in]	on	enable the log-law fill (constant dz only)
[in]	z0	roughness length [m]
[in]	wall_tblank	fine solid fraction giving the wall height (immersed forcing), or nullptr for a wall at the bottom of the domain

    {
        m_loglaw = on; m_loglaw_z0 = z0; m_loglaw_tblank = wall_tblank;
    }

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<double> ERFFillPatcher::m_crse_times

private

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

m_dt_crse

double 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(), InterpCell(), and InterpFace().

m_interp

amrex::InterpBase* ERFFillPatcher::m_interp

private

Referenced by Define(), and InterpCell().

m_loglaw

bool ERFFillPatcher::m_loglaw = false

private

Referenced by InterpFace(), and SetLogLawFill().

m_loglaw_tblank

amrex::MultiFab const* ERFFillPatcher::m_loglaw_tblank = nullptr

private

Referenced by InterpFace(), and SetLogLawFill().

m_loglaw_z0

amrex::Real ERFFillPatcher::m_loglaw_z0 = amrex::Real(0.1)

private

Referenced by InterpFace(), and SetLogLawFill().

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