ERF_Utils.H File Reference

#include "AMReX.H"
#include "AMReX_MultiFab.H"
#include "AMReX_BCRec.H"
#include "ERF_NumericalConstants.H"
#include "ERF_MicrophysicsConstants.H"
#include "ERF_DataStruct.H"
#include "ERF_IndexDefines.H"
#include "ERF_SurfaceLayer.H"
#include "ERF_FillPatcher.H"
#include "ERF_ReadBndryPlanes.H"

Include dependency graph for ERF_Utils.H:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	wrf_moisture_target (const amrex::Real rho, const amrex::Real q_n, const amrex::Real q_np1, const amrex::Real alpha) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	wrf_bdy_has_separate_hydrometeors (const MoistureComponentIndices &moisture_indices) noexcept
int	wrf_bdy_var_for_moisture_component (const int comp, const MoistureComponentIndices &moisture_indices, const bool use_wrf_bdy_qc_qi, const bool separate_hydrometeors=false)
void	rebalance_columns (amrex::MultiFab &rho, amrex::MultiFab &theta, const amrex::MultiFab &qt, const amrex::MultiFab &qv, const amrex::MultiFab *z_phys, const amrex::Geometry &geom, const bool &maintain_Th, bool use_sfc=false)
void	ChopGrids2D (amrex::BoxArray &ba, const amrex::Box &domain, int target_size)
amrex::BoxArray	ERFPostProcessBaseGrids (const amrex::Box &domain, bool decompose_in_z)
void	cons_to_prim (const amrex::MultiFab &cons_state, amrex::MultiFab &S_prim, int ng)
void	fill_wall_dist_ghost_cells (amrex::MultiFab &wdist, const amrex::Geometry &geom)
void	make_qt (const amrex::MultiFab &cons_state, amrex::MultiFab &qt, int n_qstate_into_total)
void	make_J (const amrex::Geometry &geom, amrex::MultiFab &z_phys_nd, amrex::MultiFab &detJ_cc)
void	make_areas (const amrex::Geometry &geom, amrex::MultiFab &z_phys_nd, amrex::MultiFab &ax, amrex::MultiFab &ay, amrex::MultiFab &az)
void	make_zcc (const amrex::Geometry &geom, amrex::MultiFab &z_phys_nd, amrex::MultiFab &z_phys_cc)
void	MomentumToVelocity (amrex::MultiFab &xvel_out, amrex::MultiFab &yvel_out, amrex::MultiFab &zvel_out, const amrex::MultiFab &cons_in, const amrex::MultiFab &xmom_in, const amrex::MultiFab &ymom_in, const amrex::MultiFab &zmom_in, const amrex::Box &domain, const amrex::Vector< amrex::BCRec > &domain_bcs_type_h, const amrex::MultiFab *c_vfrac=nullptr)
void	VelocityToMomentum (const amrex::MultiFab &xvel_in, const amrex::IntVect &xvel_ngrow, const amrex::MultiFab &yvel_in, const amrex::IntVect &yvel_ngrow, const amrex::MultiFab &zvel_in, const amrex::IntVect &zvel_ngrow, const amrex::MultiFab &cons_in, amrex::MultiFab &xmom_out, amrex::MultiFab &ymom_out, amrex::MultiFab &zmom_out, const amrex::Box &domain, const amrex::Vector< amrex::BCRec > &domain_bcs_type_h, const amrex::MultiFab *c_vfrac=nullptr)
void	ConvertForProjection (const amrex::MultiFab &den_div, const amrex::MultiFab &den_mlt, amrex::MultiFab &xmom, amrex::MultiFab &ymom, amrex::MultiFab &zmom, const amrex::Box &domain, const amrex::Vector< amrex::BCRec > &domain_bcs_type_h)
void	compute_influx_outflux_bdy (amrex::FArrayBox &bdy_data_xlo, amrex::FArrayBox &bdy_data_xhi, amrex::FArrayBox &bdy_data_ylo, amrex::FArrayBox &bdy_data_yhi, amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &area_vec, const amrex::Geometry &geom, amrex::Real &influx, amrex::Real &outflux, const int n)
void	enforceInOutSolvability_bdy (const amrex::MultiFab &rho0, amrex::FArrayBox &bdy_data_xlo, amrex::FArrayBox &bdy_data_xhi, amrex::FArrayBox &bdy_data_ylo, amrex::FArrayBox &bdy_data_yhi, amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &area_vec, const amrex::Geometry &geom, const amrex::Vector< amrex::BCRec > &domain_bcs_type_h)
void	enforceInOutSolvability (int lev, amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &vels_vec, amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &area_vec, const amrex::Geometry &geom)
void	realbdy_interior_bxs_xy (const amrex::Box &bx, const amrex::Box &domain, const int &width, amrex::Box &bx_xlo, amrex::Box &bx_xhi, amrex::Box &bx_ylo, amrex::Box &bx_yhi, const amrex::IntVect &ng_vect=amrex::IntVect(0, 0, 0), const bool get_int_ng=false)
void	realbdy_bc_bxs_xy (const amrex::Box &bx, const amrex::Box &domain, const int &set_width, amrex::Box &bx_xlo, amrex::Box &bx_xhi, amrex::Box &bx_ylo, amrex::Box &bx_yhi, const amrex::IntVect &ng_vect=amrex::IntVect(0, 0, 0))
void	realbdy_compute_interior_ghost_rhs (const double &total_time, const double &delta_t, const double &start_bdy_time, const double &final_bdy_time, const double &bdy_time_interval, const amrex::Real &nudge_factor, int width, const amrex::Geometry &geom, amrex::Vector< amrex::MultiFab > &S_rhs, amrex::Vector< amrex::MultiFab > &S_cur_data, amrex::Vector< amrex::Vector< amrex::FArrayBox >> &bdy_data_xlo, amrex::Vector< amrex::Vector< amrex::FArrayBox >> &bdy_data_xhi, amrex::Vector< amrex::Vector< amrex::FArrayBox >> &bdy_data_ylo, amrex::Vector< amrex::Vector< amrex::FArrayBox >> &bdy_data_yhi, std::unique_ptr< ReadBndryPlanes > &m_r2d, const amrex::Real &c_p, const amrex::Real &rdOcp, const bool use_wrf_bdy_density, const amrex::Real &bdy_rho_nudge_factor)
void	fine_compute_interior_ghost_rhs (const double &time, const double &delta_t, const int &width, const int &set_width, const amrex::Geometry &geom, ERFFillPatcher *FPr_c, ERFFillPatcher *FPr_u, ERFFillPatcher *FPr_v, ERFFillPatcher *FPr_w, amrex::Vector< amrex::BCRec > &domain_bcs_type, amrex::Vector< amrex::MultiFab > &S_rhs_f, amrex::Vector< amrex::MultiFab > &S_data_f)
void	Time_Avg_Vel_atCC (double dt, double &t_avg_cnt, amrex::MultiFab *vel_t_avg, amrex::MultiFab &xvel, amrex::MultiFab &yvel, amrex::MultiFab &zvel)
void	Accumulate_Interval_Means (double dt, double &t_mean_cnt, amrex::MultiFab *interval_means, amrex::MultiFab &xvel, amrex::MultiFab &yvel, amrex::MultiFab &zvel, amrex::MultiFab &cons)
AMREX_GPU_HOST AMREX_FORCE_INLINE void	realbdy_compute_relaxation (const int &icomp, const int &num_var, const int &width, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &dx, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &ProbLo, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &ProbHi, const amrex::Real &F1, const amrex::Box &bx_xlo, const amrex::Box &bx_xhi, const amrex::Box &bx_ylo, const amrex::Box &bx_yhi, const amrex::Array4< const amrex::Real > &arr_xlo, const amrex::Array4< const amrex::Real > &arr_xhi, const amrex::Array4< const amrex::Real > &arr_ylo, const amrex::Array4< const amrex::Real > &arr_yhi, const amrex::Array4< const amrex::Real > &data_arr, const amrex::Array4< amrex::Real > &rhs_arr, const amrex::Real &c_p, const amrex::Real &rdOcp, const int bdy_moist_nudge_type=0)
AMREX_GPU_HOST AMREX_FORCE_INLINE void	realbdy_compute_moisture_relaxation (const amrex::GpuArray< int, 6 > &moisture_comps, const int n_targets, const int &width, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &dx, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &ProbLo, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &ProbHi, const amrex::Real &F1, const amrex::Box &bx_xlo, const amrex::Box &bx_xhi, const amrex::Box &bx_ylo, const amrex::Box &bx_yhi, const amrex::Array4< const amrex::Real > &arr_xlo, const amrex::Array4< const amrex::Real > &arr_xhi, const amrex::Array4< const amrex::Real > &arr_ylo, const amrex::Array4< const amrex::Real > &arr_yhi, const amrex::Array4< const amrex::Real > &data_arr, const amrex::Array4< amrex::Real > &rhs_arr)
AMREX_GPU_HOST AMREX_FORCE_INLINE void	realbdy_compute_moisture_relaxation (const amrex::GpuArray< int, 3 > &moisture_comps, const int &width, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &dx, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &ProbLo, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &ProbHi, const amrex::Real &F1, const amrex::Box &bx_xlo, const amrex::Box &bx_xhi, const amrex::Box &bx_ylo, const amrex::Box &bx_yhi, const amrex::Array4< const amrex::Real > &arr_xlo, const amrex::Array4< const amrex::Real > &arr_xhi, const amrex::Array4< const amrex::Real > &arr_ylo, const amrex::Array4< const amrex::Real > &arr_yhi, const amrex::Array4< const amrex::Real > &data_arr, const amrex::Array4< amrex::Real > &rhs_arr)
AMREX_GPU_HOST AMREX_FORCE_INLINE void	ApplyMask (amrex::MultiFab &dst, const amrex::iMultiFab &imask, const int nghost=0)
AMREX_GPU_HOST AMREX_FORCE_INLINE void	ApplyInvertedMask (amrex::MultiFab &dst, const amrex::iMultiFab &imask, const int nghost=0)
void	thinbody_wall_dist (std::unique_ptr< amrex::MultiFab > &wdist, amrex::Vector< amrex::IntVect > &xfaces, amrex::Vector< amrex::IntVect > &yfaces, amrex::Vector< amrex::IntVect > &zfaces, const amrex::Geometry &geomdata, std::unique_ptr< amrex::MultiFab > &z_phys_cc)
void	WeatherDataInterpolation (const double time)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	quad_interp_1d (amrex::Real z, amrex::Real z0, amrex::Real p0, amrex::Real z1, amrex::Real p1, amrex::Real z2, amrex::Real p2)

Function Documentation

Accumulate_Interval_Means()

void Accumulate_Interval_Means	(	double	dt,
		double &	t_mean_cnt,
		amrex::MultiFab *	interval_means,
		amrex::MultiFab &	xvel,
		amrex::MultiFab &	yvel,
		amrex::MultiFab &	zvel,
		amrex::MultiFab &	cons
	)

Accumulate time-weighted cell-centered velocity/theta first and second moments.

Parameters

[in]	dt	accumulation interval
[in,out]	t_mean_cnt	accumulated time
[in,out]	interval_means	ten-component moment storage
[in]	xvel	x-face velocity
[in]	yvel	y-face velocity
[in]	zvel	z-face velocity
[in]	cons	conserved cell-centered state

ApplyInvertedMask()

AMREX_GPU_HOST AMREX_FORCE_INLINE void ApplyInvertedMask	(	amrex::MultiFab &	dst,
		const amrex::iMultiFab &	imask,
		const int	nghost = 0
	)

Multiply a MultiFab by the inverse of an integer mask.

Parameters

[in,out]	dst	MultiFab to be masked.
[in]	imask	Integer mask MultiFab.
[in]	nghost	Number of ghost cells to include.

{
    for (amrex::MFIter mfi(dst,amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        const amrex::Box& bx = mfi.growntilebox(nghost);
        if (bx.ok())
        {
            auto        dstFab = dst.array(mfi);
            const auto maskFab = imask.const_array(mfi);
            ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
            {
                dstFab(i,j,k) *= (1-maskFab(i,j,k));
            });
        }
    }
}

Referenced by add_thin_body_sources(), and ERF::project_velocity_tb().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyMask()

AMREX_GPU_HOST AMREX_FORCE_INLINE void ApplyMask	(	amrex::MultiFab &	dst,
		const amrex::iMultiFab &	imask,
		const int	nghost = 0
	)

{
    for (amrex::MFIter mfi(dst,amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        const amrex::Box& bx = mfi.growntilebox(nghost);
        if (bx.ok())
        {
            auto        dstFab = dst.array(mfi);
            const auto maskFab = imask.const_array(mfi);
            ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
            {
                dstFab(i,j,k) *= maskFab(i,j,k);
            });
        }
    }
}

Referenced by ERF::FillIntermediatePatch(), and ERF::project_velocity_tb().

Here is the call graph for this function:

Here is the caller graph for this function:

ChopGrids2D()

void ChopGrids2D	(	amrex::BoxArray &	ba,
		const amrex::Box &	domain,
		int	target_size
	)

compute_influx_outflux_bdy()

void compute_influx_outflux_bdy	(	amrex::FArrayBox &	bdy_data_xlo,
		amrex::FArrayBox &	bdy_data_xhi,
		amrex::FArrayBox &	bdy_data_ylo,
		amrex::FArrayBox &	bdy_data_yhi,
		amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &	area_vec,
		const amrex::Geometry &	geom,
		amrex::Real &	influx,
		amrex::Real &	outflux,
		const int	n
	)

cons_to_prim()

void cons_to_prim	(	const amrex::MultiFab &	cons_state,
		amrex::MultiFab &	S_prim,
		int	ng
	)

Convert conservative state to primitive variables.

Parameters

[in]	cons_state	Conservative state MultiFab.
[out]	S_prim	Primitive state MultiFab.
[in]	ng	Number of ghost cells.

ConvertForProjection()

void ConvertForProjection	(	const amrex::MultiFab &	den_div,
		const amrex::MultiFab &	den_mlt,
		amrex::MultiFab &	xmom,
		amrex::MultiFab &	ymom,
		amrex::MultiFab &	zmom,
		const amrex::Box &	domain,
		const amrex::Vector< amrex::BCRec > &	domain_bcs_type_h
	)

enforceInOutSolvability()

void enforceInOutSolvability	(	int	lev,
		amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &	vels_vec,
		amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &	area_vec,
		const amrex::Geometry &	geom
	)

enforceInOutSolvability_bdy()

void enforceInOutSolvability_bdy	(	const amrex::MultiFab &	rho0,
		amrex::FArrayBox &	bdy_data_xlo,
		amrex::FArrayBox &	bdy_data_xhi,
		amrex::FArrayBox &	bdy_data_ylo,
		amrex::FArrayBox &	bdy_data_yhi,
		amrex::Array< amrex::MultiFab *, AMREX_SPACEDIM > &	area_vec,
		const amrex::Geometry &	geom,
		const amrex::Vector< amrex::BCRec > &	domain_bcs_type_h
	)

ERFPostProcessBaseGrids()

amrex::BoxArray ERFPostProcessBaseGrids	(	const amrex::Box &	domain,
		bool	decompose_in_z
	)

fill_wall_dist_ghost_cells()

void fill_wall_dist_ghost_cells	(	amrex::MultiFab &	wdist,
		const amrex::Geometry &	geom
	)

Fill the ghost cells of the wall distance field, which is only computed on the valid region, so that operators reading from grown boxes do not see the sentinel value used to initialize it.

Parameters

[in,out]	wdist	MultiFab holding the wall distance.
[in]	geom	Geometry at this level.

fine_compute_interior_ghost_rhs()

void fine_compute_interior_ghost_rhs	(	const double &	time,
		const double &	delta_t,
		const int &	width,
		const int &	set_width,
		const amrex::Geometry &	geom,
		ERFFillPatcher *	FPr_c,
		ERFFillPatcher *	FPr_u,
		ERFFillPatcher *	FPr_v,
		ERFFillPatcher *	FPr_w,
		amrex::Vector< amrex::BCRec > &	domain_bcs_type,
		amrex::Vector< amrex::MultiFab > &	S_rhs_f,
		amrex::Vector< amrex::MultiFab > &	S_data_f
	)

make_areas()

void make_areas	(	const amrex::Geometry &	geom,
		amrex::MultiFab &	z_phys_nd,
		amrex::MultiFab &	ax,
		amrex::MultiFab &	ay,
		amrex::MultiFab &	az
	)

make_J()

void make_J	(	const amrex::Geometry &	geom,
		amrex::MultiFab &	z_phys_nd,
		amrex::MultiFab &	detJ_cc
	)

make_qt()

void make_qt	(	const amrex::MultiFab &	cons_state,
		amrex::MultiFab &	qt,
		int	n_qstate_into_total
	)

Compute total water mixing ratio from conservative state.

Parameters

[in]	cons_state	Conservative state MultiFab.
[out]	qt	MultiFab to store total water.
[in]	n_qstate_into_total	Number of components to include in total water.

make_zcc()

void make_zcc	(	const amrex::Geometry &	geom,
		amrex::MultiFab &	z_phys_nd,
		amrex::MultiFab &	z_phys_cc
	)

MomentumToVelocity()

void MomentumToVelocity	(	amrex::MultiFab &	xvel_out,
		amrex::MultiFab &	yvel_out,
		amrex::MultiFab &	zvel_out,
		const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	xmom_in,
		const amrex::MultiFab &	ymom_in,
		const amrex::MultiFab &	zmom_in,
		const amrex::Box &	domain,
		const amrex::Vector< amrex::BCRec > &	domain_bcs_type_h,
		const amrex::MultiFab *	c_vfrac = nullptr
	)

quad_interp_1d()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real quad_interp_1d	(	amrex::Real	z,
		amrex::Real	z0,
		amrex::Real	p0,
		amrex::Real	z1,
		amrex::Real	p1,
		amrex::Real	z2,
		amrex::Real	p2
	)

Perform quadratic interpolation in one dimension.

Parameters

[in]	z	Interpolation coordinate.
[in]	z0	Coordinate of first point.
[in]	p0	Value at first point.
[in]	z1	Coordinate of second point.
[in]	p1	Value at second point.
[in]	z2	Coordinate of third point.
[in]	p2	Value at third point.

Returns

Interpolated value.

{
    return p0 * ( (z - z1) * (z - z2) ) / ( (z0 - z1) * (z0 - z2) )
         + p1 * ( (z - z0) * (z - z2) ) / ( (z1 - z0) * (z1 - z2) )
         + p2 * ( (z - z0) * (z - z1) ) / ( (z2 - z0) * (z2 - z1) );
}

Referenced by compute_gradp_interpz().

Here is the caller graph for this function:

realbdy_bc_bxs_xy()

void realbdy_bc_bxs_xy	(	const amrex::Box &	bx,
		const amrex::Box &	domain,
		const int &	set_width,
		amrex::Box &	bx_xlo,
		amrex::Box &	bx_xhi,
		amrex::Box &	bx_ylo,
		amrex::Box &	bx_yhi,
		const amrex::IntVect &	ng_vect = amrex::IntVect(0, 0, 0)
	)

realbdy_compute_interior_ghost_rhs()

void realbdy_compute_interior_ghost_rhs	(	const double &	total_time,
		const double &	delta_t,
		const double &	start_bdy_time,
		const double &	final_bdy_time,
		const double &	bdy_time_interval,
		const amrex::Real &	nudge_factor,
		int	width,
		const amrex::Geometry &	geom,
		amrex::Vector< amrex::MultiFab > &	S_rhs,
		amrex::Vector< amrex::MultiFab > &	S_cur_data,
		amrex::Vector< amrex::Vector< amrex::FArrayBox >> &	bdy_data_xlo,
		amrex::Vector< amrex::Vector< amrex::FArrayBox >> &	bdy_data_xhi,
		amrex::Vector< amrex::Vector< amrex::FArrayBox >> &	bdy_data_ylo,
		amrex::Vector< amrex::Vector< amrex::FArrayBox >> &	bdy_data_yhi,
		std::unique_ptr< ReadBndryPlanes > &	m_r2d,
		const amrex::Real &	c_p,
		const amrex::Real &	rdOcp,
		const bool	use_wrf_bdy_density,
		const amrex::Real &	bdy_rho_nudge_factor
	)

realbdy_compute_moisture_relaxation() [1/2]

AMREX_GPU_HOST AMREX_FORCE_INLINE void realbdy_compute_moisture_relaxation	(	const amrex::GpuArray< int, 3 > &	moisture_comps,
		const int &	width,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	dx,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	ProbLo,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	ProbHi,
		const amrex::Real &	F1,
		const amrex::Box &	bx_xlo,
		const amrex::Box &	bx_xhi,
		const amrex::Box &	bx_ylo,
		const amrex::Box &	bx_yhi,
		const amrex::Array4< const amrex::Real > &	arr_xlo,
		const amrex::Array4< const amrex::Real > &	arr_xhi,
		const amrex::Array4< const amrex::Real > &	arr_ylo,
		const amrex::Array4< const amrex::Real > &	arr_yhi,
		const amrex::Array4< const amrex::Real > &	data_arr,
		const amrex::Array4< amrex::Real > &	rhs_arr
	)

{
    const amrex::GpuArray<int,6> extended_comps = {
        moisture_comps[0], moisture_comps[1], moisture_comps[2], -1, -1, -1};
    realbdy_compute_moisture_relaxation(
        extended_comps, 3, width, dx, ProbLo, ProbHi, F1,
        bx_xlo, bx_xhi, bx_ylo, bx_yhi,
        arr_xlo, arr_xhi, arr_ylo, arr_yhi, data_arr, rhs_arr);
}

Here is the call graph for this function:

realbdy_compute_moisture_relaxation() [2/2]

AMREX_GPU_HOST AMREX_FORCE_INLINE void realbdy_compute_moisture_relaxation	(	const amrex::GpuArray< int, 6 > &	moisture_comps,
		const int	n_targets,
		const int &	width,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	dx,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	ProbLo,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	ProbHi,
		const amrex::Real &	F1,
		const amrex::Box &	bx_xlo,
		const amrex::Box &	bx_xhi,
		const amrex::Box &	bx_ylo,
		const amrex::Box &	bx_yhi,
		const amrex::Array4< const amrex::Real > &	arr_xlo,
		const amrex::Array4< const amrex::Real > &	arr_xhi,
		const amrex::Array4< const amrex::Real > &	arr_ylo,
		const amrex::Array4< const amrex::Real > &	arr_yhi,
		const amrex::Array4< const amrex::Real > &	data_arr,
		const amrex::Array4< amrex::Real > &	rhs_arr
	)

Apply Davies relaxation to explicitly mapped moisture components. Target component n corresponds to state component moisture_comps[n].

{
    const amrex::IntVect iv = bx_xlo.type();
    const amrex::Real ioff = (iv[0] == 1) ? zero : myhalf;
    const amrex::Real joff = (iv[1] == 1) ? zero : myhalf;
 
    amrex::ParallelFor(bx_xlo, bx_xhi,
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        const amrex::Real x = ProbLo[0] + (i + ioff) * dx[0];
        const amrex::Real y = ProbLo[1] + (j + joff) * dx[1];
        const amrex::Real x_end = ProbLo[0] + width * dx[0];
        const amrex::Real y_end = ProbLo[1] + width * dx[1];
        const amrex::Real y_strt = ProbHi[1] - width * dx[1];
        const amrex::Real xi = (x_end - x) / (x_end - ProbLo[0]);
        const amrex::Real eta_lo = (y < y_end) ? (y_end - y) / (y_end - ProbLo[1]) : amrex::Real(0.0);
        const amrex::Real eta_hi = (y > y_strt) ? (y - y_strt) / (ProbHi[1] - y_strt) : amrex::Real(0.0);
        const amrex::Real factor = amrex::max(xi*xi, amrex::max(eta_lo,eta_hi)*amrex::max(eta_lo,eta_hi)) * F1;
        for (int n = 0; n < n_targets; ++n) {
            const int comp = moisture_comps[n];
            if (comp >= 0) {
                rhs_arr(i,j,k,comp) += factor * (arr_xlo(i,j,k,n) - data_arr(i,j,k,comp));
            }
        }
    },
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        const amrex::Real x = ProbLo[0] + (i + ioff) * dx[0];
        const amrex::Real y = ProbLo[1] + (j + joff) * dx[1];
        const amrex::Real x_strt = ProbHi[0] - width * dx[0];
        const amrex::Real y_end = ProbLo[1] + width * dx[1];
        const amrex::Real y_strt = ProbHi[1] - width * dx[1];
        const amrex::Real xi = (x - x_strt) / (ProbHi[0] - x_strt);
        const amrex::Real eta_lo = (y < y_end) ? (y_end - y) / (y_end - ProbLo[1]) : amrex::Real(0.0);
        const amrex::Real eta_hi = (y > y_strt) ? (y - y_strt) / (ProbHi[1] - y_strt) : amrex::Real(0.0);
        const amrex::Real eta = amrex::max(eta_lo,eta_hi);
        const amrex::Real factor = amrex::max(xi*xi, eta*eta) * F1;
        for (int n = 0; n < n_targets; ++n) {
            const int comp = moisture_comps[n];
            if (comp >= 0) {
                rhs_arr(i,j,k,comp) += factor * (arr_xhi(i,j,k,n) - data_arr(i,j,k,comp));
            }
        }
    });
 
    amrex::ParallelFor(bx_ylo, bx_yhi,
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        const amrex::Real y = ProbLo[1] + (j + joff) * dx[1];
        const amrex::Real y_end = ProbLo[1] + width * dx[1];
        const amrex::Real eta = (y_end - y) / (y_end - ProbLo[1]);
        const amrex::Real factor = eta*eta * F1;
        for (int n = 0; n < n_targets; ++n) {
            const int comp = moisture_comps[n];
            if (comp >= 0) {
                rhs_arr(i,j,k,comp) += factor * (arr_ylo(i,j,k,n) - data_arr(i,j,k,comp));
            }
        }
    },
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        const amrex::Real y = ProbLo[1] + (j + joff) * dx[1];
        const amrex::Real y_strt = ProbHi[1] - width * dx[1];
        const amrex::Real eta = (y - y_strt) / (ProbHi[1] - y_strt);
        const amrex::Real factor = eta*eta * F1;
        for (int n = 0; n < n_targets; ++n) {
            const int comp = moisture_comps[n];
            if (comp >= 0) {
                rhs_arr(i,j,k,comp) += factor * (arr_yhi(i,j,k,n) - data_arr(i,j,k,comp));
            }
        }
    });
}

Referenced by realbdy_compute_moisture_relaxation().

Here is the call graph for this function:

Here is the caller graph for this function:

realbdy_compute_relaxation()

AMREX_GPU_HOST AMREX_FORCE_INLINE void realbdy_compute_relaxation	(	const int &	icomp,
		const int &	num_var,
		const int &	width,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	dx,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	ProbLo,
		const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &	ProbHi,
		const amrex::Real &	F1,
		const amrex::Box &	bx_xlo,
		const amrex::Box &	bx_xhi,
		const amrex::Box &	bx_ylo,
		const amrex::Box &	bx_yhi,
		const amrex::Array4< const amrex::Real > &	arr_xlo,
		const amrex::Array4< const amrex::Real > &	arr_xhi,
		const amrex::Array4< const amrex::Real > &	arr_ylo,
		const amrex::Array4< const amrex::Real > &	arr_yhi,
		const amrex::Array4< const amrex::Real > &	data_arr,
		const amrex::Array4< amrex::Real > &	rhs_arr,
		const amrex::Real &	c_p,
		const amrex::Real &	rdOcp,
		const int	bdy_moist_nudge_type = 0
	)

Compute the nudging relaxation

Parameters

[in]	delta_t	time step
[in]	icomp	component offset
[in]	num_var	number of variables to loop
[in]	width	width of wrf bdy file
[in]	dom_lo	low bound of domain
[in]	dom_hi	high bound of domain
[in]	F1	drift relaxation parameter
[in]	bx_xlo	box for low x relaxation
[in]	bx_xhi	box for high x relaxation
[in]	bx_ylo	box for low y relaxation
[in]	bx_yhi	box for high y relaxation
[in]	arr_xlo	array for low x relaxation
[in]	arr_xhi	array for high x relaxation
[in]	arr_ylo	array for low y relaxation
[in]	arr_yhi	array for high y relaxation
[in]	data_arr	data array
[out]	rhs_arr	RHS array

{
    amrex::IntVect iv = bx_xlo.type();
    amrex::Real ioff  = (iv[0]==1) ? zero : myhalf;
    amrex::Real joff  = (iv[1]==1) ? zero : myhalf;
 
    // These are defined in ERF_Constants.H
    amrex::Real l_rdOcp  = rdOcp;
    amrex::Real cond_fac = lcond / c_p; // condensation
    amrex::Real  sub_fac = lsub  / c_p;  // sublimation
 
    int nq = num_var;
 
    amrex::ParallelFor( bx_xlo, bx_xhi,
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        // Corners with x boxes
        amrex::Real x = ProbLo[0] + (i + ioff) * dx[0];
        amrex::Real y = ProbLo[1] + (j + joff) * dx[1];
        amrex::Real x_end  = ProbLo[0] + width * dx[0];
        amrex::Real y_end  = ProbLo[1] + width * dx[1];
        amrex::Real y_strt = ProbHi[1] - width * dx[1];
        amrex::Real xi     = (x_end - x) / (x_end - ProbLo[0]);
        amrex::Real eta_lo = (y < y_end ) ? (y_end  - y) / (y_end  - ProbLo[1]) : zero;
        amrex::Real eta_hi = (y > y_strt) ? (y - y_strt) / (ProbHi[1] - y_strt) : zero;
        amrex::Real eta    = std::max(eta_lo,eta_hi);
        amrex::Real Factor = std::max(xi*xi,eta*eta) * F1;
 
        if (icomp == RhoQ1_comp)
        {
            amrex::Real exner_pi = getExnergivenRTh(data_arr(i,j,k,RhoTheta_comp),l_rdOcp,
                                                    data_arr(i,j,k,RhoQ1_comp)/data_arr(i,j,k,Rho_comp));
 
            // qv
            amrex::Real delta = arr_xlo(i,j,k,0) - data_arr(i,j,k,icomp);
            rhs_arr(i,j,k,icomp) += Factor*delta;
 
            if (bdy_moist_nudge_type==2) {
                // NOTE: we only operate on qv (above), qc and qi here; the
                //       precipitating species (qr/qs/qg) are left untouched.
 
                // qc and heat source term due to evaporation
                delta = -data_arr(i,j,k,RhoQ2_comp); // This effectively nudges to 0
                rhs_arr(i,j,k,RhoQ2_comp   ) += Factor * delta;
                rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * cond_fac / exner_pi;
 
                // qi and heat source term due to sublimation
                if (nq > 3) { // nq > 3 guarantees that RhoQ3 is ice
                    delta = -data_arr(i,j,k,RhoQ3_comp); // This effectively nudges to 0
                    rhs_arr(i,j,k,RhoQ3_comp   ) += Factor * delta;
                    rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * sub_fac / exner_pi;
                }
            } // moist_nudge_type
        } else {
            for (int n = 0; n < nq; n++) {
                amrex::Real delta = arr_xlo(i,j,k,n) - data_arr(i,j,k,n+icomp);
                rhs_arr(i,j,k,n+icomp) += Factor*delta;
            }
        }
    },
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        // Corners with x boxes
        amrex::Real x = ProbLo[0] + (i + ioff) * dx[0];
        amrex::Real y = ProbLo[1] + (j + joff) * dx[1];
        amrex::Real x_strt = ProbHi[0] - width * dx[0];
        amrex::Real y_strt = ProbHi[1] - width * dx[1];
        amrex::Real y_end  = ProbLo[1] + width * dx[1];
        amrex::Real xi     = (x - x_strt) / (ProbHi[0] - x_strt);
        amrex::Real eta_lo = (y < y_end ) ? (y_end  - y) / (y_end  - ProbLo[1]) : zero;
        amrex::Real eta_hi = (y > y_strt) ? (y - y_strt) / (ProbHi[1] - y_strt) : zero;
        amrex::Real eta    = std::max(eta_lo,eta_hi);
        amrex::Real Factor = std::max(xi*xi,eta*eta) * F1;
 
        if (icomp == RhoQ1_comp)
        {
            amrex::Real exner_pi = getExnergivenRTh(data_arr(i,j,k,RhoTheta_comp),l_rdOcp,
                                                    data_arr(i,j,k,RhoQ1_comp)/data_arr(i,j,k,Rho_comp));
 
            // qv
            amrex::Real delta = arr_xhi(i,j,k,0) - data_arr(i,j,k,icomp);
            rhs_arr(i,j,k,icomp) += Factor*delta;
 
            if (bdy_moist_nudge_type==2) {
                // NOTE: we only operate on qv (above), qc and qi here; the
                //       precipitating species (qr/qs/qg) are left untouched.
 
                // qc and heat source term due to evaporation
                delta = -data_arr(i,j,k,RhoQ2_comp); // This effectively nudges to 0
                rhs_arr(i,j,k,RhoQ2_comp   ) += Factor*delta;
                rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * cond_fac / exner_pi;
 
                // qi and heat source term due to sublimation
                if (nq > 3) { // nq > 3 guarantees that RhoQ3 is ice
                    delta = -data_arr(i,j,k,RhoQ3_comp); // This effectively nudges to 0
                    rhs_arr(i,j,k,RhoQ3_comp   ) += Factor * delta;
                    rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * sub_fac / exner_pi;
                }
            } // moist_nudge_type
        } else {
            for (int n = 0; n < nq; n++) {
                amrex::Real delta = arr_xhi(i,j,k,n) - data_arr(i,j,k,n+icomp);
                rhs_arr(i,j,k,n+icomp) += Factor*delta;
            }
        }
    });
 
    amrex::ParallelFor( bx_ylo, bx_yhi,
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        // No corners for y boxes
        amrex::Real y      = ProbLo[1] + (j + joff) * dx[1];
        amrex::Real y_end  = ProbLo[1] + width * dx[1];
        amrex::Real eta    = (y_end - y) / (y_end - ProbLo[1]);
        amrex::Real Factor = eta*eta * F1;
 
        if (icomp == RhoQ1_comp)
        {
            amrex::Real exner_pi = getExnergivenRTh(data_arr(i,j,k,RhoTheta_comp),l_rdOcp,
                                                    data_arr(i,j,k,RhoQ1_comp)/data_arr(i,j,k,Rho_comp));
            // qv
            amrex::Real delta = arr_ylo(i,j,k,0) - data_arr(i,j,k,icomp);
            rhs_arr(i,j,k,icomp) += Factor*delta;
 
            if (bdy_moist_nudge_type==2) {
                // NOTE: we only operate on qv (above), qc and qi here; the
                //       precipitating species (qr/qs/qg) are left untouched.
 
                // qc and heat source term due to evaporation
                delta = -data_arr(i,j,k,RhoQ2_comp); // This effectively nudges to 0
                rhs_arr(i,j,k,RhoQ2_comp   ) += Factor*delta;
                rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * cond_fac / exner_pi;
 
                // qi and heat source term due to sublimation
                if (nq > 3) { // nq > 3 guarantees that RhoQ3 is ice
                    delta = -data_arr(i,j,k,RhoQ3_comp); // This effectively nudges to 0
                    rhs_arr(i,j,k,RhoQ3_comp   ) += Factor * delta;
                    rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * sub_fac / exner_pi;
                }
            } // moist_nudge_type
        } else {
            for (int n = 0; n < nq; n++) {
                amrex::Real delta = arr_ylo(i,j,k,n) - data_arr(i,j,k,n+icomp);
                rhs_arr(i,j,k,n+icomp) += Factor*delta;
            }
        }
    },
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
    {
        // No corners for y boxes
        amrex::Real y      = ProbLo[1] + (j + joff) * dx[1];
        amrex::Real y_strt = ProbHi[1] - width * dx[1];
        amrex::Real eta    = (y - y_strt) / (ProbHi[1] - y_strt);
        amrex::Real Factor = eta*eta * F1;
 
        if (icomp == RhoQ1_comp)
        {
            amrex::Real exner_pi = getExnergivenRTh(data_arr(i,j,k,RhoTheta_comp),l_rdOcp,
                                                    data_arr(i,j,k,RhoQ1_comp)/data_arr(i,j,k,Rho_comp));
            // qv
            amrex::Real delta = arr_yhi(i,j,k,0) - data_arr(i,j,k,icomp);
            rhs_arr(i,j,k,icomp) += Factor*delta;
 
            if (bdy_moist_nudge_type==2) {
                // NOTE: we only operate on qv (above), qc and qi here; the
                //       precipitating species (qr/qs/qg) are left untouched.
 
                // qc and heat source term due to evaporation
                delta = -data_arr(i,j,k,RhoQ2_comp); // This effectively nudges to 0
                rhs_arr(i,j,k,RhoQ2_comp   ) += Factor * delta;
                rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * cond_fac / exner_pi;
 
                // qi and heat source term due to sublimation
                if (nq > 3) { // nq > 3 guarantees that RhoQ3 is ice
                    delta = -data_arr(i,j,k,RhoQ3_comp); // This effectively nudges to 0
                    rhs_arr(i,j,k,RhoQ3_comp   ) += Factor * delta;
                    rhs_arr(i,j,k,RhoTheta_comp) += Factor * delta * sub_fac / exner_pi;
                }
            } // moist_nudge_type
        } else {
            for (int n = 0; n < nq; n++) {
                amrex::Real delta = arr_yhi(i,j,k,n) - data_arr(i,j,k,n+icomp);
                rhs_arr(i,j,k,n+icomp) += Factor*delta;
            }
        }
    });
}

Referenced by realbdy_compute_interior_ghost_rhs().

Here is the call graph for this function:

Here is the caller graph for this function:

realbdy_interior_bxs_xy()

void realbdy_interior_bxs_xy	(	const amrex::Box &	bx,
		const amrex::Box &	domain,
		const int &	width,
		amrex::Box &	bx_xlo,
		amrex::Box &	bx_xhi,
		amrex::Box &	bx_ylo,
		amrex::Box &	bx_yhi,
		const amrex::IntVect &	ng_vect = amrex::IntVect(0, 0, 0),
		const bool	get_int_ng = false
	)

rebalance_columns()

void rebalance_columns	(	amrex::MultiFab &	rho,
		amrex::MultiFab &	theta,
		const amrex::MultiFab &	qt,
		const amrex::MultiFab &	qv,
		const amrex::MultiFab *	z_phys,
		const amrex::Geometry &	geom,
		const bool &	maintain_Th,
		bool	use_sfc = false
	)

thinbody_wall_dist()

void thinbody_wall_dist	(	std::unique_ptr< amrex::MultiFab > &	wdist,
		amrex::Vector< amrex::IntVect > &	xfaces,
		amrex::Vector< amrex::IntVect > &	yfaces,
		amrex::Vector< amrex::IntVect > &	zfaces,
		const amrex::Geometry &	geomdata,
		std::unique_ptr< amrex::MultiFab > &	z_phys_cc
	)

Compute the distance to thin-body walls.

Parameters

[out]	wdist	MultiFab to store wall distances.
[in]	xfaces	Indices of x-faces forming walls.
[in]	yfaces	Indices of y-faces forming walls.
[in]	zfaces	Indices of z-faces forming walls.
[in]	geomdata	Geometry used for physical distance.
[in]	z_phys_cc	Cell-centered physical height.

Time_Avg_Vel_atCC()

void Time_Avg_Vel_atCC	(	double	dt,
		double &	t_avg_cnt,
		amrex::MultiFab *	vel_t_avg,
		amrex::MultiFab &	xvel,
		amrex::MultiFab &	yvel,
		amrex::MultiFab &	zvel
	)

VelocityToMomentum()

void VelocityToMomentum	(	const amrex::MultiFab &	xvel_in,
		const amrex::IntVect &	xvel_ngrow,
		const amrex::MultiFab &	yvel_in,
		const amrex::IntVect &	yvel_ngrow,
		const amrex::MultiFab &	zvel_in,
		const amrex::IntVect &	zvel_ngrow,
		const amrex::MultiFab &	cons_in,
		amrex::MultiFab &	xmom_out,
		amrex::MultiFab &	ymom_out,
		amrex::MultiFab &	zmom_out,
		const amrex::Box &	domain,
		const amrex::Vector< amrex::BCRec > &	domain_bcs_type_h,
		const amrex::MultiFab *	c_vfrac = nullptr
	)

Referenced by ERF::Advance(), ERF::advance_dycore(), ERF::AverageDownTo(), ERF::FillCoarsePatch(), ERF::FillIntermediatePatch(), ERF::FillPatchFineLevel(), ERF::project_initial_velocity(), and ERF::project_momenta().

Here is the caller graph for this function:

WeatherDataInterpolation()

void WeatherDataInterpolation

(

const double

time

)

Referenced by ERF::Evolve(), and ERF::init_stuff().

Here is the caller graph for this function:

wrf_bdy_has_separate_hydrometeors()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool wrf_bdy_has_separate_hydrometeors ( const MoistureComponentIndices &  moisture_indices )

noexcept

True when ERF carries all five hydrometeor mass species separately.

{
    return moisture_indices.qc >= 0 && moisture_indices.qi >= 0 &&
           moisture_indices.qr >= 0 && moisture_indices.qs >= 0 &&
           moisture_indices.qg >= 0;
}

Referenced by ERF::InitData_post(), and ERF::timeStep().

Here is the caller graph for this function:

wrf_bdy_var_for_moisture_component()

int wrf_bdy_var_for_moisture_component ( const int  comp, const MoistureComponentIndices &  moisture_indices, const bool  use_wrf_bdy_qc_qi, const bool  separate_hydrometeors = false  )

inline

Map an active conserved moisture component to its real-boundary field.

{
    if (comp == moisture_indices.qv) { return RealBdyVars::QV; }
    if (use_wrf_bdy_qc_qi) {
        if (comp == moisture_indices.qc) { return RealBdyVars::QC; }
        if (moisture_indices.qi >= 0 && comp == moisture_indices.qi) {
            return RealBdyVars::QI;
        }
        if (separate_hydrometeors) {
            if (comp == moisture_indices.qr) { return RealBdyHydrometeorVars::QR; }
            if (comp == moisture_indices.qs) { return RealBdyHydrometeorVars::QS; }
            if (comp == moisture_indices.qg) { return RealBdyHydrometeorVars::QG; }
        }
    }
    return -1;
}

wrf_moisture_target()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real wrf_moisture_target ( const amrex::Real  rho, const amrex::Real  q_n, const amrex::Real  q_np1, const amrex::Real  alpha  )

noexcept

Build one density-weighted, nonnegative WRF moisture target.

{
    const amrex::Real q = (one - alpha) * q_n + alpha * q_np1;
    return rho * amrex::max(q, amrex::Real(0.0));
}