ERFPhysBCFunct_w Class Reference

#include <ERF_PhysBCFunct.H>

Collaboration diagram for ERFPhysBCFunct_w:

Public Member Functions
	ERFPhysBCFunct_w (const int lev, const amrex::Geometry &geom, const amrex::Vector< amrex::BCRec > &domain_bcs_type, const amrex::Gpu::DeviceVector< amrex::BCRec > &domain_bcs_type_d, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > bc_extdir_vals, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > bc_neumann_vals, const TerrainType &terrain_type, std::unique_ptr< amrex::MultiFab > &z_phys_nd, const bool use_real_bcs, amrex::Real *w_bc_data)
	~ERFPhysBCFunct_w ()
void	operator() (amrex::MultiFab &mf, amrex::MultiFab &xvel, amrex::MultiFab &yvel, amrex::IntVect const &nghost, const amrex::Real time, int bccomp, bool do_fb)
void	impose_lateral_zvel_bcs (const amrex::Array4< amrex::Real > &dest_arr, const amrex::Array4< amrex::Real const > &xvel_arr, const amrex::Array4< amrex::Real const > &yvel_arr, const amrex::Box &bx, const amrex::Box &domain, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int bccomp)
void	impose_vertical_zvel_bcs (const amrex::Array4< amrex::Real > &dest_arr, const amrex::Array4< amrex::Real const > &xvel_arr, const amrex::Array4< amrex::Real const > &yvel_arr, const amrex::Box &bx, const amrex::Box &domain, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int bccomp_u, int bccomp_v, int bccomp_w, TerrainType terrain_type)

Private Attributes
int	m_lev
amrex::Geometry	m_geom
amrex::Vector< amrex::BCRec >	m_domain_bcs_type
amrex::Gpu::DeviceVector< amrex::BCRec >	m_domain_bcs_type_d
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max >	m_bc_extdir_vals
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max >	m_bc_neumann_vals
TerrainType	m_terrain_type
amrex::MultiFab *	m_z_phys_nd
bool	m_use_real_bcs
amrex::Real *	m_w_bc_data

Constructor & Destructor Documentation

ERFPhysBCFunct_w()

ERFPhysBCFunct_w::ERFPhysBCFunct_w ( const int  lev, const amrex::Geometry &  geom, const amrex::Vector< amrex::BCRec > &  domain_bcs_type, const amrex::Gpu::DeviceVector< amrex::BCRec > &  domain_bcs_type_d, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max >  bc_extdir_vals, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max >  bc_neumann_vals, const TerrainType &  terrain_type, std::unique_ptr< amrex::MultiFab > &  z_phys_nd, const bool  use_real_bcs, amrex::Real *  w_bc_data  )

inline

        : m_lev(lev),
          m_geom(geom), m_domain_bcs_type(domain_bcs_type),
          m_domain_bcs_type_d(domain_bcs_type_d),
          m_bc_extdir_vals(bc_extdir_vals),
          m_bc_neumann_vals(bc_neumann_vals),
          m_terrain_type(terrain_type),
          m_z_phys_nd(z_phys_nd.get()),
          m_use_real_bcs(use_real_bcs),
          m_w_bc_data(w_bc_data)
    { }

~ERFPhysBCFunct_w()

ERFPhysBCFunct_w::~ERFPhysBCFunct_w ( )

inline

{}

Member Function Documentation

impose_lateral_zvel_bcs()

void ERFPhysBCFunct_w::impose_lateral_zvel_bcs	(	const amrex::Array4< amrex::Real > &	dest_arr,
		const amrex::Array4< amrex::Real const > &	xvel_arr,
		const amrex::Array4< amrex::Real const > &	yvel_arr,
		const amrex::Box &	bx,
		const amrex::Box &	domain,
		const amrex::Array4< amrex::Real const > &	z_nd,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >	dxInv,
		int	bccomp
	)

{
    BL_PROFILE_VAR("impose_lateral_zvel_bcs()",impose_lateral_zvel_bcs);
    const auto& dom_lo = lbound(domain);
    const auto& dom_hi = ubound(domain);
 
    // Based on BCRec for the domain, we need to make BCRec for this Box
    // bccomp is used as starting index for m_domain_bcs_type
    //      0 is used as starting index for bcrs
    Vector<BCRec> bcrs_w(1);
    setBC(enclosedCells(bx), domain, bccomp, 0, 1, m_domain_bcs_type, bcrs_w);
 
    // xlo: ori = 0
    // ylo: ori = 1
    // zlo: ori = 2
    // xhi: ori = 3
    // yhi: ori = 4
    // zhi: ori = 5
 
    Gpu::DeviceVector<BCRec> bcrs_w_d(1);
    Gpu::copyAsync(Gpu::hostToDevice, bcrs_w.begin(), bcrs_w.end(), bcrs_w_d.begin());
    const BCRec* bc_ptr_w = bcrs_w_d.data();
 
    GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,1> l_bc_extdir_vals_d;
 
    bool l_use_terrain = (m_z_phys_nd != nullptr);
 
    for (int ori = 0; ori < 2*AMREX_SPACEDIM; ori++) {
        l_bc_extdir_vals_d[0][ori] = m_bc_extdir_vals[bccomp][ori];
    }
 
    GeometryData const& geomdata = m_geom.data();
    bool is_periodic_in_x = geomdata.isPeriodic(0);
    bool is_periodic_in_y = geomdata.isPeriodic(1);
 
    FArrayBox dhdtfab;
 
    // First do all ext_dir bcs
    if (!is_periodic_in_x)
    {
        Real* zvel_bc_ptr = m_w_bc_data;
        Box bx_xlo(bx);  bx_xlo.setBig  (0,dom_lo.x-1);
        Box bx_xhi(bx);  bx_xhi.setSmall(0,dom_hi.x+1);
        ParallelFor(bx_xlo, bx_xhi,
            [=] AMREX_GPU_DEVICE (int i, int j, int k) {
                int iflip = dom_lo.x - 1 - i;
                if (bc_ptr_w[0].lo(0) == ERFBCType::ext_dir) {
                    dest_arr(i,j,k) = (zvel_bc_ptr) ? zvel_bc_ptr[k] : l_bc_extdir_vals_d[0][0];
                    if (l_use_terrain) {
                        dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
                    }
                } else if (bc_ptr_w[0].lo(0) == ERFBCType::foextrap) {
                    dest_arr(i,j,k) =  dest_arr(dom_lo.x,j,k);
                } else if (bc_ptr_w[0].lo(0) == ERFBCType::open) {
                    dest_arr(i,j,k) =  dest_arr(dom_lo.x,j,k);
                } else if (bc_ptr_w[0].lo(0) == ERFBCType::reflect_even) {
                    dest_arr(i,j,k) =  dest_arr(iflip,j,k);
                } else if (bc_ptr_w[0].lo(0) == ERFBCType::reflect_odd) {
                    dest_arr(i,j,k) = -dest_arr(iflip,j,k);
                }
            },
            [=] AMREX_GPU_DEVICE (int i, int j, int k) {
                int iflip = 2*dom_hi.x + 1 - i;
                if (bc_ptr_w[0].hi(0) == ERFBCType::ext_dir) {
                    dest_arr(i,j,k) = (zvel_bc_ptr) ? zvel_bc_ptr[k] : l_bc_extdir_vals_d[0][3];
                    if (l_use_terrain) {
                        dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
                    }
                } else if (bc_ptr_w[0].hi(0) == ERFBCType::foextrap) {
                    dest_arr(i,j,k) =  dest_arr(dom_hi.x,j,k);
                } else if (bc_ptr_w[0].hi(0) == ERFBCType::open) {
                    dest_arr(i,j,k) =  dest_arr(dom_hi.x,j,k);
                } else if (bc_ptr_w[0].hi(0) == ERFBCType::reflect_even) {
                    dest_arr(i,j,k) =  dest_arr(iflip,j,k);
                } else if (bc_ptr_w[0].hi(0) == ERFBCType::reflect_odd) {
                    dest_arr(i,j,k) = -dest_arr(iflip,j,k);
                }
            }
        );
    }
 
    // First do all ext_dir bcs
    if (!is_periodic_in_y)
    {
        Real* zvel_bc_ptr = m_w_bc_data;
        Box bx_ylo(bx);  bx_ylo.setBig  (1,dom_lo.y-1);
        Box bx_yhi(bx);  bx_yhi.setSmall(1,dom_hi.y+1);
        ParallelFor(bx_ylo, bx_yhi,
            [=] AMREX_GPU_DEVICE (int i, int j, int k) {
                int jflip = dom_lo.y - 1 - j;
                if (bc_ptr_w[0].lo(1) == ERFBCType::ext_dir) {
                    dest_arr(i,j,k) = (zvel_bc_ptr) ? zvel_bc_ptr[k] : l_bc_extdir_vals_d[0][1];
                    if (l_use_terrain) {
                        dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
                    }
                } else if (bc_ptr_w[0].lo(1) == ERFBCType::foextrap) {
                    dest_arr(i,j,k) =  dest_arr(i,dom_lo.y,k);
                } else if (bc_ptr_w[0].lo(1) == ERFBCType::open) {
                    dest_arr(i,j,k) =  dest_arr(i,dom_lo.y,k);
                } else if (bc_ptr_w[0].lo(1) == ERFBCType::reflect_even) {
                    dest_arr(i,j,k) =  dest_arr(i,jflip,k);
                } else if (bc_ptr_w[0].lo(1) == ERFBCType::reflect_odd) {
                    dest_arr(i,j,k) = -dest_arr(i,jflip,k);
                }
            },
            [=] AMREX_GPU_DEVICE (int i, int j, int k) {
                int jflip =  2*dom_hi.y + 1 - j;
                if (bc_ptr_w[0].hi(1) == ERFBCType::ext_dir) {
                    dest_arr(i,j,k) = (zvel_bc_ptr) ? zvel_bc_ptr[k] : l_bc_extdir_vals_d[0][4];
                    if (l_use_terrain) {
                        dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
                    }
                } else if (bc_ptr_w[0].hi(1) == ERFBCType::foextrap) {
                    dest_arr(i,j,k) =  dest_arr(i,dom_hi.y,k);
                } else if (bc_ptr_w[0].hi(1) == ERFBCType::open) {
                    dest_arr(i,j,k) =  dest_arr(i,dom_hi.y,k);
                } else if (bc_ptr_w[0].hi(1) == ERFBCType::reflect_even) {
                    dest_arr(i,j,k) =  dest_arr(i,jflip,k);
                } else if (bc_ptr_w[0].hi(1) == ERFBCType::reflect_odd) {
                    dest_arr(i,j,k) = -dest_arr(i,jflip,k);
                }
            });
    }
    Gpu::streamSynchronize();
}

Here is the call graph for this function:

impose_vertical_zvel_bcs()

void ERFPhysBCFunct_w::impose_vertical_zvel_bcs	(	const amrex::Array4< amrex::Real > &	dest_arr,
		const amrex::Array4< amrex::Real const > &	xvel_arr,
		const amrex::Array4< amrex::Real const > &	yvel_arr,
		const amrex::Box &	bx,
		const amrex::Box &	domain,
		const amrex::Array4< amrex::Real const > &	z_nd,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >	dxInv,
		int	bccomp_u,
		int	bccomp_v,
		int	bccomp_w,
		TerrainType	terrain_type
	)

{
    BL_PROFILE_VAR("impose_vertical_zvel_bcs()",impose_vertical_zvel_bcs);
    const auto& dom_lo = lbound(domain);
    const auto& dom_hi = ubound(domain);
 
    // xlo: ori = 0
    // ylo: ori = 1
    // zlo: ori = 2
    // xhi: ori = 3
    // yhi: ori = 4
    // zhi: ori = 5
 
    // Based on BCRec for the domain, we need to make BCRec for this Box
    // bccomp is used as starting index for m_domain_bcs_type
    //      0 is used as starting index for bcrs
    Vector<BCRec> bcrs_u(1), bcrs_v(1), bcrs_w(1);
    setBC(enclosedCells(bx), domain, bccomp_u, 0, 1, m_domain_bcs_type, bcrs_u);
    setBC(enclosedCells(bx), domain, bccomp_v, 0, 1, m_domain_bcs_type, bcrs_v);
    setBC(enclosedCells(bx), domain, bccomp_w, 0, 1, m_domain_bcs_type, bcrs_w);
 
    // We use these for the asserts below
    const BCRec* bc_ptr_u_h = bcrs_u.data();
    const BCRec* bc_ptr_v_h = bcrs_v.data();
    const BCRec* bc_ptr_w_h = bcrs_w.data();
 
    bool l_use_terrain = (m_z_phys_nd != nullptr);
    bool l_moving_terrain = (terrain_type == TerrainType::Moving);
 
    GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,1> l_bc_extdir_vals_d;
 
    for (int ori = 0; ori < 2*AMREX_SPACEDIM; ori++) {
        l_bc_extdir_vals_d[0][ori] = m_bc_extdir_vals[bccomp_w][ori];
    }
 
    // *******************************************************
    // Bottom boundary
    // *******************************************************
 
    // *******************************************************
    // Moving terrain
    // *******************************************************
    if (l_use_terrain && l_moving_terrain)
    {
        //************************************************************
        // NOTE: z_t depends on the time interval in which it is
        //       evaluated so we can't arbitrarily define it at a
        //       given time, we must specify an interval
        //************************************************************
 
    // Static terrain
    } else if (l_use_terrain) {
 
        if (m_lev == 0) {
            AMREX_ALWAYS_ASSERT( (bc_ptr_u_h[0].lo(2) == ERFBCType::ext_dir && bc_ptr_v_h[0].lo(2) == ERFBCType::ext_dir) ||
                                 (bc_ptr_u_h[0].lo(2) != ERFBCType::ext_dir && bc_ptr_v_h[0].lo(2) != ERFBCType::ext_dir) );
        } else {
            // If we do not reach to the top or bottom boundary then the z-vel should be
            //    filled by interpolation from the coarser grid using ERF_FillPatcher.
        }
        if (bx.smallEnd(2) == dom_lo.z) {
            ParallelFor(makeSlab(bx,2,dom_lo.z), [=] AMREX_GPU_DEVICE (int i, int j, int k) {
                dest_arr(i,j,k) = WFromOmega(i,j,k,l_bc_extdir_vals_d[0][2],xvel_arr,yvel_arr,z_phys_nd,dxInv);
            });
        }
 
    // No terrain
    } else {
        if (bx.smallEnd(2) == dom_lo.z) {
            ParallelFor(makeSlab(bx,2,dom_lo.z), [=] AMREX_GPU_DEVICE (int i, int j, int k) {
               dest_arr(i,j,k) = l_bc_extdir_vals_d[0][2];
            });
        }
    }
 
    // *******************************************************
    // Top boundary
    // *******************************************************
 
    // NOTE: if we set SlipWall at top, that generates ERFBCType::ext_dir which sets w=0 here
    // NOTE: if we set  Outflow at top, that generates ERFBCType::foextrap which doesn't touch w here
    if (bx.bigEnd(2) == dom_hi.z+1) {
        if (bc_ptr_w_h[0].hi(2) == ERFBCType::ext_dir) {
            ParallelFor(makeSlab(bx,2,dom_hi.z+1), [=] AMREX_GPU_DEVICE (int i, int j, int k)
            {
                if (l_use_terrain) {
                    dest_arr(i,j,k) = WFromOmega(i,j,k,l_bc_extdir_vals_d[0][5],xvel_arr,yvel_arr,z_phys_nd,dxInv);
                } else {
                    dest_arr(i,j,k) = l_bc_extdir_vals_d[0][5];
                }
            });
        } else if (bc_ptr_w_h[0].hi(2) == ERFBCType::neumann_int) {
            ParallelFor(makeSlab(bx,2,dom_hi.z+1), [=] AMREX_GPU_DEVICE (int i, int j, int k)
            {
                dest_arr(i,j,k) = (4.0*dest_arr(i,j,dom_hi.z) - dest_arr(i,j,dom_hi.z-1))/3.0;
            });
        }
    }
    Gpu::streamSynchronize();
}

Here is the call graph for this function:

operator()()

void ERFPhysBCFunct_w::operator()	(	amrex::MultiFab &	mf,
		amrex::MultiFab &	xvel,
		amrex::MultiFab &	yvel,
		amrex::IntVect const &	nghost,
		const amrex::Real	time,
		int	bccomp,
		bool	do_fb
	)

{
    BL_PROFILE("ERFPhysBCFunct_w::()");
 
    int bccomp_u = BCVars::xvel_bc;
    int bccomp_v = BCVars::yvel_bc;
 
    if (m_geom.isAllPeriodic()) return;
 
    const auto& domain = m_geom.Domain();
    const auto dxInv   = m_geom.InvCellSizeArray();
 
    Box gdomainz = surroundingNodes(domain,2);
    for (int i = 0; i < AMREX_SPACEDIM; ++i) {
        if (m_geom.isPeriodic(i)) {
            gdomainz.grow(i, nghost[i]);
        }
    }
    //
    // We want to make sure we impose the z-vels at k=0  if the box includes k=0
    //
    if (gdomainz.smallEnd(2) == 0) gdomainz.setSmall(2,1);
 
    //
    // We fill all of the interior and periodic ghost cells first, so we can fill
    //    those directly inside the lateral and vertical calls.
    //
    if (do_fb) {
        mf.FillBoundary(m_geom.periodicity());
    }
 
#ifdef AMREX_USE_OMP
#pragma omp parallel if (Gpu::notInLaunchRegion())
#endif
    {
        for (MFIter mfi(mf,false); mfi.isValid(); ++mfi)
        {
            //
            // This is the box we pass to the different routines
            // NOTE -- this is the full grid NOT the tile box
            //
            Box bx  = mfi.validbox();
 
            //
            // These are the boxes we use to test on relative to the domain
            //
            Box zbx = surroundingNodes(bx,2); zbx.grow(nghost);
            if (zbx.smallEnd(2) < domain.smallEnd(2)) zbx.setSmall(2,domain.smallEnd(2));
            if (zbx.bigEnd(2)   > domain.bigEnd(2))   zbx.setBig(2,domain.bigEnd(2)+1);
 
            Array4<const Real> z_nd_arr;
 
            if (m_z_phys_nd)
            {
                z_nd_arr = m_z_phys_nd->const_array(mfi);
            }
 
            //
            // Recall that gdomainz.smallEnd(2) = 1 not 0!
            //
            if (!gdomainz.contains(zbx))
            {
                Array4<const Real> const& velx_arr = xvel.const_array(mfi);
                Array4<const Real> const& vely_arr = yvel.const_array(mfi);
                Array4<      Real> const& velz_arr = mf.array(mfi);
 
                if (!m_use_real_bcs)
                {
                    if (!gdomainz.contains(zbx))
                    {
                        impose_lateral_zvel_bcs(velz_arr,velx_arr,vely_arr,zbx,domain,z_nd_arr,dxInv,bccomp_w);
                    }
                }
 
                impose_vertical_zvel_bcs(velz_arr,velx_arr,vely_arr,zbx,domain,z_nd_arr,dxInv,
                                         bccomp_u, bccomp_v, bccomp_w, m_terrain_type);
            }
        } // MFIter
    } // OpenMP
} // operator()

Member Data Documentation

m_bc_extdir_vals

amrex::Array<amrex::Array<amrex::Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NBCVAR_max> ERFPhysBCFunct_w::m_bc_extdir_vals

private

m_bc_neumann_vals

amrex::Array<amrex::Array<amrex::Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NBCVAR_max> ERFPhysBCFunct_w::m_bc_neumann_vals

private

m_domain_bcs_type

amrex::Vector<amrex::BCRec> ERFPhysBCFunct_w::m_domain_bcs_type

private

m_domain_bcs_type_d

amrex::Gpu::DeviceVector<amrex::BCRec> ERFPhysBCFunct_w::m_domain_bcs_type_d

private

m_geom

amrex::Geometry ERFPhysBCFunct_w::m_geom

private

m_lev

int ERFPhysBCFunct_w::m_lev

private

m_terrain_type

TerrainType ERFPhysBCFunct_w::m_terrain_type

private

m_use_real_bcs

bool ERFPhysBCFunct_w::m_use_real_bcs

private

m_w_bc_data

amrex::Real* ERFPhysBCFunct_w::m_w_bc_data

private

m_z_phys_nd

amrex::MultiFab* ERFPhysBCFunct_w::m_z_phys_nd

private

---

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

• Source/BoundaryConditions/ERF_PhysBCFunct.H
• Source/BoundaryConditions/ERF_BoundaryConditionsZvel.cpp
• Source/BoundaryConditions/ERF_PhysBCFunct.cpp