ERF_MoistUtils.H File Reference

#include "ERF_EOS.H"
#include "ERF_MicrophysicsUtils.H"

Include dependency graph for ERF_MoistUtils.H:

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

Go to the source code of this file.

Functions
AMREX_GPU_DEVICE AMREX_FORCE_INLINE void	GetMoistureVars (int i, int j, int k, const amrex::Array4< amrex::Real const > &cell_data, amrex::Real &qv, amrex::Real &qc_liquid, amrex::Real &qc_ice, const MoistureComponentIndices &moisture_indices)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	ComputeVirtualPotentialTemperature (const amrex::Real &theta, const amrex::Real &qv, const amrex::Real &qc_liquid, const amrex::Real &qc_ice)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	GetThetav (const int &i, const int &j, const int &k, const amrex::Array4< amrex::Real const > &cell_data, const MoistureComponentIndices &moisture_indices)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	GetThetavl (int i, int j, int k, const amrex::Array4< amrex::Real const > &cell_data, const MoistureComponentIndices &moisture_indices)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	ComputeLiquidWaterPotentialTemperature (const amrex::Real &theta, const amrex::Real &T, const amrex::Real &qc_liquid)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	GetThetal (const int &i, const int &j, const int &k, const amrex::Array4< amrex::Real const > &cell_data, const MoistureComponentIndices &moisture_indices)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	ComputeMoistStratification (const int &i, const int &j, const int &k, const amrex::Array4< amrex::Real const > &cell_data, const amrex::Real &dzInv, const amrex::Real &abs_g, const amrex::Real &inv_theta0, const MoistureComponentIndices &moisture_indices)
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	ComputeStratificationForSmagorinsky (const int &i, const int &j, const int &k, const amrex::Array4< amrex::Real const > &cell_data, const amrex::Real &dzInv, const amrex::Real &abs_g, const amrex::Real &inv_theta0, const bool &use_moisture, const int &rho_qv_comp, const MoistureComponentIndices &moisture_indices)

Function Documentation

ComputeLiquidWaterPotentialTemperature()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real ComputeLiquidWaterPotentialTemperature	(	const amrex::Real &	theta,
		const amrex::Real &	T,
		const amrex::Real &	qc_liquid
	)

Compute linearized liquid-water potential temperature

{
    return theta - (theta / T) * (L_v / Cp_d) * qc_liquid;
}

Referenced by GetThetal().

Here is the caller graph for this function:

ComputeMoistStratification()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real ComputeMoistStratification	(	const int &	i,
		const int &	j,
		const int &	k,
		const amrex::Array4< amrex::Real const > &	cell_data,
		const amrex::Real &	dzInv,
		const amrex::Real &	abs_g,
		const amrex::Real &	inv_theta0,
		const MoistureComponentIndices &	moisture_indices
	)

Compute moist stratification accounting for conditional instability

{
    // Get moisture variables partitioned into phases
    amrex::Real qv, qc_liquid, qc_ice;
    GetMoistureVars(i, j, k, cell_data, qv, qc_liquid, qc_ice, moisture_indices);
 
    // Compute virtual potential temperature gradient
    amrex::Real theta_v_upper = GetThetav(i, j, k+1, cell_data, moisture_indices);
    amrex::Real theta_v_lower = GetThetav(i, j, k-1, cell_data, moisture_indices);
 
    amrex::Real dthetav_dz = myhalf * (theta_v_upper - theta_v_lower) * dzInv;
    amrex::Real stratification = abs_g * dthetav_dz * inv_theta0;
 
    // Apply conditional instability correction
    amrex::Real total_condensate = qc_liquid + qc_ice;
    if (total_condensate > 1e-8) {
        amrex::Real T_current = getTgivenRandRTh(cell_data(i,j,k,Rho_comp),
                                                 cell_data(i,j,k,RhoTheta_comp), qv);
 
        // Phase-weighted effective latent heat
        amrex::Real liquid_fraction = qc_liquid / (total_condensate + amrex::Real(1e-12));
        amrex::Real ice_fraction = one - liquid_fraction;
        amrex::Real L_eff = liquid_fraction * L_v + ice_fraction * (L_v + lat_ice);
 
        // Phase-weighted saturation mixing ratio
        amrex::Real qsat_liquid = zero, qsat_ice = zero;
        amrex::Real pres_current = getPgivenRTh(cell_data(i,j,k,RhoTheta_comp), qv) * amrex::Real(0.01);
 
        erf_qsatw(T_current, pres_current, qsat_liquid);
        erf_qsati(T_current, pres_current, qsat_ice);
 
        amrex::Real qsat_eff = liquid_fraction * qsat_liquid + ice_fraction * qsat_ice;
 
        // Moist adiabatic lapse rate correction
        amrex::Real gamma_moist_factor = (one + L_eff*qsat_eff/(R_d*T_current)) /
                                         (one + L_eff*L_eff*qsat_eff/(Cp_d*R_v*T_current*T_current));
 
        stratification *= gamma_moist_factor;
    }
 
    return stratification;
}

Referenced by ComputeStratificationForSmagorinsky().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeStratificationForSmagorinsky()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real ComputeStratificationForSmagorinsky	(	const int &	i,
		const int &	j,
		const int &	k,
		const amrex::Array4< amrex::Real const > &	cell_data,
		const amrex::Real &	dzInv,
		const amrex::Real &	abs_g,
		const amrex::Real &	inv_theta0,
		const bool &	use_moisture,
		const int &	rho_qv_comp,
		const MoistureComponentIndices &	moisture_indices
	)

Compute stratification for Smagorinsky scheme (moist or dry)

{
    if (use_moisture && (rho_qv_comp >= 0)) {
        // Moist stratification with virtual temperature and conditional instability
        return ComputeMoistStratification(i, j, k, cell_data, dzInv, abs_g, inv_theta0, moisture_indices);
    } else {
        // Dry stratification (original approach)
        amrex::Real theta_hi = cell_data(i,j,k+1,RhoTheta_comp)/cell_data(i,j,k+1,Rho_comp);
        amrex::Real theta_lo = cell_data(i,j,k-1,RhoTheta_comp)/cell_data(i,j,k-1,Rho_comp);
        amrex::Real dtheta_dz = myhalf * (theta_hi - theta_lo) * dzInv;
        return abs_g * dtheta_dz * inv_theta0;
    }
}

Here is the call graph for this function:

ComputeVirtualPotentialTemperature()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real ComputeVirtualPotentialTemperature	(	const amrex::Real &	theta,
		const amrex::Real &	qv,
		const amrex::Real &	qc_liquid,
		const amrex::Real &	qc_ice
	)

Compute virtual potential temperature with moisture loading effects

{
    amrex::Real qc_total = qc_liquid + qc_ice;
    return theta * (one + epsv * qv - qc_total);
}

Referenced by GetThetav().

Here is the caller graph for this function:

GetMoistureVars()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE void GetMoistureVars	(	int	i,
		int	j,
		int	k,
		const amrex::Array4< amrex::Real const > &	cell_data,
		amrex::Real &	qv,
		amrex::Real &	qc_liquid,
		amrex::Real &	qc_ice,
		const MoistureComponentIndices &	moisture_indices
	)

Extract moisture variables and partition into liquid/ice phases

{
    qv = zero; qc_liquid = zero; qc_ice = zero;
 
    // Water vapor
    if (moisture_indices.qv >= 0) {
        qv = cell_data(i,j,k,moisture_indices.qv)/cell_data(i,j,k,Rho_comp);
    }
 
    // Cloud liquid water
    if (moisture_indices.qc >= 0) {
        qc_liquid = cell_data(i,j,k,moisture_indices.qc)/cell_data(i,j,k,Rho_comp);
    }
 
    // Cloud ice (only if separate ice species exists)
    if (moisture_indices.qi >= 0) {
        qc_ice = cell_data(i,j,k,moisture_indices.qi)/cell_data(i,j,k,Rho_comp);
    }
    // No temperature-based partitioning - respect the microphysics scheme's decisions
 
    // Add precipitating species
    if (moisture_indices.qr >= 0) {  // Rain (always liquid)
        qc_liquid += cell_data(i,j,k,moisture_indices.qr)/cell_data(i,j,k,Rho_comp);
    }
    if (moisture_indices.qs >= 0) {  // Snow (always ice)
        qc_ice += cell_data(i,j,k,moisture_indices.qs)/cell_data(i,j,k,Rho_comp);
    }
    if (moisture_indices.qg >= 0) {  // Graupel (always ice)
        qc_ice += cell_data(i,j,k,moisture_indices.qg)/cell_data(i,j,k,Rho_comp);
    }
}

Referenced by ComputeMoistStratification(), GetThetal(), and GetThetav().

Here is the caller graph for this function:

GetThetal()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real GetThetal	(	const int &	i,
		const int &	j,
		const int &	k,
		const amrex::Array4< amrex::Real const > &	cell_data,
		const MoistureComponentIndices &	moisture_indices
	)

Wrapper around ComputeLiquidWaterPotentialTemperature

{
    amrex::Real qv, qcl, qci;
    GetMoistureVars(i, j, k, cell_data, qv, qcl, qci, moisture_indices);
 
    amrex::Real theta = cell_data(i, j, k, RhoTheta_comp) / cell_data(i, j, k, Rho_comp);
 
    amrex::Real T = getTgivenRandRTh(cell_data(i, j, k, Rho_comp),
                                     cell_data(i, j, k, RhoTheta_comp),
                                     qv);
 
    return ComputeLiquidWaterPotentialTemperature(theta, T, qcl);
}

Referenced by ComputeN2(), ComputeN2_EB(), and ComputeTurbulentViscosityLES().

Here is the call graph for this function:

Here is the caller graph for this function:

GetThetav()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real GetThetav	(	const int &	i,
		const int &	j,
		const int &	k,
		const amrex::Array4< amrex::Real const > &	cell_data,
		const MoistureComponentIndices &	moisture_indices
	)

Wrapper around ComputeVirtualPotentialTemperature

{
    amrex::Real theta = cell_data(i, j, k, RhoTheta_comp) / cell_data(i, j, k, Rho_comp);
 
    amrex::Real qv, qcl, qci;
    GetMoistureVars(i, j, k, cell_data, qv, qcl, qci, moisture_indices);
 
    return ComputeVirtualPotentialTemperature(theta, qv, qcl, qci);
}

Referenced by MYNNPBLH::compute_pblh(), ComputeDiffusivityMRF(), ComputeDiffusivityYSUNew(), ComputeMoistStratification(), ComputeN2(), ComputeN2_EB(), ComputeTurbulentViscosityLES(), and ComputeVerticalDerivativesPBL().

Here is the call graph for this function:

Here is the caller graph for this function:

GetThetavl()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real GetThetavl	(	int	i,
		int	j,
		int	k,
		const amrex::Array4< amrex::Real const > &	cell_data,
		const MoistureComponentIndices &	moisture_indices
	)

Compute liquid-water virtual potential temperature theta_vl = theta * (1 + 0.61*qv - ql - qi) where ql = qc (cloud liquid) and qi = qi (cloud ice) This accounts for condensate loading in the virtual temperature effect

{
    const amrex::Real rho   = cell_data(i, j, k, Rho_comp);
    const amrex::Real theta = cell_data(i, j, k, RhoTheta_comp) / rho;
 
    amrex::Real qv = zero, qc = zero, qi = zero;
    if (moisture_indices.qv >= 0)
        qv = cell_data(i, j, k, moisture_indices.qv) / rho;
    if (moisture_indices.qc >= 0)
        qc = cell_data(i, j, k, moisture_indices.qc) / rho;
    if (moisture_indices.qi >= 0)
        qi = cell_data(i, j, k, moisture_indices.qi) / rho;
 
    return theta * (one + epsv * qv - qc - qi);
}

Referenced by ComputeDiffusivityYSUNew().

Here is the caller graph for this function: