ERF_DiffusionSrcForState_N.cpp File Reference

#include "ERF_Diffusion.H"
#include "ERF_ScalarDiffusion.H"
#include "ERF_NativeScalarDiffusion.H"
#include "ERF_EddyViscosity.H"
#include "ERF_SetupScalarDiffusion.H"

Include dependency graph for ERF_DiffusionSrcForState_N.cpp:

Functions
void	DiffusionSrcForState_N (const Box &bx, const Box &domain, int start_comp, int num_comp, const Array4< const Real > &u, const Array4< const Real > &v, const Array4< const Real > &cell_data, const Array4< const Real > &cell_prim, const Array4< Real > &cell_rhs, const Array4< Real > &xflux, const Array4< Real > &yflux, const Array4< Real > &zflux, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const Array4< const Real > &mf_mx, const Array4< const Real > &mf_ux, const Array4< const Real > &mf_vx, const Array4< const Real > &mf_my, const Array4< const Real > &mf_uy, const Array4< const Real > &mf_vy, Array4< Real > &hfx_x, Array4< Real > &hfx_y, Array4< Real > &hfx_z, Array4< Real > &qfx1_x, Array4< Real > &qfx1_y, Array4< Real > &qfx1_z, Array4< Real > &qfx2_z, const Array4< const Real > &mu_turb, const SolverChoice &solverChoice, const int level, const BCRec *bc_ptr, const bool use_SurfLayer, const Vector< std::unique_ptr< SurfaceLayer >> &SurfLayer, const Real implicit_fac, const ScalarDiffusionRefluxViews *reflux_flx, const Array4< const Real > &wall_face33, const Array4< const Real > &wall_hfx)

Function Documentation

DiffusionSrcForState_N()

void DiffusionSrcForState_N	(	const Box &	bx,
		const Box &	domain,
		int	start_comp,
		int	num_comp,
		const Array4< const Real > &	u,
		const Array4< const Real > &	v,
		const Array4< const Real > &	cell_data,
		const Array4< const Real > &	cell_prim,
		const Array4< Real > &	cell_rhs,
		const Array4< Real > &	xflux,
		const Array4< Real > &	yflux,
		const Array4< Real > &	zflux,
		const GpuArray< Real, AMREX_SPACEDIM > &	cellSizeInv,
		const Array4< const Real > &	mf_mx,
		const Array4< const Real > &	mf_ux,
		const Array4< const Real > &	mf_vx,
		const Array4< const Real > &	mf_my,
		const Array4< const Real > &	mf_uy,
		const Array4< const Real > &	mf_vy,
		Array4< Real > &	hfx_x,
		Array4< Real > &	hfx_y,
		Array4< Real > &	hfx_z,
		Array4< Real > &	qfx1_x,
		Array4< Real > &	qfx1_y,
		Array4< Real > &	qfx1_z,
		Array4< Real > &	qfx2_z,
		const Array4< const Real > &	mu_turb,
		const SolverChoice &	solverChoice,
		const int	level,
		const BCRec *	bc_ptr,
		const bool	use_SurfLayer,
		const Vector< std::unique_ptr< SurfaceLayer >> &	SurfLayer,
		const Real	implicit_fac,
		const ScalarDiffusionRefluxViews *	reflux_flx,
		const Array4< const Real > &	wall_face33,
		const Array4< const Real > &	wall_hfx
	)

Function for computing the scalar RHS for diffusion operator without terrain.

Parameters

[in]	bx	cell center box to loop over
[in]	domain	box of the whole domain
[in]	start_comp	starting component index
[in]	num_comp	number of components
[in]	u	velocity in x-dir
[in]	v	velocity in y-dir
[in]	cell_data	conserved cell center vars
[in]	cell_prim	primitive cell center vars
[out]	cell_rhs	RHS for cell center vars
[in]	xflux	flux in x-dir
[in]	yflux	flux in y-dir
[in]	zflux	flux in z-dir
[in]	cellSizeInv	inverse cell size array
[in]	mf_mx	x map factor at cell centers
[in]	mf_ux	x map factor at x-faces
[in]	mf_vx	x map factor at y-faces
[in]	mf_my	y map factor at cell centers
[in]	mf_uy	y map factor at x-faces
[in]	mf_vy	y map factor at y-faces
[in,out]	hfx_z	heat flux in z-dir
[in,out]	qfx1_z	heat flux in z-dir
[out]	qfx2_z	heat flux in z-dir
[in]	mu_turb	turbulent viscosity
[in]	solverChoice	container of solver and diffusion parameters
[in]	level	AMR level
[in]	bc_ptr	container with boundary conditions
[in]	use_SurfLayer	whether we have turned on subgrid diffusion
[in]	implicit_fac	– factor of implicitness for vertical differences only
[in]	reflux_flx	if not null, face views (indexed by state component) to which the fluxes of each component are added for refluxing

{
    BL_PROFILE_VAR("DiffusionSrcForState_N()",DiffusionSrcForState_N);
 
    const Real explicit_fac = one - implicit_fac;
 
#include "ERF_SetupScalarDiffusion.H"
 
    for (int n(0); n<num_comp; ++n) {
        const int qty_index = start_comp + n;
        const NativeScalarDiffusionPolicy native_policy =
            ResolveNativeScalarDiffusionPolicy(qty_index, diffChoice);
 
        ScalarDiffusionFieldViews field;
        field.scalar = cell_prim;
        field.scalar_comp = native_policy.scalar_comp;
        field.density = cell_data;
        field.rho_comp = Rho_comp;
        field.mu_turb = mu_turb;
        field.xflux = xflux;
        field.yflux = yflux;
        field.zflux = zflux;
        field.flux_comp = native_policy.flux_comp;
        field.rhs = cell_rhs;
        field.rhs_comp = native_policy.rhs_comp;
 
        ScalarDiffusionFluxPolicy flux_policy;
        flux_policy.coefficients = native_policy.coefficients;
        flux_policy.coefficient_mode = {l_consA, l_turb};
        flux_policy.surface = {
            SurfLayer_xlo, SurfLayer_xhi, SurfLayer_ylo, SurfLayer_yhi,
            SurfLayer_zlo, SurfLayer_zhi
        };
        if (native_policy.is_theta) {
            flux_policy.prescribed.use_x_on_side = true;
            flux_policy.prescribed.use_y_on_side = true;
            flux_policy.prescribed.use_z_on_side = true;
            flux_policy.prescribed.x = Array4<const Real>(hfx_x);
            flux_policy.prescribed.y = Array4<const Real>(hfx_y);
            flux_policy.prescribed.z = Array4<const Real>(hfx_z);
            flux_policy.diagnostic.enabled = true;
            flux_policy.diagnostic.z = hfx_z;
        } else if (native_policy.is_q1) {
            flux_policy.prescribed.use_x_on_side = true;
            flux_policy.prescribed.use_y_on_side = true;
            flux_policy.prescribed.use_z_on_side = true;
            flux_policy.prescribed.x = Array4<const Real>(qfx1_x);
            flux_policy.prescribed.y = Array4<const Real>(qfx1_y);
            flux_policy.prescribed.z = Array4<const Real>(qfx1_z);
            flux_policy.diagnostic.enabled = true;
            flux_policy.diagnostic.z = qfx1_z;
        } else if (native_policy.is_q2) {
            flux_policy.diagnostic.enabled = true;
            flux_policy.diagnostic.write_on_surface = true;
            flux_policy.diagnostic.z = qfx2_z;
        }
 
        BuildScalarDiffusionFluxes_N(
            bx, domain, field, flux_policy, cellSizeInv, u, v, mf_ux, mf_uy,
            mf_vx, mf_vy, bc_ptr, native_policy.bc_comp);
        if (native_policy.scale_raw_vertical_flux) {
            ScaleScalarDiffusionVerticalFlux(
                zbx, zflux, field.flux_comp, explicit_fac);
        }
        // Fraction-stress immersed wall law: no theta or TKE flux through the bottom face of the
        // wall cell, as through zlo on flat ground (ERF_ImmersedWallCell.H)
        if (wall_face33 && (qty_index == RhoTheta_comp || qty_index == RhoKE_comp)) {
            const int fc = field.flux_comp;
            const Box mbx = zbx & amrex::convert(Box(wall_face33), zbx.ixType());
            ParallelFor(mbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
            {
                zflux(i,j,k,fc) *= wall_face33(i,j,k);
            });
            if (qty_index == RhoTheta_comp && hfx_z) {
                // the TKE buoyancy reads hfx_z: on the wall face it is the wall heat flux of the
                // wall law (rho times the kinematic flux, as the surface layer writes it at zlo).
                // wall_hfx has no ghost cells: on the top face of a box split in z (never with
                // amr.no_box_split_dir = 2) the face reads zero here and its value from the box above
                const Box hbx = mbx & amrex::convert(Box(hfx_z), zbx.ixType());
                ParallelFor(hbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
                {
                    const Real q_wall = (wall_hfx && wall_hfx.contains(i,j,k))
                                      ? cell_data(i,j,k,Rho_comp) * wall_hfx(i,j,k) : zero;
                    hfx_z(i,j,k) = (wall_face33(i,j,k) == zero) ? q_wall : wall_face33(i,j,k) * hfx_z(i,j,k);
                });
            }
        }
        ApplyScalarDiffusionFluxDivergence_N(
            bx, xflux, yflux, zflux, field.flux_comp, cell_rhs, field.rhs_comp,
            cellSizeInv, mf_mx, mf_my);
        if (reflux_flx) {
            AddScalarDiffusionRefluxFluxes_N(
                bx, xflux, yflux, zflux, field.flux_comp, *reflux_flx, field.rhs_comp, mf_mx, mf_my);
        }
    } // n
}

Here is the call graph for this function: