ERF_MoistUtils.H

Go to the documentation of this file.

#ifndef ERF_MOISTUTILS_H_
#define ERF_MOISTUTILS_H_
 
#include "ERF_EOS.H"
#include "ERF_MicrophysicsUtils.H"
 
// =============================================================================
// MOIST TURBULENCE FUNCTIONS
// =============================================================================
 
/**
 * Extract moisture variables and partition into liquid/ice phases
 */
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)
{
    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);
    }
}
 
/**
 * Compute virtual potential temperature with moisture loading effects
 */
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::Real qc_total = qc_liquid + qc_ice;
    return theta * (one + epsv * qv - qc_total);
}
 
/**
 * Wrapper around ComputeVirtualPotentialTemperature
 */
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::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);
}
 
/**
 * 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
 */
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)
{
    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);
}
 
 
/**
 * Compute linearized liquid-water potential temperature
 */
AMREX_GPU_DEVICE
AMREX_FORCE_INLINE
amrex::Real ComputeLiquidWaterPotentialTemperature (const amrex::Real& theta,
                                                    const amrex::Real& T,
                                                    const amrex::Real& qc_liquid)
{
    return theta - (theta / T) * (L_v / Cp_d) * qc_liquid;
}
 
/**
 * Wrapper around ComputeLiquidWaterPotentialTemperature
 */
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::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);
}
 
 
/**
 * Compute moist stratification accounting for conditional instability
 */
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)
{
    // 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;
}
 
/**
 * Compute stratification for Smagorinsky scheme (moist or dry)
 */
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)
{
    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;
    }
}
 
#endif