ShocTKE Class Reference

#include <ERF_ShocTKE.H>

Static Public Member Functions
static void	compute_shear_production (const ShocColumnData &col, amrex::FArrayBox &sterm_iface)
static void	integrate_column_stability (const ShocColumnData &col, amrex::Vector< amrex::Real > &brunt_int)
static void	diagnose_tke_and_diffusivities (ShocColumnData &col, const ShocRuntimeOptions &opts, amrex::Real dt)

Member Function Documentation

compute_shear_production()

void ShocTKE::compute_shear_production ( const ShocColumnData &  col, amrex::FArrayBox &  sterm_iface  )

static

{
    const Box iface_box(IntVect(0,0,0), IntVect(col.layout.ncell - 1, col.layout.nlev, 0));
    sterm_iface.resize(iface_box, 1, The_Async_Arena());
    sterm_iface.template setVal<amrex::RunOn::Device>(0.0);
 
    auto sterm = sterm_iface.array();
    const auto u = col.u.const_array();
    const auto v = col.v.const_array();
    const auto zt = col.zt.const_array();
    const auto zi = col.zi.const_array();
    const auto layout = col.layout;
    const Box col_box(IntVect(0,0,0), IntVect(layout.ncell - 1, 0, 0));
 
    ParallelFor(col_box, [=] AMREX_GPU_DEVICE (int ic, int, int) noexcept
    {
        sterm(ic,0,0) = 0.0_rt;
        sterm(ic,layout.nlev,0) = 0.0_rt;
        for (int k = 1; k < layout.nlev; ++k) {
            const Real dz_zi = interface_spacing(zt, zi, layout, ic, k);
            const Real du_dz = (u(ic,k-1,0) - u(ic,k,0)) / dz_zi;
            const Real dv_dz = (v(ic,k-1,0) - v(ic,k,0)) / dz_zi;
            sterm(ic,k,0) = shoc_shear_ck() * (du_dz * du_dz + dv_dz * dv_dz);
        }
    });
}

Here is the call graph for this function:

diagnose_tke_and_diffusivities()

void ShocTKE::diagnose_tke_and_diffusivities ( ShocColumnData &  col, const ShocRuntimeOptions &  opts, amrex::Real  dt  )

static

{
    AMREX_ALWAYS_ASSERT(dt > 0.0);
 
    const Box cell_box(IntVect(0,0,0), IntVect(col.layout.ncell - 1, col.layout.nlev - 1, 0));
    FArrayBox sterm_iface;
    FArrayBox sterm_zt(cell_box, 1, The_Async_Arena());
    FArrayBox a_diss(cell_box, 1, The_Async_Arena());
 
    compute_shear_production(col, sterm_iface);
    interpolate_iface_to_cc(col, sterm_iface, sterm_zt, 0.0);
 
    auto tke = col.tke.array();
    auto isotropy = col.isotropy.array();
    auto tk = col.tk.array();
    auto tkh = col.tkh.array();
    auto tke_tend = col.tke_tend.array();
    auto shear_prod_arr = col.shear_prod.array();
    auto buoy_prod_arr = col.buoy_prod.array();
    auto diss_arr = col.diss_tke.array();
 
    const auto wthv_sec = col.wthv_sec.const_array();
    const auto shoc_mix = col.shoc_mix.const_array();
    const auto brunt = col.brunt.const_array();
    const auto zt = col.zt.const_array();
    const auto tabs = col.tabs.const_array();
    const auto pblh = col.pblh.const_array();
    const auto sterm = sterm_zt.const_array();
    auto a_diss_arr = a_diss.array();
    const auto dz = col.dz.const_array();
    const auto p_mid = col.p_mid.const_array();
    const auto zi = col.zi.const_array();
    const auto layout = col.layout;
    const Box col_box(IntVect(0,0,0), IntVect(layout.ncell - 1, 0, 0));
 
    ParallelFor(col_box, [=] AMREX_GPU_DEVICE (int ic, int, int) noexcept
    {
        const Real z_sfc = zi(ic,0,0);
        Real brunt_int = 0.0_rt;
        for (int k = 0; k < layout.nlev; ++k) {
            if (p_mid(ic,k,0) > shoc_trop_pres()) {
                brunt_int += dz(ic,k,0) * brunt(ic,k,0);
            }
 
            const Real old_tke = amrex::max(0.0_rt, tke(ic,k,0));
            const Real buoy_prod = opts.shoc_1p5tke
                ? -old_tke * brunt(ic,k,0)
                : (CONST_GRAV / shoc_base_temp()) * wthv_sec(ic,k,0);
            const Real shear_prod = tk(ic,k,0) * sterm(ic,k,0);
            const Real mix = amrex::max(shoc_mix(ic,k,0), 1.0e-12_rt);
            const Real diss = shoc_tke_cee() / mix * old_tke * std::sqrt(old_tke);
            const Real net_prod = opts.signed_tke_production
                ? (shear_prod + buoy_prod)
                : amrex::max(0.0_rt, shear_prod + buoy_prod);
            const Real raw_new_tke = shoc_clamp(old_tke + dt * (net_prod - diss),
                                                shoc_min_tke(), shoc_max_tke());
            const Real top_factor = top_taper_factor(zt, zi, layout, opts, ic, k);
            const Real new_tke = shoc_clamp(shoc_min_tke() +
                                            top_factor * (raw_new_tke - shoc_min_tke()),
                                            shoc_min_tke(), shoc_max_tke());
 
            a_diss_arr(ic,k,0) = top_factor * diss;
            shear_prod_arr(ic,k,0) = top_factor * shear_prod;
            buoy_prod_arr(ic,k,0) = top_factor * buoy_prod;
            diss_arr(ic,k,0) = top_factor * diss;
            tke_tend(ic,k,0) = new_tke - old_tke;
            tke(ic,k,0) = new_tke;
        }
 
        Real lambda = opts.lambda_low + ((brunt_int / CONST_GRAV) - opts.lambda_thresh) * opts.lambda_slope;
        lambda = shoc_clamp(lambda, opts.lambda_low, opts.lambda_high);
 
        for (int k = 0; k < layout.nlev; ++k) {
            const Real diss = amrex::max(a_diss_arr(ic,k,0), 1.0e-12_rt);
            const Real tscale = 2.0_rt * tke(ic,k,0) / diss;
            const Real local_lambda = (brunt(ic,k,0) <= 0.0_rt) ? 0.0_rt : lambda;
            isotropy(ic,k,0) = amrex::min(shoc_max_iso(),
                                          tscale / (1.0_rt + local_lambda * brunt(ic,k,0) * tscale * tscale));
 
            const Real zt_agl = shoc::height_agl(zt(ic,k,0), z_sfc);
            const bool use_stable_mix = (zt_agl < pblh(ic,0,0) + shoc_pbl_trans()) &&
                                        (tabs(ic,0,0) < shoc_tabs_crit());
            if (use_stable_mix) {
                const Real sterm_sqrt = std::sqrt(amrex::max(sterm(ic,k,0), 0.0_rt));
                tkh(ic,k,0) = shoc_stable_ckh() * shoc_mix(ic,k,0) * shoc_mix(ic,k,0) * sterm_sqrt;
                tk(ic,k,0) = shoc_stable_ckm() * shoc_mix(ic,k,0) * shoc_mix(ic,k,0) * sterm_sqrt;
            } else {
                tkh(ic,k,0) = opts.coeff_kh * isotropy(ic,k,0) * tke(ic,k,0);
                tk(ic,k,0) = opts.coeff_km * isotropy(ic,k,0) * tke(ic,k,0);
            }
 
            const Real top_factor = top_taper_factor(zt, zi, layout, opts, ic, k);
            isotropy(ic,k,0) *= top_factor;
            tkh(ic,k,0) = top_factor * amrex::max(0.0_rt, tkh(ic,k,0));
            tk(ic,k,0) = top_factor * amrex::max(0.0_rt, tk(ic,k,0));
        }
    });
}

Referenced by ShocDiagnostics::diagnose_pre_implicit().

Here is the call graph for this function:

Here is the caller graph for this function:

integrate_column_stability()

void ShocTKE::integrate_column_stability ( const ShocColumnData &  col, amrex::Vector< amrex::Real > &  brunt_int  )

static

{
    brunt_int.assign(col.layout.ncell, 0.0);
    const auto dz = col.dz.const_array();
    const auto p_mid = col.p_mid.const_array();
    const auto brunt = col.brunt.const_array();
 
    for (int ic = 0; ic < col.layout.ncell; ++ic) {
        for (int k = 0; k < col.layout.nlev; ++k) {
            if (p_mid(ic,k,0) > shoc_trop_pres()) {
                brunt_int[ic] += dz(ic,k,0) * brunt(ic,k,0);
            }
        }
    }
}

---

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

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