WSM6 Class Reference

#include <ERF_WSM6.H>

Inheritance diagram for WSM6:

Collaboration diagram for WSM6:

Public Member Functions
	WSM6 ()
virtual	~WSM6 ()=default
void	Define (SolverChoice &sc) override
void	Init (const amrex::MultiFab &cons_in, const amrex::BoxArray &grids, const amrex::Geometry &geom, const amrex::Real &dt_advance, std::unique_ptr< amrex::MultiFab > &z_phys_nd, std::unique_ptr< amrex::MultiFab > &detJ_cc) override
void	Set_dzmin (const amrex::Real dz_min) override
void	Copy_State_to_Micro (const amrex::MultiFab &cons_in) override
void	Copy_Micro_to_State (amrex::MultiFab &cons_in) override
void	Update_Micro_Vars (amrex::MultiFab &cons_in) override
void	Update_State_Vars (amrex::MultiFab &cons_in) override
void	Advance (const amrex::Real &dt_advance, const SolverChoice &solverChoice) override
amrex::MultiFab *	Qmoist_Ptr (const int &varIdx) override
int	Qmoist_Size () override
int	Qstate_Moist_Size () override
void	Set_RealWidth (const int real_width) override
void	Qmoist_Restart_Vars (const SolverChoice &, std::vector< int > &a_idx, std::vector< std::string > &a_names) const override
Public Member Functions inherited from NullMoist
	NullMoist ()
virtual	~NullMoist ()=default
virtual int	Qstate_NonMoist_Size ()
virtual void	GetPlotVarNames (amrex::Vector< std::string > &a_vec) const
virtual void	GetPlotVar (const std::string &, amrex::MultiFab &) const

Private Types
using	FabPtr = std::shared_ptr< amrex::MultiFab >

Private Attributes
int	m_qmoist_size = 3
int	n_qstate_moist_size = 6
amrex::Vector< int >	MicVarMap
amrex::Geometry	m_geom
int	m_real_width {0}
amrex::Real	dt {0.0}
amrex::Real	m_dzmin {0.0}
int	nlev {0}
int	zlo {0}
int	zhi {0}
int	m_axis {2}
bool	m_do_cond {true}
amrex::MultiFab *	m_z_phys_nd {nullptr}
amrex::MultiFab *	m_detJ_cc {nullptr}
amrex::Array< FabPtr, MicVar_WSM6::NumVars >	mic_fab_vars

Member Typedef Documentation

FabPtr

using WSM6::FabPtr = std::shared_ptr<amrex::MultiFab>

private

Constructor & Destructor Documentation

WSM6()

WSM6::WSM6 ( )

inline

{}

~WSM6()

virtual WSM6::~WSM6 ( )

virtualdefault

Member Function Documentation

Advance()

void WSM6::Advance ( const amrex::Real &  dt_advance, const SolverChoice &  solverChoice  )

overridevirtual

Reimplemented from NullMoist.

{
    dt = dt_advance;
 
#ifdef ERF_USE_WSM6_FORT
    static bool wsm6_inited = false;
 
    // Minimal phase-1 initialization for single-moment WSM6.
    if (!wsm6_inited) {
        constexpr double den0 = 1.28;                 // Standard dry-air density (kg/m^3)
        constexpr double denr = static_cast<double>(rhoh2o);
        constexpr double dens = static_cast<double>(rhos);
        constexpr double cl = static_cast<double>(Cp_l);
        constexpr double cpv = static_cast<double>(Cp_v);
        constexpr int hail_opt = 0;                   // Graupel mode
        mp_wsm6_init_c(den0, denr, dens, cl, cpv, hail_opt);
        wsm6_inited = true;
    }
 
    constexpr double g = static_cast<double>(CONST_GRAV);
    constexpr double cpd = static_cast<double>(Cp_d);
    constexpr double cpv = static_cast<double>(Cp_v);
    constexpr double rd = static_cast<double>(R_d);
    constexpr double rv = static_cast<double>(R_v);
    constexpr double t0c = 273.15;
    constexpr double ep1 = static_cast<double>(R_v / R_d - one);
    constexpr double ep2 = static_cast<double>(R_d / R_v);
    constexpr double qmin = 1.0e-12;
    constexpr double xls = static_cast<double>(lsub);
    constexpr double xlv0 = static_cast<double>(lat_vap);
    constexpr double xlf0 = static_cast<double>(lat_ice);
    constexpr double den0 = 1.28;
    constexpr double denr = static_cast<double>(rhoh2o);
    constexpr double cliq = static_cast<double>(Cp_l);
    constexpr double cice = 2106.0;
    constexpr double psat = 610.78;
 
    for (MFIter mfi(*mic_fab_vars[MicVar_WSM6::qv], TileNoZ()); mfi.isValid(); ++mfi) {
        const Box box = mfi.tilebox();
        const Box fab_box = mfi.fabbox();
 
        auto const& t_arr = mic_fab_vars[MicVar_WSM6::tabs]->array(mfi);
        auto const& qv_arr = mic_fab_vars[MicVar_WSM6::qv]->array(mfi);
        auto const& qc_arr = mic_fab_vars[MicVar_WSM6::qc]->array(mfi);
        auto const& qi_arr = mic_fab_vars[MicVar_WSM6::qi]->array(mfi);
        auto const& qr_arr = mic_fab_vars[MicVar_WSM6::qr]->array(mfi);
        auto const& qs_arr = mic_fab_vars[MicVar_WSM6::qs]->array(mfi);
        auto const& qg_arr = mic_fab_vars[MicVar_WSM6::qg]->array(mfi);
        auto const& den_arr = mic_fab_vars[MicVar_WSM6::rho]->array(mfi);
        auto const& p_arr = mic_fab_vars[MicVar_WSM6::pres]->array(mfi);
        auto rain_arr = mic_fab_vars[MicVar_WSM6::rain_accum]->array(mfi);
        auto snow_arr = mic_fab_vars[MicVar_WSM6::snow_accum]->array(mfi);
        auto graup_arr = mic_fab_vars[MicVar_WSM6::graup_accum]->array(mfi);
 
        const int ilo = box.smallEnd(0);
        const int ihi = box.bigEnd(0);
        const int jlo = box.smallEnd(1);
        const int jhi = box.bigEnd(1);
        const int klo = box.smallEnd(2);
        const int khi = box.bigEnd(2);
 
        const int imlo = fab_box.smallEnd(0);
        const int imhi = fab_box.bigEnd(0);
        const int jmlo = fab_box.smallEnd(1);
        const int jmhi = fab_box.bigEnd(1);
        const int kmlo = fab_box.smallEnd(2);
        const int kmhi = fab_box.bigEnd(2);
 
        const Real dz_val = m_geom.CellSize(m_axis);
        FArrayBox delz_fab(fab_box, 1);
        auto const& delz_arr = delz_fab.array();
        delz_fab.setVal(dz_val);
 
        const Array4<const Real> z_arr = (m_z_phys_nd) ? m_z_phys_nd->const_array(mfi) : Array4<const Real> {};
        ParallelFor(box, [=] AMREX_GPU_DEVICE (int i, int j, int k) {
            delz_arr(i,j,k) = (z_arr) ? Real(0.25) * ( (z_arr(i  ,j  ,k+1) - z_arr(i  ,j  ,k))
                                                     + (z_arr(i+1,j  ,k+1) - z_arr(i+1,j  ,k))
                                                     + (z_arr(i  ,j+1,k+1) - z_arr(i  ,j+1,k))
                                                     + (z_arr(i+1,j+1,k+1) - z_arr(i+1,j+1,k)) ) : dz_val;
        });
 
        Box box2d(fab_box);
        box2d.makeSlab(2, 0);
        FArrayBox rainncv_fab(box2d, 1);
        FArrayBox sr_fab(box2d, 1);
        FArrayBox snowncv_fab(box2d, 1);
        FArrayBox graupelncv_fab(box2d, 1);
        FArrayBox rainacc_fab(box2d, 1);
        FArrayBox snowacc_fab(box2d, 1);
        FArrayBox graupacc_fab(box2d, 1);
 
        auto const& rainncv_arr = rainncv_fab.array();
        auto const& sr_arr = sr_fab.array();
        auto const& snowncv_arr = snowncv_fab.array();
        auto const& graupelncv_arr = graupelncv_fab.array();
        auto const& rainacc_arr = rainacc_fab.array();
        auto const& snowacc_arr = snowacc_fab.array();
        auto const& graupacc_arr = graupacc_fab.array();
        ParallelFor(box2d, [=] AMREX_GPU_DEVICE (int i, int j, int) {
            rainacc_arr(i,j,0) = rain_arr(i,j,klo);
            snowacc_arr(i,j,0) = snow_arr(i,j,klo);
            graupacc_arr(i,j,0) = graup_arr(i,j,klo);
            rainncv_arr(i,j,0) = Real(0.0);
            sr_arr(i,j,0) = Real(0.0);
            snowncv_arr(i,j,0) = Real(0.0);
            graupelncv_arr(i,j,0) = Real(0.0);
        });
 
        mp_wsm6_run_c(
            t_arr.dataPtr(),
            qv_arr.dataPtr(), qc_arr.dataPtr(), qi_arr.dataPtr(),
            qr_arr.dataPtr(), qs_arr.dataPtr(), qg_arr.dataPtr(),
            den_arr.dataPtr(), p_arr.dataPtr(), delz_arr.dataPtr(),
            static_cast<double>(dt), g, cpd, cpv, rd, rv, t0c, ep1, ep2, qmin,
            xls, xlv0, xlf0, den0, denr, cliq, cice, psat,
            rainacc_arr.dataPtr(), rainncv_arr.dataPtr(), sr_arr.dataPtr(),
            snowacc_arr.dataPtr(), snowncv_arr.dataPtr(),
            graupacc_arr.dataPtr(), graupelncv_arr.dataPtr(),
            imlo, imhi, jmlo, jmhi, kmlo, kmhi,
            ilo, ihi, jlo, jhi, klo, khi);
 
        ParallelFor(box2d, [=] AMREX_GPU_DEVICE (int i, int j, int) {
            rain_arr(i,j,klo) = rainacc_arr(i,j,0);
            snow_arr(i,j,klo) = snowacc_arr(i,j,0);
            graup_arr(i,j,klo) = graupacc_arr(i,j,0);
        });
    }
#else
    amrex::Abort("WSM6 Fortran bridge requested but ERF was not built with ERF_USE_WSM6_FORT");
#endif
}

Here is the call graph for this function:

Copy_Micro_to_State()

void WSM6::Copy_Micro_to_State ( amrex::MultiFab &  cons_in )

overridevirtual

Reimplemented from NullMoist.

{
    for (MFIter mfi(cons, TilingIfNotGPU()); mfi.isValid(); ++mfi) {
        const auto& box3d = mfi.tilebox();
        auto states = cons.array(mfi);
 
        auto rho = mic_fab_vars[MicVar_WSM6::rho]->array(mfi);
        auto theta = mic_fab_vars[MicVar_WSM6::theta]->array(mfi);
 
        auto qv = mic_fab_vars[MicVar_WSM6::qv]->array(mfi);
        auto qc = mic_fab_vars[MicVar_WSM6::qc]->array(mfi);
        auto qi = mic_fab_vars[MicVar_WSM6::qi]->array(mfi);
        auto qr = mic_fab_vars[MicVar_WSM6::qr]->array(mfi);
        auto qs = mic_fab_vars[MicVar_WSM6::qs]->array(mfi);
        auto qg = mic_fab_vars[MicVar_WSM6::qg]->array(mfi);
 
        ParallelFor(box3d, [=] AMREX_GPU_DEVICE(int i, int j, int k) {
            states(i,j,k,RhoTheta_comp) = rho(i,j,k) * theta(i,j,k);
            states(i,j,k,RhoQ1_comp) = rho(i,j,k) * amrex::max(Real(0), qv(i,j,k));
            states(i,j,k,RhoQ2_comp) = rho(i,j,k) * amrex::max(Real(0), qc(i,j,k));
            states(i,j,k,RhoQ3_comp) = rho(i,j,k) * amrex::max(Real(0), qi(i,j,k));
            states(i,j,k,RhoQ4_comp) = rho(i,j,k) * amrex::max(Real(0), qr(i,j,k));
            states(i,j,k,RhoQ5_comp) = rho(i,j,k) * amrex::max(Real(0), qs(i,j,k));
            states(i,j,k,RhoQ6_comp) = rho(i,j,k) * amrex::max(Real(0), qg(i,j,k));
        });
    }
 
    cons.FillBoundary(m_geom.periodicity());
}

Referenced by Update_State_Vars().

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_State_to_Micro()

void WSM6::Copy_State_to_Micro ( const amrex::MultiFab &  cons_in )

overridevirtual

Reimplemented from NullMoist.

{
    for (MFIter mfi(cons_in); mfi.isValid(); ++mfi) {
        // Match Morrison behavior: refresh microphysics ghost zones from state.
        // WSM6 Fortran reads the full (ims:ime, jms:jme, kms:kme) slab.
        const auto& box3d = mfi.growntilebox();
        auto states = cons_in.array(mfi);
 
        auto rho = mic_fab_vars[MicVar_WSM6::rho]->array(mfi);
        auto theta = mic_fab_vars[MicVar_WSM6::theta]->array(mfi);
        auto tabs = mic_fab_vars[MicVar_WSM6::tabs]->array(mfi);
        auto pres = mic_fab_vars[MicVar_WSM6::pres]->array(mfi);
 
        auto qv = mic_fab_vars[MicVar_WSM6::qv]->array(mfi);
        auto qc = mic_fab_vars[MicVar_WSM6::qc]->array(mfi);
        auto qi = mic_fab_vars[MicVar_WSM6::qi]->array(mfi);
        auto qr = mic_fab_vars[MicVar_WSM6::qr]->array(mfi);
        auto qs = mic_fab_vars[MicVar_WSM6::qs]->array(mfi);
        auto qg = mic_fab_vars[MicVar_WSM6::qg]->array(mfi);
 
        ParallelFor(box3d, [=] AMREX_GPU_DEVICE(int i, int j, int k) {
            rho(i,j,k) = states(i,j,k,Rho_comp);
            theta(i,j,k) = states(i,j,k,RhoTheta_comp) / states(i,j,k,Rho_comp);
 
            qv(i,j,k) = amrex::max(Real(0.0), states(i,j,k,RhoQ1_comp) / states(i,j,k,Rho_comp));
            qc(i,j,k) = amrex::max(Real(0.0), states(i,j,k,RhoQ2_comp) / states(i,j,k,Rho_comp));
            qi(i,j,k) = amrex::max(Real(0.0), states(i,j,k,RhoQ3_comp) / states(i,j,k,Rho_comp));
            qr(i,j,k) = amrex::max(Real(0.0), states(i,j,k,RhoQ4_comp) / states(i,j,k,Rho_comp));
            qs(i,j,k) = amrex::max(Real(0.0), states(i,j,k,RhoQ5_comp) / states(i,j,k,Rho_comp));
            qg(i,j,k) = amrex::max(Real(0.0), states(i,j,k,RhoQ6_comp) / states(i,j,k,Rho_comp));
 
            tabs(i,j,k) = getTgivenRandRTh(states(i,j,k,Rho_comp),
                                           states(i,j,k,RhoTheta_comp),
                                           qv(i,j,k));
            pres(i,j,k) = getPgivenRTh(states(i,j,k,RhoTheta_comp), qv(i,j,k));
        });
    }
}

Referenced by Update_Micro_Vars().

Here is the call graph for this function:

Here is the caller graph for this function:

Define()

void WSM6::Define ( SolverChoice &  sc )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        m_axis = sc.ave_plane;
        m_do_cond = (!sc.use_shoc);
    }

Init()

void WSM6::Init ( const amrex::MultiFab &  cons_in, const amrex::BoxArray &  grids, const amrex::Geometry &  geom, const amrex::Real &  dt_advance, std::unique_ptr< amrex::MultiFab > &  z_phys_nd, std::unique_ptr< amrex::MultiFab > &  detJ_cc  )

overridevirtual

Reimplemented from NullMoist.

{
    dt = dt_advance;
    m_geom = geom;
 
    m_z_phys_nd = z_phys_nd.get();
    m_detJ_cc = detJ_cc.get();
 
    MicVarMap.resize(m_qmoist_size);
    MicVarMap = {MicVar_WSM6::rain_accum, MicVar_WSM6::snow_accum, MicVar_WSM6::graup_accum};
 
    for (int ivar = 0; ivar < MicVar_WSM6::NumVars; ++ivar) {
        mic_fab_vars[ivar] = std::make_shared<MultiFab>(cons_in.boxArray(), cons_in.DistributionMap(),
                                                        1, cons_in.nGrowVect());
        mic_fab_vars[ivar]->setVal(0.0);
    }
 
    nlev = m_geom.Domain().length(2);
    zlo = m_geom.Domain().smallEnd(2);
    zhi = m_geom.Domain().bigEnd(2);
}

Qmoist_Ptr()

amrex::MultiFab* WSM6::Qmoist_Ptr ( const int &  varIdx )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        AMREX_ALWAYS_ASSERT(varIdx < m_qmoist_size);
        return mic_fab_vars[MicVarMap[varIdx]].get();
    }

Here is the call graph for this function:

Qmoist_Restart_Vars()

void WSM6::Qmoist_Restart_Vars ( const SolverChoice &  , std::vector< int > &  a_idx, std::vector< std::string > &  a_names  ) const

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        a_idx = {0, 1, 2};
        a_names = {"RainAccum", "SnowAccum", "GraupAccum"};
    }

Qmoist_Size()

int WSM6::Qmoist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return m_qmoist_size; }

Qstate_Moist_Size()

int WSM6::Qstate_Moist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return n_qstate_moist_size; }

Set_dzmin()

void WSM6::Set_dzmin ( const amrex::Real  dz_min )

inlineoverridevirtual

Reimplemented from NullMoist.

{ m_dzmin = dz_min; }

Set_RealWidth()

void WSM6::Set_RealWidth ( const int  real_width )

inlineoverridevirtual

Reimplemented from NullMoist.

{ m_real_width = real_width; }

Update_Micro_Vars()

void WSM6::Update_Micro_Vars ( amrex::MultiFab &  cons_in )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        Copy_State_to_Micro(cons_in);
    }

Here is the call graph for this function:

Update_State_Vars()

void WSM6::Update_State_Vars ( amrex::MultiFab &  cons_in )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        Copy_Micro_to_State(cons_in);
    }

Here is the call graph for this function:

Member Data Documentation

dt

amrex::Real WSM6::dt {0.0}

private

m_axis

int WSM6::m_axis {2}

private

Referenced by Define().

m_detJ_cc

amrex::MultiFab* WSM6::m_detJ_cc {nullptr}

private

m_do_cond

bool WSM6::m_do_cond {true}

private

Referenced by Define().

m_dzmin

amrex::Real WSM6::m_dzmin {0.0}

private

Referenced by Set_dzmin().

m_geom

amrex::Geometry WSM6::m_geom

private

m_qmoist_size

int WSM6::m_qmoist_size = 3

private

Referenced by Qmoist_Ptr(), and Qmoist_Size().

m_real_width

int WSM6::m_real_width {0}

private

Referenced by Set_RealWidth().

m_z_phys_nd

amrex::MultiFab* WSM6::m_z_phys_nd {nullptr}

private

mic_fab_vars

amrex::Array<FabPtr, MicVar_WSM6::NumVars> WSM6::mic_fab_vars

private

Referenced by Qmoist_Ptr().

MicVarMap

amrex::Vector<int> WSM6::MicVarMap

private

Referenced by Qmoist_Ptr().

n_qstate_moist_size

int WSM6::n_qstate_moist_size = 6

private

Referenced by Qstate_Moist_Size().

nlev

int WSM6::nlev {0}

private

zhi

int WSM6::zhi {0}

private

zlo

int WSM6::zlo {0}

private

---

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

• Source/Microphysics/WSM6/ERF_WSM6.H
• Source/Microphysics/WSM6/ERF_AdvanceWSM6.cpp
• Source/Microphysics/WSM6/ERF_InitWSM6.cpp
• Source/Microphysics/WSM6/ERF_UpdateWSM6.cpp