ERF_SetupDiff.H

Go to the documentation of this file.

/** \cond */
    // include common definitions used in the implicit diffusion solve
#include "ERF_SetupVertDiff.H"
 
    const Real dx_inv = cellSizeInv[0];
    const Real dy_inv = cellSizeInv[1];
 
    [[maybe_unused]] const bool SurfLayer_xlo = use_SurfLayer && SurfLayer[amrex::Orientation::xlo()] != nullptr;
    [[maybe_unused]] const bool SurfLayer_ylo = use_SurfLayer && SurfLayer[amrex::Orientation::ylo()] != nullptr;
    [[maybe_unused]] const bool SurfLayer_zlo = use_SurfLayer && SurfLayer[amrex::Orientation::zlo()] != nullptr;
    [[maybe_unused]] const bool SurfLayer_xhi = use_SurfLayer && SurfLayer[amrex::Orientation::xhi()] != nullptr;
    [[maybe_unused]] const bool SurfLayer_yhi = use_SurfLayer && SurfLayer[amrex::Orientation::yhi()] != nullptr;
    [[maybe_unused]] const bool SurfLayer_zhi = use_SurfLayer && SurfLayer[amrex::Orientation::zhi()] != nullptr;
 
    const Box xbx = surroundingNodes(bx,0);
    const Box ybx = surroundingNodes(bx,1);
    const Box zbx = surroundingNodes(bx,2);
 
    [[maybe_unused]] const int end_comp   = start_comp + num_comp - 1;
    [[maybe_unused]] bool l_use_keqn = turbChoice.use_keqn;
    [[maybe_unused]] bool l_implicit_diss = turbChoice.use_keqn && turbChoice.implicit_tke_dissipation;
    [[maybe_unused]] bool l_use_mynn = turbChoice.use_pbl_tke;
 
    // Clamp the divisor to the smallest normal Real before the select: an optimised
    //   build if-converts the select into an unconditional 1/theta_ref (also when
    //   the select is on the divisor), which trips fpe_trap_zero with the default
    //   theta_ref = 0. The clamp is exact for any normal theta_ref > 0 and its
    //   reciprocal is finite in single and double precision.
    [[maybe_unused]] const bool use_ref_theta = (turbChoice.theta_ref > 0);
    [[maybe_unused]] const Real inv_theta_ref = one / amrex::max(turbChoice.theta_ref, std::numeric_limits<Real>::min());
    [[maybe_unused]] const Real l_inv_theta0 = (use_ref_theta) ? inv_theta_ref : one;
 
    // Horizontal companions of eddy_diff_idz, which is built along with
    //   alpha_eff in ERF_SetupVertDiff.H; see the notes there.  The two
    //   horizontal directions use the same components.
    // Indexed by primitive component, so the tables must cover every scalar slot
    //   (base and smoke) as well as the moist quantities that follow them.
    Vector<int> eddy_diff_idx(NPRIMVAR_max, EddyDiff::Q_h);
    eddy_diff_idx[PrimTheta_comp] = EddyDiff::Theta_h;
    eddy_diff_idx[PrimKE_comp]    = EddyDiff::KE_h;
    for (int n = 0; n < NSCALARS; ++n) {
        eddy_diff_idx[PrimScalar_comp + n] = EddyDiff::Scalar_h;
    }
    Vector<int> eddy_diff_idy(eddy_diff_idx);
 
    // The tables are indexed by primitive component, i.e. by qty_index-1, so the
    //   highest index this call can reach is end_comp-1.
    AMREX_ALWAYS_ASSERT(eddy_diff_idx.size() == eddy_diff_idz.size());
    AMREX_ALWAYS_ASSERT(eddy_diff_idx.size() == alpha_eff.size());
    AMREX_ALWAYS_ASSERT(end_comp-1 < static_cast<int>(alpha_eff.size()));
 
    // Device vectors
    Gpu::AsyncVector<int>  eddy_diff_idx_d;
    Gpu::AsyncVector<int>  eddy_diff_idy_d;
 
    eddy_diff_idx_d.resize(eddy_diff_idx.size());
    eddy_diff_idy_d.resize(eddy_diff_idy.size());
 
    Gpu::copy(Gpu::hostToDevice, eddy_diff_idx.begin(), eddy_diff_idx.end(), eddy_diff_idx_d.begin());
    Gpu::copy(Gpu::hostToDevice, eddy_diff_idy.begin(), eddy_diff_idy.end(), eddy_diff_idy_d.begin());
 
    // Capture pointers for device code
    [[maybe_unused]] int*  d_eddy_diff_idx = eddy_diff_idx_d.data();
    [[maybe_unused]] int*  d_eddy_diff_idy = eddy_diff_idy_d.data();
/** \endcond */