ERF_EBRedistribute.cpp File Reference

#include <AMReX_Config.H>
#include <AMReX_Geometry.H>
#include <ERF.H>
#include <ERF_EBRedistribute.H>
#include "AMReX_EB_Redistribution.H"

Include dependency graph for ERF_EBRedistribute.cpp:

Functions
void	redistribute_term (int ncomp, const Geometry &geom, MultiFab &result, MultiFab &result_tmp, MultiFab const &state, EBFArrayBoxFactory const &ebfact, BCRec const *bc, Real const local_dt)
void	redistribute_term (MFIter const &mfi, int ncomp, const Geometry &geom, MultiFab &result, MultiFab &result_tmp, MultiFab const &state, EBFArrayBoxFactory const &ebfact, BCRec const *bc, Real const local_dt)

Function Documentation

redistribute_term() [1/2]

void redistribute_term	(	int	ncomp,
		const Geometry &	geom,
		MultiFab &	result,
		MultiFab &	result_tmp,
		MultiFab const &	state,
		EBFArrayBoxFactory const &	ebfact,
		BCRec const *	bc,
		Real const	local_dt
	)

{
    // ************************************************************************
    // Redistribute result_tmp and pass out result
    // ************************************************************************
    AMREX_ASSERT(result.nComp() == state.nComp());
 
    result_tmp.FillBoundary(geom.periodicity());
 
#ifdef _OPENMP
#pragma omp parallel if (Gpu::notInLaunchRegion())
#endif
    for (MFIter mfi(state,TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        redistribute_term(mfi, ncomp, geom, result, result_tmp, state, ebfact, bc, local_dt);
    }
}

Referenced by erf_slow_rhs_post().

Here is the caller graph for this function:

redistribute_term() [2/2]

void redistribute_term	(	MFIter const &	mfi,
		int	ncomp,
		const Geometry &	geom,
		MultiFab &	result,
		MultiFab &	result_tmp,
		MultiFab const &	state,
		EBFArrayBoxFactory const &	ebfact,
		BCRec const *	bc,
		Real const	local_dt
	)

{
    AMREX_ASSERT(result.nComp() == state.nComp());
 
    Box const& bx = mfi.tilebox();
 
    // EBFArrayBoxFactory const& ebfact = EBFactory(lev);
    EBCellFlagFab const& flagfab = ebfact.getMultiEBCellFlagFab()[mfi];
    Array4<EBCellFlag const> const& flag = flagfab.const_array();
 
    bool regular = (flagfab.getType(amrex::grow(bx,4)) == FabType::regular);
    bool covered = (flagfab.getType(bx) == FabType::covered);
 
    Array4<Real> out = result.array(mfi);
    Array4<Real> in  = result_tmp.array(mfi);
 
    if (!regular && !covered)
    {
        auto const& vfrac = ebfact.getVolFrac().const_array(mfi);
        auto const& ccc   = ebfact.getCentroid().const_array(mfi);
 
        auto const& apx = ebfact.getAreaFrac()[0]->const_array(mfi);
        auto const& apy = ebfact.getAreaFrac()[1]->const_array(mfi);
        auto const& apz = ebfact.getAreaFrac()[2]->const_array(mfi);
 
        auto const& fcx = ebfact.getFaceCent()[0]->const_array(mfi);
        auto const& fcy = ebfact.getFaceCent()[1]->const_array(mfi);
        auto const& fcz = ebfact.getFaceCent()[2]->const_array(mfi);
 
        Box gbx = bx; gbx.grow(3);
 
        FArrayBox scratch_fab(gbx,ncomp);
        Array4<Real> scratch = scratch_fab.array();
        Elixir eli_scratch = scratch_fab.elixir();
 
        // This is scratch space if calling StateRedistribute
        // ParallelFor(Box(scratch), [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
        // {
        //     scratch(i,j,k) = 1.;
        // });
 
        std::string redistribution_type = "StateRedist";
 
        // State redist acts on the state.
        Array4<Real const> state_arr = state.const_array(mfi);
        ApplyRedistribution( bx, ncomp, out, in, state_arr,
                             scratch, flag,
                             apx, apy, apz, vfrac,
                             fcx, fcy, fcz, ccc,
                             bc, geom, local_dt, redistribution_type);
    }
    else
    {
        ParallelFor(bx, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) noexcept
        {
            out(i,j,k,n) = in(i,j,k,n);
        });
    }
}