ERF_init_from_input_sounding.cpp File Reference

#include <ERF.H>
#include <EOS.H>
#include <ERF_Constants.H>
#include <Utils.H>
#include <prob_common.H>

Include dependency graph for ERF_init_from_input_sounding.cpp:

Functions
void	init_bx_scalars_from_input_sounding (const Box &bx, Array4< Real > const &state, GeometryData const &geomdata, Array4< const Real > const &z_cc_arr, const bool &l_moist, InputSoundingData const &inputSoundingData)
void	init_bx_scalars_from_input_sounding_hse (const Box &bx, Array4< Real > const &state, Array4< Real > const &r_hse_arr, Array4< Real > const &p_hse_arr, Array4< Real > const &pi_hse_arr, GeometryData const &geomdata, Array4< const Real > const &z_cc_arr, const Real &l_gravity, const Real &l_rdOcp, const bool &l_moist, InputSoundingData const &inputSoundingData)
void	init_bx_velocities_from_input_sounding (const Box &bx, Array4< Real > const &x_vel, Array4< Real > const &y_vel, Array4< Real > const &z_vel, GeometryData const &geomdata, Array4< const Real > const &z_nd_arr, InputSoundingData const &inputSoundingData)

Function Documentation

init_bx_scalars_from_input_sounding()

void init_bx_scalars_from_input_sounding	(	const Box &	bx,
		Array4< Real > const &	state,
		GeometryData const &	geomdata,
		Array4< const Real > const &	z_cc_arr,
		const bool &	l_moist,
		InputSoundingData const &	inputSoundingData
	)

Box level wrapper for initializing scalar data from input sounding data.

Parameters

bx	Box specifying the indices we are initializing
state	Array4 specifying the state data we are to initialize
geomdata	GeometryData object specifying the domain geometry
inputSoundingData	InputSoundingData object we are to initialize from

{
    const Real* z_inp_sound     = inputSoundingData.z_inp_sound_d.dataPtr();
    const Real* theta_inp_sound = inputSoundingData.theta_inp_sound_d.dataPtr();
    const Real* qv_inp_sound    = inputSoundingData.qv_inp_sound_d.dataPtr();
    const int   inp_sound_size  = inputSoundingData.size();
 
    // Geometry
    const Real* prob_lo = geomdata.ProbLo();
    const Real* dx = geomdata.CellSize();
    const Real  z_lo = prob_lo[2];
    const Real  dz   = dx[2];
 
    // We want to set the lateral BC values, too
    Box gbx = bx; // Copy constructor
    gbx.grow(0,1); gbx.grow(1,1); // Grow by one in the lateral directions
 
    ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
        const Real z = (z_cc_arr) ? z_cc_arr(i,j,k)
                                         : z_lo + (k + 0.5) * dz;
 
        Real rho_0 = 1.0;
 
        // Set the density
        state(i, j, k, Rho_comp) = rho_0;
 
        // Initial Rho0*Theta0
        state(i, j, k, RhoTheta_comp) = rho_0 * interpolate_1d(z_inp_sound, theta_inp_sound, z, inp_sound_size);
 
        // Set scalar = A_0*exp(-10r^2), where r is distance from center of domain
        state(i, j, k, RhoScalar_comp) = 0;
 
        // total nonprecipitating water (Q1) == water vapor (Qv), i.e., there is no cloud water or cloud ice
        if (l_moist)
            state(i, j, k, RhoQ1_comp) = rho_0 * interpolate_1d(z_inp_sound, qv_inp_sound, z, inp_sound_size);
 
    });
}

Referenced by ERF::init_from_input_sounding().

Here is the call graph for this function:

Here is the caller graph for this function:

init_bx_scalars_from_input_sounding_hse()

void init_bx_scalars_from_input_sounding_hse	(	const Box &	bx,
		Array4< Real > const &	state,
		Array4< Real > const &	r_hse_arr,
		Array4< Real > const &	p_hse_arr,
		Array4< Real > const &	pi_hse_arr,
		GeometryData const &	geomdata,
		Array4< const Real > const &	z_cc_arr,
		const Real &	l_gravity,
		const Real &	l_rdOcp,
		const bool &	l_moist,
		InputSoundingData const &	inputSoundingData
	)

Box level wrapper for initializing scalar and hydrostatic base state data from input sounding data.

Parameters

bx	Box specifying the indices we are initializing
state	Array4 specifying the state data we are to initialize
r_hse_arr	Array4 specifying the density HSE base state data we are to initialize
p_hse_arr	Array4 specifying the pressure HSE base state data we are to initialize
pi_hse_arr	Array4 specifying the Exner pressure HSE base state data we are to initialize
geomdata	GeometryData object specifying the domain geometry
l_gravity	Real number specifying the gravitational acceleration constant
l_rdOcp	Real number specifying the Rhydberg constant ($R_d$) divided by specific heat at constant pressure ($c_p$)
inputSoundingData	InputSoundingData object we are to initialize from

{
    const Real* z_inp_sound     = inputSoundingData.z_inp_sound_d.dataPtr();
    const Real* rho_inp_sound   = inputSoundingData.rho_inp_sound_d.dataPtr();
    const Real* theta_inp_sound = inputSoundingData.theta_inp_sound_d.dataPtr();
    const Real* qv_inp_sound    = inputSoundingData.qv_inp_sound_d.dataPtr();
    const int   inp_sound_size  = inputSoundingData.size();
 
    // Geometry
    int ktop = bx.bigEnd(2);
    const Real* prob_lo = geomdata.ProbLo();
    const Real* dx = geomdata.CellSize();
    const Real  z_lo = prob_lo[2];
    const Real  dz   = dx[2];
 
    // We want to set the lateral BC values, too
    Box gbx = bx; // Copy constructor
    gbx.grow(0,1); gbx.grow(1,1); // Grow by one in the lateral directions
 
    ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
        const Real z = (z_cc_arr) ? z_cc_arr(i,j,k)
                                         : z_lo + (k + 0.5) * dz;
 
        Real rho_k, qv_k, rhoTh_k;
 
        // Set the density
        rho_k = interpolate_1d(z_inp_sound, rho_inp_sound, z, inp_sound_size);
        state(i, j, k, Rho_comp) = rho_k;
 
        // Initial Rho0*Theta0
        rhoTh_k = rho_k * interpolate_1d(z_inp_sound, theta_inp_sound, z, inp_sound_size);
        state(i, j, k, RhoTheta_comp) = rhoTh_k;
 
        // Set scalar = A_0*exp(-10r^2), where r is distance from center of domain
        state(i, j, k, RhoScalar_comp) = 0;
 
        // Update hse quantities with values calculated from InputSoundingData.calc_rho_p()
        qv_k = (l_moist) ? interpolate_1d(z_inp_sound, qv_inp_sound, z, inp_sound_size) : 0.0;
        r_hse_arr (i, j, k) = rho_k * (1.0 + qv_k);
        p_hse_arr (i, j, k) = getPgivenRTh(rhoTh_k, qv_k);
        pi_hse_arr(i, j, k) = getExnergivenRTh(rhoTh_k, l_rdOcp);
 
        // Boundary treatment
        if (k==0)
        {
            // set the ghost cell with dz and rho at boundary
            Real rho_surf =
                interpolate_1d(z_inp_sound, rho_inp_sound, 0.0, inp_sound_size);
            p_hse_arr (i, j, k-1) = p_hse_arr(i,j,k) + dz * rho_surf * l_gravity;
            pi_hse_arr(i, j, k-1) = getExnergivenP(p_hse_arr(i, j, k-1), l_rdOcp);
        }
        else if (k==ktop)
        {
            // set the ghost cell with dz and rho at boundary
            Real rho_top =
                interpolate_1d(z_inp_sound, rho_inp_sound, z+dz/2, inp_sound_size);
            p_hse_arr (i, j, k+1) = p_hse_arr(i,j,k) - dz * rho_top * l_gravity;
            pi_hse_arr(i, j, k+1) = getExnergivenP(p_hse_arr(i, j, k+1), l_rdOcp);
        }
 
        // total nonprecipitating water (Q1) == water vapor (Qv), i.e., there
        // is no cloud water or cloud ice
        if (l_moist)
            state(i, j, k, RhoQ1_comp) = rho_k * qv_k;
    });
}

Referenced by ERF::init_from_input_sounding().

Here is the call graph for this function:

Here is the caller graph for this function:

init_bx_velocities_from_input_sounding()

void init_bx_velocities_from_input_sounding	(	const Box &	bx,
		Array4< Real > const &	x_vel,
		Array4< Real > const &	y_vel,
		Array4< Real > const &	z_vel,
		GeometryData const &	geomdata,
		Array4< const Real > const &	z_nd_arr,
		InputSoundingData const &	inputSoundingData
	)

Box level wrapper for initializing velocities from input sounding data.

Parameters

bx	Box specifying the indices we are initializing
x_vel	Array4 specifying the x-velocity data we are to initialize
y_vel	Array4 specifying the y-velocity data we are to initialize
z_vel	Array4 specifying the z-velocity data we are to initialize
geomdata	GeometryData object specifying the domain geometry
inputSoundingData	InputSoundingData object we are to initialize from

{
    const Real* z_inp_sound     = inputSoundingData.z_inp_sound_d.dataPtr();
    const Real* U_inp_sound     = inputSoundingData.U_inp_sound_d.dataPtr();
    const Real* V_inp_sound     = inputSoundingData.V_inp_sound_d.dataPtr();
    const int   inp_sound_size  = inputSoundingData.size();
 
    // Geometry
    const Real* prob_lo = geomdata.ProbLo();
    const Real* dx = geomdata.CellSize();
    const Real  z_lo = prob_lo[2];
    const Real  dz   = dx[2];
 
    // We want to set the lateral BC values, too
    Box gbx = bx; // Copy constructor
    gbx.grow(0,1); gbx.grow(1,1); // Grow by one in the lateral directions
 
    // Construct a box that is on x-faces
    const Box& xbx = surroundingNodes(gbx,0);
    // Construct a box that is on y-faces
    const Box& ybx = surroundingNodes(gbx,1);
    // Construct a box that is on z-faces
    const Box& zbx = surroundingNodes(gbx,2);
 
    // Set the x,y,z-velocities
    ParallelFor(xbx, ybx, zbx,
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
        // Note that this is called on a box of x-faces
        const Real z = (z_nd_arr) ? 0.25*( z_nd_arr(i,j  ,k  )
                                                + z_nd_arr(i,j+1,k  )
                                                + z_nd_arr(i,j  ,k+1)
                                                + z_nd_arr(i,j+1,k+1))
                                         : z_lo + (k + 0.5) * dz;
 
        // Set the x-velocity
        x_vel(i, j, k) = interpolate_1d(z_inp_sound, U_inp_sound, z, inp_sound_size);
    },
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
        // Note that this is called on a box of y-faces
        const Real z = (z_nd_arr) ? 0.25*( z_nd_arr(i  ,j,k  )
                                                + z_nd_arr(i+1,j,k  )
                                                + z_nd_arr(i  ,j,k+1)
                                                + z_nd_arr(i+1,j,k+1))
                                         : z_lo + (k + 0.5) * dz;
 
        // Set the y-velocity
        y_vel(i, j, k) = interpolate_1d(z_inp_sound, V_inp_sound, z, inp_sound_size);
    },
    [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
        // Note that this is called on a box of z-faces
        // Set the z-velocity
        z_vel(i, j, k) = 0.0;
    });
}

Referenced by ERF::init_from_input_sounding().

Here is the call graph for this function:

Here is the caller graph for this function: