ShocPDF Class Reference

#include <ERF_ShocPDF.H>

Static Public Member Functions
static void	diagnose_pdf (ShocColumnData &col, const ShocRuntimeOptions &opts, double dt)

Member Function Documentation

diagnose_pdf()

void ShocPDF::diagnose_pdf ( ShocColumnData &  col, const ShocRuntimeOptions &  opts, double  dt  )

static

{
    // Interim native-SHOC contract: this PDF remains liquid-cloud
    // macrophysics. It may carry pre-existing ice through the thermodynamic
    // state, but it does not create or repartition cloud ice here.
    FArrayBox w3_zt, thl_sec_zt, qw_sec_zt, wthl_zt, wqw_zt, qwthl_zt;
    const auto layout = col.layout;
    const Box cell_box(IntVect(0,0,0), IntVect(layout.ncell - 1, layout.nlev - 1, 0));
    w3_zt.resize(cell_box, 1, The_Async_Arena());
    thl_sec_zt.resize(cell_box, 1, The_Async_Arena());
    qw_sec_zt.resize(cell_box, 1, The_Async_Arena());
    wthl_zt.resize(cell_box, 1, The_Async_Arena());
    wqw_zt.resize(cell_box, 1, The_Async_Arena());
    qwthl_zt.resize(cell_box, 1, The_Async_Arena());
 
    {
        BL_PROFILE("SHOC::advance::pdf::interpolate");
        interpolate_iface_to_cc(col, col.w3, w3_zt, shoc_large_neg());
        interpolate_iface_to_cc(col, col.thl_sec, thl_sec_zt, 0.0_rt);
        interpolate_iface_to_cc(col, col.qw_sec, qw_sec_zt, 0.0_rt);
        interpolate_iface_to_cc(col, col.wthl_sec, wthl_zt, shoc_large_neg());
        interpolate_iface_to_cc(col, col.wqw_sec, wqw_zt, shoc_large_neg());
        interpolate_iface_to_cc(col, col.qwthl_sec, qwthl_zt, shoc_large_neg());
    }
 
    auto shoc_cldfrac = col.shoc_cldfrac.array();
    auto shoc_ql = col.shoc_ql.array();
    auto shoc_ql2 = col.shoc_ql2.array();
    auto shoc_cond = col.shoc_cond.array();
    auto shoc_evap = col.shoc_evap.array();
    auto wqls_sec = col.wqls_sec.array();
    auto wthv_sec = col.wthv_sec.array();
 
    const auto thetal = col.thetal.const_array();
    const auto qw = col.qw.const_array();
    const auto w_field = col.w.const_array();
    const auto p_mid = col.p_mid.const_array();
    const auto thl_sec = thl_sec_zt.const_array();
    const auto qw_sec = qw_sec_zt.const_array();
    const auto qwthl_sec = qwthl_zt.const_array();
    const auto wthl_sec = wthl_zt.const_array();
    const auto wqw_sec = wqw_zt.const_array();
    const auto w_sec = col.w_sec.const_array();
    const auto w3 = w3_zt.const_array();
 
    {
        BL_PROFILE("SHOC::advance::pdf::main_kernel");
        ParallelFor(cell_box, [=] AMREX_GPU_DEVICE (int ic, int k, int) noexcept
        {
            const Real thl_first = thetal(ic,k,0);
            const Real qw_first = qw(ic,k,0);
            const Real w_first = w_field(ic,k,0);
            const Real w2sec = amrex::max(w_sec(ic,k,0), 0.0_rt);
            const Real sqrtw2 = std::sqrt(w2sec);
            const Real sqrtthl = amrex::max(shoc_thl_tol(), std::sqrt(amrex::max(thl_sec(ic,k,0), 0.0_rt)));
            const Real sqrtqt = amrex::max(shoc_rt_tol(), std::sqrt(amrex::max(qw_sec(ic,k,0), 0.0_rt)));
 
            Real skew_w = 0.0, w1_1 = w_first, w1_2 = w_first, w2_1 = 0.0, w2_2 = 0.0, a = 0.5;
            vv_parameters(w_first, w2sec, w3(ic,k,0), skew_w, w1_1, w1_2, w2_1, w2_2, a);
 
            Real thl1_1 = thl_first, thl1_2 = thl_first, thl2_1 = 0.0, thl2_2 = 0.0;
            Real sqrtthl2_1 = 0.0, sqrtthl2_2 = 0.0;
            thl_parameters(wthl_sec(ic,k,0), sqrtw2, sqrtthl, amrex::max(thl_sec(ic,k,0), 0.0_rt),
                           thl_first, w1_1, w1_2, skew_w, a,
                           thl1_1, thl1_2, thl2_1, thl2_2, sqrtthl2_1, sqrtthl2_2);
 
            Real qw1_1 = qw_first, qw1_2 = qw_first, qw2_1 = 0.0, qw2_2 = 0.0;
            Real sqrtqw2_1 = 0.0, sqrtqw2_2 = 0.0;
            qw_parameters(wqw_sec(ic,k,0), sqrtw2, skew_w, sqrtqt, amrex::max(qw_sec(ic,k,0), 0.0_rt),
                          w1_2, w1_1, qw_first, a,
                          qw1_1, qw1_2, qw2_1, qw2_2, sqrtqw2_1, sqrtqw2_2);
 
            w1_1 = w1_1 * sqrtw2 + w_first;
            w1_2 = w1_2 * sqrtw2 + w_first;
 
            const Real r_qwthl_1 = inplume_correlation(sqrtqw2_1, sqrtthl2_1, a,
                                                       sqrtqw2_2, sqrtthl2_2,
                                                       qwthl_sec(ic,k,0), qw1_1, qw_first,
                                                       thl1_1, thl_first, qw1_2, thl1_2);
 
            Real Tl1_1 = amrex::max(shoc_tl_min(), compute_temperature(thl1_1, p_mid(ic,k,0)));
            Real Tl1_2 = amrex::max(shoc_tl_min(), compute_temperature(thl1_2, p_mid(ic,k,0)));
            Real qs1 = 0.0_rt, beta1 = 0.0_rt, qs2 = 0.0_rt, beta2 = 0.0_rt;
            compute_qs_beta(Tl1_1, p_mid(ic,k,0), qs1, beta1);
            compute_qs_beta(Tl1_2, p_mid(ic,k,0), qs2, beta2);
 
            Real s1 = 0.0_rt, std_s1 = 0.0_rt, qn1 = 0.0_rt, c1 = 0.0_rt;
            Real s2 = 0.0_rt, std_s2 = 0.0_rt, qn2 = 0.0_rt, c2 = 0.0_rt;
            compute_s_terms(qw1_1, qs1, beta1, p_mid(ic,k,0), thl2_1, qw2_1,
                            sqrtthl2_1, sqrtqw2_1, r_qwthl_1, s1, std_s1, qn1, c1);
 
            if (qw1_1 == qw1_2 && thl2_1 == thl2_2 && qs1 == qs2) {
                s2 = s1;
                std_s2 = std_s1;
                qn2 = qn1;
                c2 = c1;
            } else {
                compute_s_terms(qw1_2, qs2, beta2, p_mid(ic,k,0), thl2_2, qw2_2,
                                sqrtthl2_2, sqrtqw2_2, r_qwthl_1, s2, std_s2, qn2, c2);
            }
 
            const Real ql1 = amrex::min(qn1, qw1_1);
            const Real ql2 = amrex::min(qn2, qw1_2);
            const Real old_ql = shoc_ql(ic,k,0);
            const Real cldfrac = amrex::min(1.0_rt, a * c1 + (1.0_rt - a) * c2);
            const Real ql = amrex::max(0.0_rt, a * ql1 + (1.0_rt - a) * ql2);
            const Real ql2_var = amrex::max(0.0_rt, a * (s1 * ql1 + c1 * std_s1 * std_s1)
                                               + (1.0_rt - a) * (s2 * ql2 + c2 * std_s2 * std_s2)
                                               - ql * ql);
            const Real wqls = a * ((w1_1 - w_first) * ql1) + (1.0_rt - a) * ((w1_2 - w_first) * ql2);
 
            shoc_cldfrac(ic,k,0) = clamp01(cldfrac);
            shoc_ql(ic,k,0) = ql;
            shoc_ql2(ic,k,0) = ql2_var;
            wqls_sec(ic,k,0) = wqls;
            wthv_sec(ic,k,0) = compute_buoyancy_flux(wthl_sec(ic,k,0), wqw_sec(ic,k,0),
                                                     p_mid(ic,k,0), wqls);
 
            if (opts.extra_shoc_diags) {
                const Real dt = static_cast<Real>(dt_d);
                const Real ql_change = ql - old_ql;
                shoc_cond(ic,k,0) = amrex::max(0.0_rt, ql_change / amrex::max(dt, eps()));
                shoc_evap(ic,k,0) = amrex::max(0.0_rt, -ql_change / amrex::max(dt, eps()));
            } else {
                shoc_cond(ic,k,0) = 0.0_rt;
                shoc_evap(ic,k,0) = 0.0_rt;
            }
        });
    }
}

Referenced by ShocDiagnostics::diagnose_post_implicit().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• Source/PBL/Shoc/ERF_ShocPDF.H
• Source/PBL/Shoc/ERF_ShocPDF.cpp