ERF_SAMUtils.H File Reference

#include <cmath>
#include <limits>
#include <AMReX_Array4.H>
#include <AMReX_GpuQualifiers.H>
#include "ERF_Constants.H"
#include "ERF_DataStruct.H"
#include "ERF_EOS.H"
#include "ERF_IndexDefines.H"
#include "ERF_MicrophysicsUtils.H"

Include dependency graph for ERF_SAMUtils.H:

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

Go to the source code of this file.

Classes
struct	SAMPhaseFractions
struct	SAMCloudPhaseChange
struct	SAMPrecipSources
struct	SAMPrimitiveCell
struct	SAMPrecipConfig
struct	SAMPrecipCellDiagnostics
struct	SAMCoefficientRow
struct	SAMPrecipFaceState
struct	SAMPrecipComponentFaceState
struct	SAMFaceState
struct	SAMSurfaceAccumulation
struct	SAMPrecipFluxComponents

Typedefs
using	SAMCellState = SAMPrimitiveCell

Functions
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_mbar_to_pa (const amrex::Real &pres_mbar) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_pa_to_mbar (const amrex::Real &pres_pa) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_theta_from_stored_mbar_converted_to_pa (const amrex::Real &tabs, const amrex::Real &pres_mbar, const amrex::Real rdOcp) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrimitiveCell	sam_cons_to_primitive (const amrex::Real &rho, const amrex::Real &rho_theta, const amrex::Real &rho_qv, const amrex::Real &rho_qcl, const amrex::Real &rho_qci, const amrex::Real &rho_qpr, const amrex::Real &rho_qps, const amrex::Real &rho_qpg) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void	sam_primitive_to_cons (const SAMPrimitiveCell &primitive, const amrex::Array4< amrex::Real > &states_arr, const int &i, const int &j, const int &k) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	sam_is_no_ice (const MoistureType &moisture_type) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	sam_is_no_precip (const MoistureType &moisture_type) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_cloud_liquid_fraction (const int &SAM_moisture_type, const amrex::Real &tabs, const amrex::Real an, const amrex::Real bn) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_precip_rain_fraction (const int &SAM_moisture_type, const amrex::Real &tabs) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_graupel_fraction (const int &SAM_moisture_type, const amrex::Real &tabs) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMCloudPhaseChange	sam_partition_cloud_phase (const int &SAM_moisture_type, const amrex::Real &tabs, const amrex::Real &qn, const amrex::Real &qcl, const amrex::Real &qci, const amrex::Real fac_cond, const amrex::Real fac_fus, const amrex::Real an, const amrex::Real bn) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_mixed_qsat (const amrex::Real &omn, const amrex::Real &qsatw, const amrex::Real &qsati) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_mixed_dqsat_dT (const amrex::Real &omn, const amrex::Real &domn, const amrex::Real &qsatw, const amrex::Real &qsati, const amrex::Real &dqsatw, const amrex::Real &dqsati) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_mixed_dqif_dT (const amrex::Real &omn, const amrex::Real &domn, const amrex::Real &qn, const amrex::Real &dqsatm) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_newton_residual (const amrex::Real &tabs_new, const amrex::Real &tabs_old, const amrex::Real fcond, const amrex::Real &qv, const amrex::Real &qsatm, const amrex::Real ffus, const amrex::Real &qi, const amrex::Real &qif) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_newton_residual_derivative (const amrex::Real fcond, const amrex::Real ffus, const amrex::Real &dqsatm, const amrex::Real &dqif) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources	sam_autoconversion_rates (const amrex::Real &dtn, const amrex::Real &qcc, const amrex::Real &qii, const amrex::Real &coefice_k) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources	sam_accretion_rates (const amrex::Real &dtn, const amrex::Real &qcc, const amrex::Real &qii, const amrex::Real &qpr, const amrex::Real &qps, const amrex::Real &qpg, const amrex::Real &powr1, const amrex::Real &pows1, const amrex::Real &powg1, const amrex::Real &omp, const amrex::Real &omg, const amrex::Real &accrrc_k, const amrex::Real &accrsc_k, const amrex::Real &accrsi_k, const amrex::Real &accrgc_k, const amrex::Real &accrgi_k) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources	sam_rescale_cloud_sinks (const amrex::Real &qcl, const amrex::Real &qci, const amrex::Real &eps, SAMPrecipSources result) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources	sam_partition_autoconverted_precip (SAMPrecipSources result, const amrex::Real &omp, const amrex::Real &omg) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources	sam_precip_evaporation_rates (const amrex::Real &qpr, const amrex::Real &qps, const amrex::Real &qpg, const amrex::Real &powr2, const amrex::Real &pows2, const amrex::Real &powg2, const amrex::Real &evapr1_k, const amrex::Real &evapr2_k, const amrex::Real &evaps1_k, const amrex::Real &evaps2_k, const amrex::Real &evapg1_k, const amrex::Real &evapg2_k) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources	sam_apply_precip_evaporation_limiter (const amrex::Real &qpr, const amrex::Real &qps, const amrex::Real &qpg, SAMPrecipSources result) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMCellState	sam_precip_cell_update (SAMCellState state, const SAMCoefficientRow &coeffs, const SAMPrecipConfig &config, SAMPrecipCellDiagnostics *diagnostics=nullptr) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMCoefficientRow	sam_compute_coefficient_row (const amrex::Real &rho, const amrex::Real &tabs, const amrex::Real &gamr1, const amrex::Real &gamr2, const amrex::Real &gams1, const amrex::Real &gams2, const amrex::Real &gamg1, const amrex::Real &gamg2) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_cloud_ice_terminal_velocity (const amrex::Real &qci_avg) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMFaceState	sam_face_average_state (const int &k, const int &k_lo, const int &k_hi, const amrex::Real &rho_km1, const amrex::Real &rho_k, const amrex::Real tabs_km1, const amrex::Real tabs_k, const amrex::Real &qci_km1, const amrex::Real &qci_k, const amrex::Real qp_km1, const amrex::Real qp_k) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int	sam_precip_face_donor_k (const int &face_k, const int &k_lo, const int &k_hi) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int	sam_substep_count_from_reduced_flux (const amrex::Real &reduced_flux, const amrex::Real &dt, const amrex::Real &dz) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFaceState	sam_precip_face_state (const int &SAM_moisture_type, const amrex::Array4< const amrex::Real > &rho_array, const amrex::Array4< const amrex::Real > &tabs_array, const amrex::Array4< const amrex::Real > &qp_array, const int &i, const int &j, const int &k, const int &k_lo, const int &k_hi) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipComponentFaceState	sam_precip_component_face_state (const amrex::Array4< const amrex::Real > &rho_array, const amrex::Array4< const amrex::Real > &tabs_array, const amrex::Array4< const amrex::Real > &qpr_array, const amrex::Array4< const amrex::Real > &qps_array, const amrex::Array4< const amrex::Real > &qpg_array, const int &i, const int &j, const int &k, const int &k_lo, const int &k_hi) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_precip_flux_from_face_state (const SAMPrecipFaceState &face_state, const amrex::Real &vrain, const amrex::Real &vsnow, const amrex::Real &vgrau) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFluxComponents	sam_precip_flux_components_from_face_state (const SAMPrecipFaceState &face_state, const amrex::Real &vrain, const amrex::Real &vsnow, const amrex::Real &vgrau) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFluxComponents	sam_precip_component_fluxes_from_face_state (const SAMPrecipComponentFaceState &face_state, const amrex::Real &vrain, const amrex::Real &vsnow, const amrex::Real &vgrau) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_precip_flux_density_corrected (const amrex::Real &precip_flux, const amrex::Real &rho_0, const amrex::Real &rho_avg) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFluxComponents	sam_precip_flux_components_density_corrected (const SAMPrecipFluxComponents &precip_fluxes, const amrex::Real &rho_0, const amrex::Real &rho_avg) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_limit_precip_component_flux (const amrex::Real &raw_flux, const amrex::Real &rho_donor, const amrex::Real &q_donor, const amrex::Real &detJ_donor, const amrex::Real &coef) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	sam_sedimentation_tendency (const amrex::Real &fz_hi, const amrex::Real &fz_lo, const amrex::Real &rho, const amrex::Real &dJinv, const amrex::Real &coef) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMSurfaceAccumulation	sam_surface_accumulation_from_component_fluxes (const SAMPrecipFluxComponents &component_fluxes, const amrex::Real &dtn) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMSurfaceAccumulation	sam_surface_accumulation (const SAMPrecipFaceState &face_state, const amrex::Real &rho_0, const amrex::Real &vrain, const amrex::Real &vsnow, const amrex::Real &vgrau, const amrex::Real &dtn) noexcept

Typedef Documentation

SAMCellState

using SAMCellState = SAMPrimitiveCell

Function Documentation

sam_accretion_rates()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources sam_accretion_rates ( const amrex::Real &  dtn, const amrex::Real &  qcc, const amrex::Real &  qii, const amrex::Real &  qpr, const amrex::Real &  qps, const amrex::Real &  qpg, const amrex::Real &  powr1, const amrex::Real &  pows1, const amrex::Real &  powg1, const amrex::Real &  omp, const amrex::Real &  omg, const amrex::Real &  accrrc_k, const amrex::Real &  accrsc_k, const amrex::Real &  accrsi_k, const amrex::Real &  accrgc_k, const amrex::Real &  accrgi_k  )

noexcept

{
    SAMPrecipSources result{};
    amrex::Real accrcr = zero;
    amrex::Real accrcs = zero;
    amrex::Real accris = zero;
    amrex::Real accrcg = zero;
    amrex::Real accrig = zero;
 
    // Accretion increments over dtn. Liquid-origin sinks feed rain, snow, and
    // graupel; ice-origin sinks feed snow and graupel. These strict empirical
    // selector thresholds are implementation rules, not fundamental laws:
    // rain requires omp > 0.001, snow requires omp < 0.999 and omg < 0.999,
    // and graupel requires omp < 0.999 and omg > 0.001. Equality is inactive.
    if (omp > amrex::Real(0.001)) {
        accrcr = accrrc_k;
    }
    if (omp < amrex::Real(0.999) && omg < amrex::Real(0.999)) {
        accrcs = accrsc_k;
        accris = accrsi_k;
    }
    if (omp < amrex::Real(0.999) && omg > amrex::Real(0.001)) {
        accrcg = accrgc_k;
        accrig = accrgi_k;
    }
 
    result.dprc = dtn * accrcr * qcc * std::pow(qpr, powr1);
    result.dpsc = dtn * accrcs * qcc * std::pow(qps, pows1);
    result.dpgc = dtn * accrcg * qcc * std::pow(qpg, powg1);
    result.dpsi = dtn * accris * qii * std::pow(qps, pows1);
    result.dpgi = dtn * accrig * qii * std::pow(qpg, powg1);
    return result;
}

Referenced by sam_precip_cell_update().

Here is the caller graph for this function:

sam_apply_precip_evaporation_limiter()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources sam_apply_precip_evaporation_limiter ( const amrex::Real &  qpr, const amrex::Real &  qps, const amrex::Real &  qpg, SAMPrecipSources  result  )

noexcept

{
    // Limits rain evaporation and snow/graupel sublimation by available
    // qpr/qps/qpg so the source update cannot make precipitating species
    // negative.
    result.dqpr = amrex::min(qpr, result.dqpr);
    result.dqps = amrex::min(qps, result.dqps);
    result.dqpg = amrex::min(qpg, result.dqpg);
    result.dqp = result.dqpr + result.dqps + result.dqpg;
    return result;
}

Referenced by sam_precip_cell_update().

Here is the caller graph for this function:

sam_autoconversion_rates()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources sam_autoconversion_rates ( const amrex::Real &  dtn, const amrex::Real &  qcc, const amrex::Real &  qii, const amrex::Real &  coefice_k  )

noexcept

{
    SAMPrecipSources result{};
    // Thresholded cloud-liquid and cloud-ice autoconversion increments over
    // the microphysics time step dtn. The strict qcw0/qci0 thresholds are
    // intentional: equality leaves the source inactive.
    const amrex::Real auto_r = (qcc > qcw0) ? alphaelq : zero;
    const amrex::Real autos  = (qii > qci0) ? betaelq * coefice_k : zero;
    result.dqca = dtn * auto_r * (qcc - qcw0);
    result.dqia = dtn * autos  * (qii - qci0);
    return result;
}

Referenced by sam_precip_cell_update().

Here is the caller graph for this function:

sam_cloud_ice_terminal_velocity()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_cloud_ice_terminal_velocity ( const amrex::Real &  qci_avg )

noexcept

{
    // MUST MATCH: SAM cloud-ice terminal-velocity coefficient and exponent.
    return amrex::min(amrex::Real(0.4),
                      amrex::Real(8.66) * std::pow((amrex::max(amrex::Real(0.0), qci_avg) + amrex::Real(1.e-10)), amrex::Real(0.24)));
}

Referenced by SAM::IceFall().

Here is the caller graph for this function:

sam_cloud_liquid_fraction()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_cloud_liquid_fraction ( const int &  SAM_moisture_type, const amrex::Real &  tabs, const amrex::Real  an, const amrex::Real  bn  )

noexcept

{
    // Empirical cloud phase-fraction closure for omega_n. No-ice mode forces
    // liquid fraction to one; the warm branch is all liquid, the cold branch
    // is all ice, and the mixed branch varies linearly with temperature.
    if (SAM_moisture_type == 2) {
        return one;
    }
    if (tabs >= tbgmax) {
        return one;
    }
    if (tabs <= tbgmin) {
        return zero;
    }
    return an * tabs - bn;
}

Referenced by SAM::NewtonIterSat(), sam_partition_cloud_phase(), and sam_precip_cell_update().

Here is the caller graph for this function:

sam_compute_coefficient_row()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMCoefficientRow sam_compute_coefficient_row ( const amrex::Real &  rho, const amrex::Real &  tabs, const amrex::Real &  gamr1, const amrex::Real &  gamr2, const amrex::Real &  gams1, const amrex::Real &  gams2, const amrex::Real &  gamg1, const amrex::Real &  gamg2  )

noexcept

{
    // Preserve the SAM baseline formula ordering in these closure rows.
    SAMCoefficientRow row{};
    amrex::Real prefactor;
    amrex::Real pratio = std::sqrt(amrex::Real(1.29) / rho);
    amrex::Real estw = amrex::Real(100.0) * erf_esatw(tabs);
    amrex::Real esti = amrex::Real(100.0) * erf_esati(tabs);
 
    amrex::Real coef1 = fourth * PI * nzeros * a_snow * gams1 * pratio
        / std::pow((PI * rhos * nzeros / rho), ((three + b_snow) / amrex::Real(4.0)));
    amrex::Real coef2 = std::exp(amrex::Real(0.025) * (tabs - amrex::Real(273.15)));
    row.accrsi = coef1 * coef2 * esicoef;
    row.accrsc = coef1 * esccoef;
    row.coefice = coef2;
 
    coef1 = (lsub / (tabs * R_v) - one) * lsub / (therco * tabs);
    coef2 = R_v * R_d / (diffelq * esti);
    prefactor = two * PI * nzeros / (rho * (coef1 + coef2));
    prefactor *= (two / PI);
    row.evaps1 = prefactor * amrex::Real(0.65) * std::sqrt(rho / (PI * rhos * nzeros));
    row.evaps2 = prefactor * amrex::Real(0.44) * std::sqrt(a_snow * rho / muelq) * gams2
        * std::sqrt(pratio) * std::pow(rho / (PI * rhos * nzeros), ((amrex::Real(5.0) + b_snow) / amrex::Real(8.0)));
 
    coef1 = fourth * PI * nzerog * a_grau * gamg1 * pratio
        / std::pow((PI * rhog * nzerog / rho), ((three + b_grau) / amrex::Real(4.0)));
    coef2 = std::exp(amrex::Real(0.025) * (tabs - amrex::Real(273.15)));
    row.accrgi = coef1 * coef2 * egicoef;
    row.accrgc = coef1 * egccoef;
 
    coef1 = (lsub / (tabs * R_v) - one) * lsub / (therco * tabs);
    coef2 = R_v * R_d / (diffelq * esti);
    prefactor = two * PI * nzerog / (rho * (coef1 + coef2));
    row.evapg1 = prefactor * amrex::Real(0.78) * std::sqrt(rho / (PI * rhog * nzerog));
    row.evapg2 = prefactor * amrex::Real(0.31) * std::sqrt(a_grau * rho / muelq) * gamg2
        * std::sqrt(pratio) * std::pow(rho / (PI * rhog * nzerog), ((amrex::Real(5.0) + b_grau) / amrex::Real(8.0)));
 
    row.accrrc = fourth * PI * nzeror * a_rain * gamr1 * pratio
        / std::pow((PI * rhor * nzeror / rho), ((three + b_rain) / amrex::Real(4.0))) * erccoef;
 
    coef1 = (lcond / (tabs * R_v) - one) * lcond / (therco * tabs);
    coef2 = R_v * R_d / (diffelq * estw);
    prefactor = two * PI * nzeror / (rho * (coef1 + coef2));
    row.evapr1 = prefactor * amrex::Real(0.78) * std::sqrt(rho / (PI * rhor * nzeror));
    row.evapr2 = prefactor * amrex::Real(0.31) * std::sqrt(a_rain * rho / muelq) * gamr2
        * std::sqrt(pratio) * std::pow(rho / (PI * rhor * nzeror), ((amrex::Real(5.0) + b_rain) / amrex::Real(8.0)));
    return row;
}

Referenced by SAM::Compute_Coefficients().

Here is the call graph for this function:

Here is the caller graph for this function:

sam_cons_to_primitive()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrimitiveCell sam_cons_to_primitive ( const amrex::Real &  rho, const amrex::Real &  rho_theta, const amrex::Real &  rho_qv, const amrex::Real &  rho_qcl, const amrex::Real &  rho_qci, const amrex::Real &  rho_qpr, const amrex::Real &  rho_qps, const amrex::Real &  rho_qpg  )

noexcept

{
    // Copy-in reconstructs the SAM primitive cell state from the conserved ERF
    // state, clips negative moisture defensively, and diagnoses tabs and
    // pres_mbar from the incoming rho*theta/rho*q state. That diagnosed mbar
    // pressure is the held pressure for the following source updates.
    SAMPrimitiveCell result{};
    result.rho = rho;
    result.theta = rho_theta / rho;
    result.qv = amrex::max(amrex::Real(0.0), rho_qv / rho);
    result.qcl = amrex::max(amrex::Real(0.0), rho_qcl / rho);
    result.qci = amrex::max(amrex::Real(0.0), rho_qci / rho);
    result.qn = result.qcl + result.qci;
    result.qt = result.qv + result.qn;
    result.qpr = amrex::max(amrex::Real(0.0), rho_qpr / rho);
    result.qps = amrex::max(amrex::Real(0.0), rho_qps / rho);
    result.qpg = amrex::max(amrex::Real(0.0), rho_qpg / rho);
    result.qp = result.qpr + result.qps + result.qpg;
    result.tabs = getTgivenRandRTh(rho, rho_theta, result.qv);
    result.pres_mbar = sam_pa_to_mbar(getPgivenRTh(rho_theta, result.qv));
    return result;
}

Referenced by SAM::Copy_State_to_Micro().

Here is the call graph for this function:

Here is the caller graph for this function:

sam_face_average_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMFaceState sam_face_average_state ( const int &  k, const int &  k_lo, const int &  k_hi, const amrex::Real &  rho_km1, const amrex::Real &  rho_k, const amrex::Real  tabs_km1, const amrex::Real  tabs_k, const amrex::Real &  qci_km1, const amrex::Real &  qci_k, const amrex::Real  qp_km1, const amrex::Real  qp_k  )

noexcept

{
    SAMFaceState result{};
    if (k == k_lo) {
        result.rho_avg = rho_k;
        result.tabs_avg = tabs_k;
        result.qci_avg = qci_k;
        result.qp_avg = qp_k;
    } else if (k == k_hi + 1) {
        result.rho_avg = rho_km1;
        result.tabs_avg = tabs_km1;
        result.qci_avg = qci_km1;
        result.qp_avg = qp_km1;
    } else {
        result.rho_avg = myhalf * (rho_km1 + rho_k);
        result.tabs_avg = myhalf * (tabs_km1 + tabs_k);
        result.qci_avg = myhalf * (qci_km1 + qci_k);
        result.qp_avg = myhalf * (qp_km1 + qp_k);
    }
    return result;
}

Referenced by SAM::IceFall().

Here is the caller graph for this function:

sam_graupel_fraction()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_graupel_fraction ( const int &  SAM_moisture_type, const amrex::Real &  tabs  )

noexcept

{
    // Empirical graupel fraction omega_g. No-ice mode forces graupel fraction
    // to zero, and the result is clipped to [0, 1].
    if (SAM_moisture_type == 2) {
        return zero;
    }
    return amrex::max(amrex::Real(0.0), amrex::min(amrex::Real(1.0), (tabs - tgrmin) * a_gr));
}

Referenced by sam_precip_cell_update(), and sam_precip_face_state().

Here is the caller graph for this function:

sam_is_no_ice()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool sam_is_no_ice ( const MoistureType &  moisture_type )

noexcept

{
    return moisture_type == MoistureType::SAM_NoIce ||
           moisture_type == MoistureType::SAM_NoPrecip_NoIce;
}

Referenced by SAM::Cloud(), and SAM::IceFall().

Here is the caller graph for this function:

sam_is_no_precip()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool sam_is_no_precip ( const MoistureType &  moisture_type )

noexcept

{
    return moisture_type == MoistureType::SAM_NoPrecip_NoIce;
}

Referenced by SAM::Precip(), and SAM::PrecipFall().

Here is the caller graph for this function:

sam_limit_precip_component_flux()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_limit_precip_component_flux ( const amrex::Real &  raw_flux, const amrex::Real &  rho_donor, const amrex::Real &  q_donor, const amrex::Real &  detJ_donor, const amrex::Real &  coef  )

noexcept

{
    const amrex::Real available_flux =
        rho_donor * amrex::max(amrex::Real(0.0), q_donor) * detJ_donor / coef;
    return amrex::min(raw_flux, available_flux);
}

Referenced by SAM::PrecipFall().

Here is the caller graph for this function:

sam_mbar_to_pa()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_mbar_to_pa ( const amrex::Real &  pres_mbar )

noexcept

{
    // SAM stores pressure in mbar. EOS and theta helpers expect Pa.
    return amrex::Real(100.0) * pres_mbar;
}

Referenced by sam_theta_from_stored_mbar_converted_to_pa().

Here is the caller graph for this function:

sam_mixed_dqif_dT()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_mixed_dqif_dT ( const amrex::Real &  omn, const amrex::Real &  domn, const amrex::Real &  qn, const amrex::Real &  dqsatm  )

noexcept

{
    // Temperature derivative of the final ice fraction
    return -domn * qn - (one - omn) * dqsatm;
}

Referenced by SAM::NewtonIterSat().

Here is the caller graph for this function:

sam_mixed_dqsat_dT()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_mixed_dqsat_dT ( const amrex::Real &  omn, const amrex::Real &  domn, const amrex::Real &  qsatw, const amrex::Real &  qsati, const amrex::Real &  dqsatw, const amrex::Real &  dqsati  )

noexcept

{
    // Temperature derivative of mixed saturation, including the mixed-branch
    // temperature derivative of the liquid/ice phase fraction.
    return omn * dqsatw + (one - omn) * dqsati + domn * qsatw - domn * qsati;
}

Referenced by SAM::NewtonIterSat().

Here is the caller graph for this function:

sam_mixed_qsat()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_mixed_qsat ( const amrex::Real &  omn, const amrex::Real &  qsatw, const amrex::Real &  qsati  )

noexcept

{
    // Mixed liquid/ice saturation relation used by the SAM cloud adjustment.
    return omn * qsatw + (one - omn) * qsati;
}

Referenced by SAM::Cloud(), SAM::NewtonIterSat(), and sam_precip_cell_update().

Here is the caller graph for this function:

sam_newton_residual()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_newton_residual ( const amrex::Real &  tabs_new, const amrex::Real &  tabs_old, const amrex::Real  fcond, const amrex::Real &  qv, const amrex::Real &  qsatm, const amrex::Real  ffus, const amrex::Real &  qi, const amrex::Real &  qif  )

noexcept

{
    // Residual for the local constant-pressure saturation adjustment solve.
    return -tabs_new + tabs_old + fcond * (qv - qsatm) - ffus * (qi - qif);
}

Referenced by SAM::NewtonIterSat().

Here is the caller graph for this function:

sam_newton_residual_derivative()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_newton_residual_derivative ( const amrex::Real  fcond, const amrex::Real  ffus, const amrex::Real &  dqsatm, const amrex::Real &  dqif  )

noexcept

{
    // Derivative for the local constant-pressure saturation adjustment solve.
    return -one - fcond * dqsatm + ffus * dqif;
}

Referenced by SAM::NewtonIterSat().

Here is the caller graph for this function:

sam_pa_to_mbar()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_pa_to_mbar ( const amrex::Real &  pres_pa )

noexcept

{
    return amrex::Real(0.01) * pres_pa;
}

Referenced by SAM::Compute_Coefficients(), and sam_cons_to_primitive().

Here is the caller graph for this function:

sam_partition_autoconverted_precip()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources sam_partition_autoconverted_precip ( SAMPrecipSources  result, const amrex::Real &  omp, const amrex::Real &  omg  )

noexcept

{
    // Partitions limited autoconversion sources into rain/snow/graupel using
    // the precipitating phase fractions and adds direct accretion
    // contributions. dqpr + dqps + dqpg equals the limited cloud sink total.
    result.dqpr = (result.dqca + result.dqia) * omp + result.dprc;
    result.dqps = (result.dqca + result.dqia) * (one - omp) * (one - omg) + result.dpsc + result.dpsi;
    result.dqpg = (result.dqca + result.dqia) * (one - omp) * omg + result.dpgc + result.dpgi;
    return result;
}

Referenced by sam_precip_cell_update().

Here is the caller graph for this function:

sam_partition_cloud_phase()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMCloudPhaseChange sam_partition_cloud_phase ( const int &  SAM_moisture_type, const amrex::Real &  tabs, const amrex::Real &  qn, const amrex::Real &  qcl, const amrex::Real &  qci, const amrex::Real  fac_cond, const amrex::Real  fac_fus, const amrex::Real  an, const amrex::Real  bn  )

noexcept

{
    // Repartition cloud condensate between liquid and ice using omega_n while
    // preserving total cloud condensate qn. The temperature increment accounts
    // for fusion heating/cooling under the held-pressure source-step
    // convention; no-ice mode collapses condensate into liquid.
    SAMCloudPhaseChange result{};
    result.qcl = qcl;
    result.qci = qci;
    result.tabs = tabs;
    result.omn = sam_cloud_liquid_fraction(SAM_moisture_type, tabs, an, bn);
 
    if (SAM_moisture_type == 1) {
        if (tabs >= tbgmax) {
            result.omn = one;
            result.delta_qi = qci;
            result.qci = zero;
            result.qcl += result.delta_qi;
            result.tabs -= fac_fus * result.delta_qi;
        } else if (tabs <= tbgmin) {
            result.omn = zero;
            result.delta_qc = qcl;
            result.qcl = zero;
            result.qci += result.delta_qc;
            result.tabs += fac_fus * result.delta_qc;
        } else {
            result.delta_qc = qcl - qn * result.omn;
            result.delta_qi = qci - qn * (one - result.omn);
            result.qcl = qn * result.omn;
            result.qci = qn * (one - result.omn);
            result.tabs += fac_fus * result.delta_qc;
            result.omn = sam_cloud_liquid_fraction(SAM_moisture_type, result.tabs, an, bn);
        }
    } else {
        result.omn = one;
        result.delta_qc = qcl - qn;
        result.qcl = qn;
        result.qci = zero;
        result.tabs += fac_cond * result.delta_qc;
    }
 
    result.qn = result.qcl + result.qci;
    return result;
}

Referenced by SAM::Cloud().

Here is the call graph for this function:

Here is the caller graph for this function:

sam_precip_cell_update()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMCellState sam_precip_cell_update ( SAMCellState  state, const SAMCoefficientRow &  coeffs, const SAMPrecipConfig &  config, SAMPrecipCellDiagnostics *  diagnostics = nullptr  )

noexcept

{
    // Local SAM precipitation source update. This is a cell-local,
    // held-pressure microphysics update; sedimentation and surface
    // accumulation are handled in PrecipFall. Before sedimentation, the source
    // terms exchange water among qv/qcl/qci/qpr/qps/qpg, conserve total water,
    // and conserve the constant-pressure latent proxy
    // tabs + fac_cond*qv - fac_fus*(qci + qps + qpg)
    // up to limiter and roundoff effects.
    if (diagnostics != nullptr) {
        *diagnostics = {};
    }
 
    state.qn = state.qcl + state.qci;
    state.qt = state.qv  + state.qn;
    state.qp = state.qpr + state.qps + state.qpg;
 
    if (!config.enable_precip || state.qn + state.qp <= zero) {
        return state;
    }
 
    amrex::Real omn;
    amrex::Real omp;
    amrex::Real omg;
    if (config.sam_moisture_type == 2) {
        omn = one;
        omp = one;
        omg = zero;
    } else {
        omn = sam_cloud_liquid_fraction(config.sam_moisture_type,
                                        state.tabs, a_bg, tbgmin * a_bg);
        omp = sam_precip_rain_fraction(config.sam_moisture_type,
                                       state.tabs);
        omg = sam_graupel_fraction(config.sam_moisture_type,
                                   state.tabs);
    }
 
    if (diagnostics != nullptr) {
        diagnostics->omn = omn;
        diagnostics->omp = omp;
        diagnostics->omg = omg;
    }
 
    if (state.qn > zero) {
        SAMPrecipSources source_terms =
            sam_autoconversion_rates(config.dtn, state.qcl, state.qci, coeffs.coefice);
        const SAMPrecipSources accretion_terms =
            sam_accretion_rates(config.dtn, state.qcl, state.qci, state.qpr, state.qps, state.qpg,
                                config.powr1, config.pows1, config.powg1,
                                omp, omg,
                                coeffs.accrrc, coeffs.accrsc, coeffs.accrsi,
                                coeffs.accrgc, coeffs.accrgi);
        if (diagnostics != nullptr) {
            diagnostics->autoconversion = source_terms;
            diagnostics->accretion = accretion_terms;
        }
 
        source_terms.dprc = accretion_terms.dprc;
        source_terms.dpsc = accretion_terms.dpsc;
        source_terms.dpgc = accretion_terms.dpgc;
        source_terms.dpsi = accretion_terms.dpsi;
        source_terms.dpgi = accretion_terms.dpgi;
        source_terms = sam_rescale_cloud_sinks(state.qcl, state.qci,
                                               config.eps, source_terms);
        if (diagnostics != nullptr) {
            diagnostics->limited_sources = source_terms;
        }
 
        source_terms = sam_partition_autoconverted_precip(source_terms, omp, omg);
        if (diagnostics != nullptr) {
            diagnostics->partitioned_sources = source_terms;
        }
 
        const amrex::Real dqca = source_terms.dqca;
        const amrex::Real dqia = source_terms.dqia;
 
        state.qcl -= source_terms.dqc;
        state.qci -= source_terms.dqi;
        state.qpr += source_terms.dqpr;
        state.qps += source_terms.dqps;
        state.qpg += source_terms.dqpg;
 
        state.qn = state.qcl + state.qci;
        state.qt = state.qv + state.qn;
        state.qp = state.qpr + state.qps + state.qpg;
 
        // Cloud-liquid accretion onto snow and graupel increases frozen mass
        // and must contribute the same fusion-heating term to the local latent
        // proxy as the autoconverted frozen branch.
        state.tabs += config.fac_fus * (dqca * (one - omp) - dqia * omp
                          + source_terms.dpsc + source_terms.dpgc);
        state.theta = sam_theta_from_stored_mbar_converted_to_pa(state.tabs,
                                                                 state.pres_mbar,
                                                                 config.rdOcp);
    }
 
    amrex::Real qsatw;
    amrex::Real qsati;
    erf_qsatw(state.tabs, state.pres_mbar, qsatw);
    erf_qsati(state.tabs, state.pres_mbar, qsati);
    const amrex::Real qsat = sam_mixed_qsat(omn, qsatw, qsati);
    if (diagnostics != nullptr) {
        diagnostics->qsat = qsat;
    }
 
    if (state.qp > zero && state.qv < qsat) {
        SAMPrecipSources evaporation_terms =
            sam_precip_evaporation_rates(state.qpr, state.qps, state.qpg,
                                         config.powr2, config.pows2, config.powg2,
                                         coeffs.evapr1, coeffs.evapr2,
                                         coeffs.evaps1, coeffs.evaps2,
                                         coeffs.evapg1, coeffs.evapg2);
 
        const amrex::Real supersat_factor = config.dtn * (one - state.qv / qsat);
        evaporation_terms.dqpr *= supersat_factor;
        evaporation_terms.dqps *= supersat_factor;
        evaporation_terms.dqpg *= supersat_factor;
        evaporation_terms = sam_apply_precip_evaporation_limiter(state.qpr,
                                                                 state.qps,
                                                                 state.qpg,
                                                                 evaporation_terms);
        if (diagnostics != nullptr) {
            diagnostics->evaporation = evaporation_terms;
        }
 
        state.qv += evaporation_terms.dqp;
        state.qpr -= evaporation_terms.dqpr;
        state.qps -= evaporation_terms.dqps;
        state.qpg -= evaporation_terms.dqpg;
 
        state.qt = state.qv + state.qn;
        state.qp = state.qpr + state.qps + state.qpg;
 
        // Rain evaporation cools with Lv/cp; snow and graupel sublimation cool
        // with Ls/cp, preserving the same local latent proxy.
        state.tabs -= config.fac_cond * evaporation_terms.dqpr
                    + config.fac_sub * (evaporation_terms.dqps + evaporation_terms.dqpg);
        state.theta = sam_theta_from_stored_mbar_converted_to_pa(state.tabs,
                                                                 state.pres_mbar,
                                                                 config.rdOcp);
    }
 
    return state;
}

Referenced by SAM::Precip().

Here is the call graph for this function:

Here is the caller graph for this function:

sam_precip_component_face_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipComponentFaceState sam_precip_component_face_state ( const amrex::Array4< const amrex::Real > &  rho_array, const amrex::Array4< const amrex::Real > &  tabs_array, const amrex::Array4< const amrex::Real > &  qpr_array, const amrex::Array4< const amrex::Real > &  qps_array, const amrex::Array4< const amrex::Real > &  qpg_array, const int &  i, const int &  j, const int &  k, const int &  k_lo, const int &  k_hi  )

noexcept

{
    // MUST MATCH: SAM PrecipFall bottom/interior/top face rules.
    SAMPrecipComponentFaceState result{};
    if (k == k_lo) {
        result.rho_avg = rho_array(i,j,k);
        result.tabs_avg = tabs_array(i,j,k);
        result.qpr_avg = qpr_array(i,j,k);
        result.qps_avg = qps_array(i,j,k);
        result.qpg_avg = qpg_array(i,j,k);
    } else if (k == k_hi + 1) {
        result.rho_avg = rho_array(i,j,k-1);
        result.tabs_avg = tabs_array(i,j,k-1);
        result.qpr_avg = qpr_array(i,j,k-1);
        result.qps_avg = qps_array(i,j,k-1);
        result.qpg_avg = qpg_array(i,j,k-1);
    } else {
        result.rho_avg = myhalf * (rho_array(i,j,k-1) + rho_array(i,j,k));
        result.tabs_avg = myhalf * (tabs_array(i,j,k-1) + tabs_array(i,j,k));
        result.qpr_avg = myhalf * (qpr_array(i,j,k-1) + qpr_array(i,j,k));
        result.qps_avg = myhalf * (qps_array(i,j,k-1) + qps_array(i,j,k));
        result.qpg_avg = myhalf * (qpg_array(i,j,k-1) + qpg_array(i,j,k));
    }
    return result;
}

Referenced by SAM::PrecipFall().

Here is the caller graph for this function:

sam_precip_component_fluxes_from_face_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFluxComponents sam_precip_component_fluxes_from_face_state ( const SAMPrecipComponentFaceState &  face_state, const amrex::Real &  vrain, const amrex::Real &  vsnow, const amrex::Real &  vgrau  )

noexcept

{
    SAMPrecipFluxComponents result{};
    if (face_state.qpr_avg > zero) {
        result.rain = vrain * std::pow(face_state.rho_avg * face_state.qpr_avg, one + crain);
    }
    if (face_state.qps_avg > zero) {
        result.snow = vsnow * std::pow(face_state.rho_avg * face_state.qps_avg, one + csnow);
    }
    if (face_state.qpg_avg > zero) {
        result.graupel = vgrau * std::pow(face_state.rho_avg * face_state.qpg_avg, one + cgrau);
    }
    return result;
}

Referenced by SAM::PrecipFall().

Here is the caller graph for this function:

sam_precip_evaporation_rates()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources sam_precip_evaporation_rates ( const amrex::Real &  qpr, const amrex::Real &  qps, const amrex::Real &  qpg, const amrex::Real &  powr2, const amrex::Real &  pows2, const amrex::Real &  powg2, const amrex::Real &  evapr1_k, const amrex::Real &  evapr2_k, const amrex::Real &  evaps1_k, const amrex::Real &  evaps2_k, const amrex::Real &  evapg1_k, const amrex::Real &  evapg2_k  )

noexcept

{
    // Positive-domain evaporation/sublimation rate form for precipitating
    // species: C1*sqrt(q_m) + C2*q_m^p. The derivative is singular at q_m = 0,
    // so derivative checks only make sense away from zero.
    SAMPrecipSources result{};
    result.dqpr = evapr1_k * std::sqrt(qpr) + evapr2_k * std::pow(qpr, powr2);
    result.dqps = evaps1_k * std::sqrt(qps) + evaps2_k * std::pow(qps, pows2);
    result.dqpg = evapg1_k * std::sqrt(qpg) + evapg2_k * std::pow(qpg, powg2);
    return result;
}

Referenced by sam_precip_cell_update().

Here is the caller graph for this function:

sam_precip_face_donor_k()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int sam_precip_face_donor_k ( const int &  face_k, const int &  k_lo, const int &  k_hi  )

noexcept

{
    if (face_k <= k_lo) {
        return k_lo;
    }
    if (face_k >= k_hi + 1) {
        return k_hi;
    }
    return face_k;
}

Referenced by SAM::PrecipFall().

Here is the caller graph for this function:

sam_precip_face_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFaceState sam_precip_face_state ( const int &  SAM_moisture_type, const amrex::Array4< const amrex::Real > &  rho_array, const amrex::Array4< const amrex::Real > &  tabs_array, const amrex::Array4< const amrex::Real > &  qp_array, const int &  i, const int &  j, const int &  k, const int &  k_lo, const int &  k_hi  )

noexcept

{
    // MUST MATCH: SAM PrecipFall bottom/interior/top face rules.
    SAMPrecipFaceState result{};
    if (k == k_lo) {
        result.rho_avg = rho_array(i,j,k);
        result.tabs_avg = tabs_array(i,j,k);
        result.qp_avg = qp_array(i,j,k);
    } else if (k == k_hi + 1) {
        result.rho_avg = rho_array(i,j,k-1);
        result.tabs_avg = tabs_array(i,j,k-1);
        result.qp_avg = qp_array(i,j,k-1);
    } else {
        result.rho_avg = myhalf * (rho_array(i,j,k-1) + rho_array(i,j,k));
        result.tabs_avg = myhalf * (tabs_array(i,j,k-1) + tabs_array(i,j,k));
        result.qp_avg = myhalf * (qp_array(i,j,k-1) + qp_array(i,j,k));
    }
    result.omp = sam_precip_rain_fraction(SAM_moisture_type, result.tabs_avg);
    result.omg = sam_graupel_fraction(SAM_moisture_type, result.tabs_avg);
    result.qrr = result.omp * result.qp_avg;
    result.qss = (one - result.omp) * (one - result.omg) * result.qp_avg;
    result.qgg = (one - result.omp) * result.omg * result.qp_avg;
    return result;
}

Here is the call graph for this function:

sam_precip_flux_components_density_corrected()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFluxComponents sam_precip_flux_components_density_corrected ( const SAMPrecipFluxComponents &  precip_fluxes, const amrex::Real &  rho_0, const amrex::Real &  rho_avg  )

noexcept

{
    const amrex::Real density_correction = std::sqrt(rho_0 / rho_avg);
    return {
        precip_fluxes.rain * density_correction,
        precip_fluxes.snow * density_correction,
        precip_fluxes.graupel * density_correction};
}

Referenced by SAM::PrecipFall(), and sam_surface_accumulation().

Here is the caller graph for this function:

sam_precip_flux_components_from_face_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipFluxComponents sam_precip_flux_components_from_face_state ( const SAMPrecipFaceState &  face_state, const amrex::Real &  vrain, const amrex::Real &  vsnow, const amrex::Real &  vgrau  )

noexcept

{
    SAMPrecipFluxComponents result{};
    if (face_state.qp_avg <= qp_threshold) {
        return result;
    }
 
    result.rain = face_state.omp * vrain * std::pow(face_state.rho_avg * face_state.qrr, one + crain);
    result.snow = (one - face_state.omp) * (one - face_state.omg)
        * vsnow * std::pow(face_state.rho_avg * face_state.qss, one + csnow);
    result.graupel = (one - face_state.omp) * face_state.omg
        * vgrau * std::pow(face_state.rho_avg * face_state.qgg, one + cgrau);
    return result;
}

Referenced by sam_surface_accumulation().

Here is the caller graph for this function:

sam_precip_flux_density_corrected()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_precip_flux_density_corrected ( const amrex::Real &  precip_flux, const amrex::Real &  rho_0, const amrex::Real &  rho_avg  )

noexcept

{
    return precip_flux * std::sqrt(rho_0 / rho_avg);
}

sam_precip_flux_from_face_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_precip_flux_from_face_state ( const SAMPrecipFaceState &  face_state, const amrex::Real &  vrain, const amrex::Real &  vsnow, const amrex::Real &  vgrau  )

noexcept

{
    if (face_state.qp_avg <= qp_threshold) {
        return zero;
    }
    return face_state.omp * vrain * std::pow(face_state.rho_avg * face_state.qrr, one + crain)
        + (one - face_state.omp)
            * ((one - face_state.omg) * vsnow * std::pow(face_state.rho_avg * face_state.qss, one + csnow)
               + face_state.omg * vgrau * std::pow(face_state.rho_avg * face_state.qgg, one + cgrau));
}

sam_precip_rain_fraction()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_precip_rain_fraction ( const int &  SAM_moisture_type, const amrex::Real &  tabs  )

noexcept

{
    // Empirical precipitating rain fraction omega_p. No-ice mode forces rain
    // fraction to one, and the result is clipped to [0, 1].
    if (SAM_moisture_type == 2) {
        return one;
    }
    return amrex::max(amrex::Real(0.0), amrex::min(amrex::Real(1.0), (tabs - tprmin) * a_pr));
}

Referenced by sam_precip_cell_update(), and sam_precip_face_state().

Here is the caller graph for this function:

sam_primitive_to_cons()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void sam_primitive_to_cons ( const SAMPrimitiveCell &  primitive, const amrex::Array4< amrex::Real > &  states_arr, const int &  i, const int &  j, const int &  k  )

noexcept

{
    // Copy-out writes rho*theta and clipped moisture species back to the
    // conserved state. Pressure is not stored here; it is diagnosed again on
    // the next copy-in.
    states_arr(i,j,k,RhoTheta_comp) = primitive.rho * primitive.theta;
    states_arr(i,j,k,RhoQ1_comp) = primitive.rho * amrex::max(amrex::Real(0.0), primitive.qv);
    states_arr(i,j,k,RhoQ2_comp) = primitive.rho * amrex::max(amrex::Real(0.0), primitive.qcl);
    states_arr(i,j,k,RhoQ3_comp) = primitive.rho * amrex::max(amrex::Real(0.0), primitive.qci);
    states_arr(i,j,k,RhoQ4_comp) = primitive.rho * amrex::max(amrex::Real(0.0), primitive.qpr);
    states_arr(i,j,k,RhoQ5_comp) = primitive.rho * amrex::max(amrex::Real(0.0), primitive.qps);
    states_arr(i,j,k,RhoQ6_comp) = primitive.rho * amrex::max(amrex::Real(0.0), primitive.qpg);
}

Referenced by SAM::Copy_Micro_to_State().

Here is the caller graph for this function:

sam_rescale_cloud_sinks()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMPrecipSources sam_rescale_cloud_sinks ( const amrex::Real &  qcl, const amrex::Real &  qci, const amrex::Real &  eps, SAMPrecipSources  result  )

noexcept

{
    // Proportional donor limiter. If requested liquid or ice sinks exceed
    // available qcl/qci, all competing sinks from the same donor phase share
    // one scale factor. This preserves source ratios while preventing negative
    // qcl or qci. The eps denominator intentionally leaves only an epsilon-
    // scale undershoot.
    result.dqc = result.dqca + result.dprc + result.dpsc + result.dpgc;
    result.dqi = result.dqia + result.dpsi + result.dpgi;
 
    const amrex::Real scalec = amrex::min(qcl, result.dqc) / (result.dqc + eps);
    const amrex::Real scalei = amrex::min(qci, result.dqi) / (result.dqi + eps);
 
    result.dqca *= scalec;
    result.dprc *= scalec;
    result.dpsc *= scalec;
    result.dpgc *= scalec;
    result.dqia *= scalei;
    result.dpsi *= scalei;
    result.dpgi *= scalei;
    result.dqc = result.dqca + result.dprc + result.dpsc + result.dpgc;
    result.dqi = result.dqia + result.dpsi + result.dpgi;
 
    return result;
}

Referenced by sam_precip_cell_update().

Here is the caller graph for this function:

sam_sedimentation_tendency()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_sedimentation_tendency ( const amrex::Real &  fz_hi, const amrex::Real &  fz_lo, const amrex::Real &  rho, const amrex::Real &  dJinv, const amrex::Real &  coef  )

noexcept

{
    return dJinv * (one / rho) * (fz_hi - fz_lo) * coef;
}

Referenced by SAM::IceFall(), and SAM::PrecipFall().

Here is the caller graph for this function:

sam_substep_count_from_reduced_flux()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int sam_substep_count_from_reduced_flux ( const amrex::Real &  reduced_flux, const amrex::Real &  dt, const amrex::Real &  dz  )

noexcept

{
    // Substeps follow the legacy reduced-flux rule based on the maximum
    // density-corrected precip flux, not directly on a terminal fall speed.
    // Property tests characterize this behavior before any intended change.
    // MUST MATCH: SAM::CFL_MAX.
    return static_cast<int>(std::ceil(reduced_flux * (dt / dz) / myhalf));
}

Referenced by SAM::IceFall(), and SAM::PrecipFall().

Here is the caller graph for this function:

sam_surface_accumulation()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMSurfaceAccumulation sam_surface_accumulation ( const SAMPrecipFaceState &  face_state, const amrex::Real &  rho_0, const amrex::Real &  vrain, const amrex::Real &  vsnow, const amrex::Real &  vgrau, const amrex::Real &  dtn  )

noexcept

{
    const SAMPrecipFluxComponents face_fluxes =
        sam_precip_flux_components_from_face_state(face_state, vrain, vsnow, vgrau);
 
    return sam_surface_accumulation_from_component_fluxes(
        sam_precip_flux_components_density_corrected(face_fluxes, rho_0, face_state.rho_avg),
        dtn);
}

Here is the call graph for this function:

sam_surface_accumulation_from_component_fluxes()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE SAMSurfaceAccumulation sam_surface_accumulation_from_component_fluxes ( const SAMPrecipFluxComponents &  component_fluxes, const amrex::Real &  dtn  )

noexcept

{
    SAMSurfaceAccumulation result{};
    result.rain = component_fluxes.rain * dtn / rhor * amrex::Real(1000.0);
    result.snow = component_fluxes.snow * dtn / rhos * amrex::Real(1000.0);
    result.graupel = component_fluxes.graupel * dtn / rhog * amrex::Real(1000.0);
    return result;
}

Referenced by SAM::PrecipFall(), and sam_surface_accumulation().

Here is the caller graph for this function:

sam_theta_from_stored_mbar_converted_to_pa()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real sam_theta_from_stored_mbar_converted_to_pa ( const amrex::Real &  tabs, const amrex::Real &  pres_mbar, const amrex::Real  rdOcp  )

noexcept

{
    // Do not replace this with getThgivenRandT(rho,T,qv): that would enforce a
    // fixed-density EOS projection rather than the SAM source-step
    // thermodynamic contract.
    return getThgivenTandP(tabs, sam_mbar_to_pa(pres_mbar), rdOcp);
}

Referenced by SAM::Cloud(), and sam_precip_cell_update().

Here is the call graph for this function:

Here is the caller graph for this function: