Kessler Class Reference

#include <ERF_Kessler.H>

Inheritance diagram for Kessler:

Collaboration diagram for Kessler:

Public Member Functions
	Kessler ()
virtual	~Kessler ()=default
void	AdvanceKessler (const SolverChoice &solverChoice)
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, const amrex::MultiFab &) 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
int	Qstate_Moist_NumConc_Size () 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
virtual void	GetPlotVar (const std::string &a_name, amrex::MultiFab &a_mf, const int) const
virtual void	SetCurrentLevel (const int &)
virtual void	InitLevel (const int, const amrex::MultiFab &)
virtual int	getDiagnosticsInterval () const
virtual void	Set_RealWidth (const int)

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

Private Attributes
int	m_qmoist_size = 1
int	n_qstate_moist_size = 3
int	n_qstate_moist_numconc_size = 0
amrex::Vector< int >	MicVarMap
amrex::Geometry	m_geom
amrex::Real	dt
amrex::Real	m_dzmin
int	nlev
int	zlo
int	zhi
amrex::Real	m_fac_cond
bool	m_do_cond
amrex::MultiFab *	m_z_phys_nd
amrex::MultiFab *	m_detJ_cc
amrex::Array< FabPtr, MicVar_Kess::NumVars >	mic_fab_vars

Static Private Attributes
static constexpr amrex::Real	CFL_MAX = kessler_sedimentation_cfl_max

Member Typedef Documentation

FabPtr

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

private

Constructor & Destructor Documentation

Kessler()

Kessler::Kessler ( )

inline

{}

~Kessler()

virtual Kessler::~Kessler ( )

virtualdefault

Member Function Documentation

Advance()

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

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        dt = dt_advance;
 
        this->AdvanceKessler(solverChoice);
    }

Here is the call graph for this function:

AdvanceKessler()

void Kessler::AdvanceKessler

(

const SolverChoice &

solverChoice

)

Compute Precipitation-related Microphysics quantities.

{
    bool do_cond = m_do_cond;
    auto tabs    = mic_fab_vars[MicVar_Kess::tabs];
    auto domain  = m_geom.Domain();
    int k_lo = domain.smallEnd(2);
    int k_hi = domain.bigEnd(2);
    if (solverChoice.moisture_type == MoistureType::Kessler)
    {
        MultiFab fz;
        auto ba    = tabs->boxArray();
        auto dm    = tabs->DistributionMap();
        fz.define(convert(ba, IntVect(0,0,1)), dm, 1, 0); // No ghost cells
 
        Real dtn  = dt;
        Real coef = dtn/m_dzmin;
 
        for ( MFIter mfi(*tabs,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
            auto qv_array    = mic_fab_vars[MicVar_Kess::qv]->array(mfi);
            auto qc_array    = mic_fab_vars[MicVar_Kess::qcl]->array(mfi);
            auto qp_array    = mic_fab_vars[MicVar_Kess::qp]->array(mfi);
            auto qt_array    = mic_fab_vars[MicVar_Kess::qt]->array(mfi);
            auto tabs_array  = mic_fab_vars[MicVar_Kess::tabs]->array(mfi);
            auto pres_array  = mic_fab_vars[MicVar_Kess::pres]->array(mfi);
            auto theta_array = mic_fab_vars[MicVar_Kess::theta]->array(mfi);
            auto rho_array   = mic_fab_vars[MicVar_Kess::rho]->array(mfi);
 
            auto tbx = mfi.tilebox();
 
            Real d_fac_cond = m_fac_cond;
 
            ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
            {
                qv_array(i,j,k) = std::max(Real(0), qv_array(i,j,k));
                qc_array(i,j,k) = std::max(Real(0), qc_array(i,j,k));
                qp_array(i,j,k) = std::max(Real(0), qp_array(i,j,k));
 
                Real qsat_local, dtqsat_local;
                Real pressure = pres_array(i,j,k);
                // Kessler stores pressure in mbar / hPa for the qsat helpers.
                erf_qsatw(tabs_array(i,j,k), pressure, qsat_local);
                erf_dtqsatw(tabs_array(i,j,k), pressure, dtqsat_local);
 
                if (qsat_local <= Real(0)) {
                    amrex::Warning("qsat computed as non-positive; setting to Real(0)!");
                    qsat_local = Real(0);
                }
 
                const KesslerSourceTerms source_terms = kessler_warm_rain_sources(
                    qv_array(i,j,k), qc_array(i,j,k), qp_array(i,j,k), rho_array(i,j,k),
                    pressure, qsat_local, dtqsat_local, dtn, do_cond, d_fac_cond);
 
                qv_array(i,j,k) += -source_terms.dq_vapor_to_cloud
                                 +  source_terms.dq_cloud_to_vapor
                                 +  source_terms.dq_rain_to_vapor;
                qc_array(i,j,k) +=  source_terms.dq_vapor_to_cloud
                                 -  source_terms.dq_cloud_to_vapor
                                 -  source_terms.dq_cloud_to_rain;
                qp_array(i,j,k) +=  source_terms.dq_cloud_to_rain
                                 -  source_terms.dq_rain_to_vapor;
 
                Real theta_over_T = theta_array(i,j,k)/tabs_array(i,j,k);
                theta_array(i,j,k) += theta_over_T * d_fac_cond
                    * (source_terms.dq_vapor_to_cloud
                       - source_terms.dq_cloud_to_vapor
                       - source_terms.dq_rain_to_vapor);
 
                qv_array(i,j,k) = std::max(Real(0), qv_array(i,j,k));
                qc_array(i,j,k) = std::max(Real(0), qc_array(i,j,k));
                qp_array(i,j,k) = std::max(Real(0), qp_array(i,j,k));
 
                qt_array(i,j,k) = qv_array(i,j,k) + qc_array(i,j,k);
            });
        }
 
        for ( MFIter mfi(fz, TilingIfNotGPU()); mfi.isValid(); ++mfi ){
            auto rho_array = mic_fab_vars[MicVar_Kess::rho]->array(mfi);
            auto qp_array  = mic_fab_vars[MicVar_Kess::qp]->array(mfi);
 
            auto fz_array  = fz.array(mfi);
            const Box& tbz = mfi.tilebox();
 
            ParallelFor(tbz, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
            {
                const Real rho_km1 = (k == k_lo) ? rho_array(i,j,k) : rho_array(i,j,k-1);
                const Real rho_k = (k == k_hi+1) ? rho_array(i,j,k-1) : rho_array(i,j,k);
                const Real qp_km1 = (k == k_lo) ? qp_array(i,j,k) : qp_array(i,j,k-1);
                const Real qp_k = (k == k_hi+1) ? qp_array(i,j,k-1) : qp_array(i,j,k);
                const KesslerFaceState face_state =
                    kessler_face_state(k, k_hi, rho_km1, rho_k, qp_km1, qp_k);
 
                const Real terminal_velocity = kessler_terminal_velocity(face_state.rho, face_state.qp);
                fz_array(i,j,k) = kessler_precip_flux(face_state.rho, terminal_velocity, face_state.qp);
            });
        }
 
        auto const& ma_rho_arr = mic_fab_vars[MicVar_Kess::rho]->const_arrays();
        auto const& ma_qp_arr = mic_fab_vars[MicVar_Kess::qp]->const_arrays();
        // The sedimentation CFL uses fall speed, not precipitating mass flux.
        // fz stores rho * Vt * qp for the flux divergence below, so the reduction
        // recomputes Vt from the same face state used for the flux.
        GpuTuple<Real> max_terminal_velocity = ParReduce(TypeList<ReduceOpMax>{},
                                                         TypeList<Real>{},
                                                         fz, IntVect(0),
                                                         [=] AMREX_GPU_DEVICE (int box_no, int i, int j, int k) noexcept
                                                         -> GpuTuple<Real>
                                                         {
                                                             const auto& rho_arr = ma_rho_arr[box_no];
                                                             const auto& qp_arr = ma_qp_arr[box_no];
                                                             const Real rho_km1 = (k == k_lo) ? rho_arr(i,j,k) : rho_arr(i,j,k-1);
                                                             const Real rho_k = (k == k_hi+1) ? rho_arr(i,j,k-1) : rho_arr(i,j,k);
                                                             const Real qp_km1 = (k == k_lo) ? qp_arr(i,j,k) : qp_arr(i,j,k-1);
                                                             const Real qp_k = (k == k_hi+1) ? qp_arr(i,j,k-1) : qp_arr(i,j,k);
                                                             const KesslerFaceState face_state =
                                                                 kessler_face_state(k, k_hi, rho_km1, rho_k, qp_km1, qp_k);
                                                             return { kessler_terminal_velocity(face_state.rho, face_state.qp) };
                                                         });
        int n_substep = kessler_num_sedimentation_substeps(get<0>(max_terminal_velocity),
                                                           dt, m_dzmin);
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(n_substep >= 1,
                                         "Kessler: Number of precipitation substeps must be greater than 0!");
        coef /= Real(n_substep);
        dtn  /= Real(n_substep);
 
        for (int nsub(0); nsub<n_substep; ++nsub) {
            for ( MFIter mfi(*tabs, TilingIfNotGPU()); mfi.isValid(); ++mfi ){
                auto rho_array = mic_fab_vars[MicVar_Kess::rho]->array(mfi);
                auto qp_array  = mic_fab_vars[MicVar_Kess::qp]->array(mfi);
                auto rain_accum_array = mic_fab_vars[MicVar_Kess::rain_accum]->array(mfi);
                auto fz_array  = fz.array(mfi);
 
                const auto dJ_array = (m_detJ_cc) ? m_detJ_cc->const_array(mfi) : Array4<const Real>{};
 
                const Box& tbx = mfi.tilebox();
                const Box& tbz = mfi.tilebox(IntVect(0,0,1),IntVect(0));
 
                ParallelFor(tbz, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
                {
                    const Real rho_km1 = (k == k_lo) ? rho_array(i,j,k) : rho_array(i,j,k-1);
                    const Real rho_k = (k == k_hi+1) ? rho_array(i,j,k-1) : rho_array(i,j,k);
                    const Real qp_km1 = (k == k_lo) ? qp_array(i,j,k) : qp_array(i,j,k-1);
                    const Real qp_k = (k == k_hi+1) ? qp_array(i,j,k-1) : qp_array(i,j,k);
                    const int donor_k = kessler_face_donor_k(k, k_hi);
                    const KesslerFaceState face_state =
                        kessler_face_state(k, k_hi, rho_km1, rho_k, qp_km1, qp_k);
 
                    const Real terminal_velocity = kessler_terminal_velocity(face_state.rho, face_state.qp);
                    const Real donor_rho = rho_array(i,j,donor_k);
                    const Real donor_qp = std::max(Real(0), qp_array(i,j,donor_k));
                    const Real donor_detJ = (dJ_array) ? dJ_array(i,j,donor_k) : Real(1);
                    // The face flux uses face rho and donor qp. The limiter uses donor rho,
                    // donor qp, and donor detJ because it caps how much rain can leave the donor
                    // cell in this substep.
                    // Cap outgoing flux by the donor cell's detJ-weighted available rain water:
                    // F * dt / dz <= rho_donor * qp_donor * detJ_donor.
                    // This keeps compressed cells from losing more rain than they contain.
                    const Real max_flux = donor_rho * donor_qp * donor_detJ / coef;
                    fz_array(i,j,k) = amrex::min(
                        kessler_precip_flux(face_state.rho, terminal_velocity, face_state.qp), max_flux);
 
                    if(k==k_lo){
                        // Surface accumulation stores the bottom-face precipitation mass per area
                        // increment converted to liquid-water depth.
                        rain_accum_array(i,j,k) = rain_accum_array(i,j,k)
                                                + kessler_rain_accumulation_increment(fz_array(i,j,k) * dtn);
                    }
                });
 
                ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
                {
                    Real dJinv = (dJ_array) ? Real(1)/dJ_array(i,j,k) : Real(1);
 
                    // Threshold local face-flux copies only. Neighboring cells share fz
                    // faces, so the cell update must not mutate fz while applying the
                    // small-value cutoff.
                    Real f_hi = fz_array(i,j,k+1);
                    Real f_lo = fz_array(i,j,k  );
 
                    if (kessler_is_small_sedimentation_value(f_hi)) {
                        f_hi = Real(0);
                    }
                    if (kessler_is_small_sedimentation_value(f_lo)) {
                        f_lo = Real(0);
                    }
                    Real dq_sed = kessler_sedimentation_tendency(
                        f_hi, f_lo, rho_array(i,j,k), dJinv, coef);
                    if (kessler_is_small_sedimentation_value(dq_sed)) {
                        dq_sed = Real(0);
                    }
 
                    qp_array(i,j,k) +=  dq_sed;
                    qp_array(i,j,k)  = std::max(Real(0), qp_array(i,j,k));
                });
            }
        }
    }
 
    if (solverChoice.moisture_type == MoistureType::Kessler_NoRain) {
        if (!do_cond) { return; }
        for ( MFIter mfi(*tabs,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
            auto qv_array    = mic_fab_vars[MicVar_Kess::qv]->array(mfi);
            auto qc_array    = mic_fab_vars[MicVar_Kess::qcl]->array(mfi);
            auto qt_array    = mic_fab_vars[MicVar_Kess::qt]->array(mfi);
            auto tabs_array  = mic_fab_vars[MicVar_Kess::tabs]->array(mfi);
            auto theta_array = mic_fab_vars[MicVar_Kess::theta]->array(mfi);
            auto pres_array  = mic_fab_vars[MicVar_Kess::pres]->array(mfi);
 
            auto tbx = mfi.tilebox();
 
            Real d_fac_cond = m_fac_cond;
 
            ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
            {
                qc_array(i,j,k) = std::max(Real(0), qc_array(i,j,k));
 
                Real qsat, dtqsat;
 
                Real pressure = pres_array(i,j,k);
                // Kessler stores pressure in mbar / hPa for the qsat helpers.
                erf_qsatw(tabs_array(i,j,k), pressure, qsat);
                erf_dtqsatw(tabs_array(i,j,k), pressure, dtqsat);
 
                const KesslerSaturationAdjustment saturation_adjustment =
                    kessler_saturation_adjustment(qv_array(i,j,k), qc_array(i,j,k), qsat, dtqsat,
                                                  do_cond, d_fac_cond);
 
                qv_array(i,j,k) += -saturation_adjustment.dq_vapor_to_cloud
                                 +  saturation_adjustment.dq_cloud_to_vapor;
                qc_array(i,j,k) +=  saturation_adjustment.dq_vapor_to_cloud
                                 -  saturation_adjustment.dq_cloud_to_vapor;
 
                Real theta_over_T = theta_array(i,j,k)/tabs_array(i,j,k);
                theta_array(i,j,k) += theta_over_T * d_fac_cond
                    * (saturation_adjustment.dq_vapor_to_cloud - saturation_adjustment.dq_cloud_to_vapor);
 
                qv_array(i,j,k) = std::max(Real(0), qv_array(i,j,k));
                qc_array(i,j,k) = std::max(Real(0), qc_array(i,j,k));
 
                qt_array(i,j,k) = qv_array(i,j,k) + qc_array(i,j,k);
            });
        }
    }
}

Referenced by Advance().

Here is the call graph for this function:

Here is the caller graph for this function:

Copy_Micro_to_State()

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

overridevirtual

Updates conserved and microphysics variables in the provided MultiFabs from the internal MultiFabs that store Microphysics module data.

Parameters

[out]	cons	Conserved variables
[out]	qmoist	qv, qc, qi, qr, qs, qg

Reimplemented from NullMoist.

{
    // Get the temperature, density, theta, qt and qp from input
    for ( MFIter mfi(cons,TilingIfNotGPU()); mfi.isValid(); ++mfi) {
        const auto& box3d = mfi.tilebox();
 
        auto states_arr = cons.array(mfi);
 
        auto rho_arr    = mic_fab_vars[MicVar_Kess::rho]->array(mfi);
        auto theta_arr  = mic_fab_vars[MicVar_Kess::theta]->array(mfi);
        auto qv_arr     = mic_fab_vars[MicVar_Kess::qv]->array(mfi);
        auto qc_arr     = mic_fab_vars[MicVar_Kess::qcl]->array(mfi);
        auto qp_arr     = mic_fab_vars[MicVar_Kess::qp]->array(mfi);
 
        // get potential total density, temperature, qt, qp
        ParallelFor( box3d, [=] AMREX_GPU_DEVICE (int i, int j, int k)
        {
            states_arr(i,j,k,RhoTheta_comp) = rho_arr(i,j,k)*theta_arr(i,j,k);
            states_arr(i,j,k,RhoQ1_comp)    = rho_arr(i,j,k)*qv_arr(i,j,k);
            states_arr(i,j,k,RhoQ2_comp)    = rho_arr(i,j,k)*qc_arr(i,j,k);
            states_arr(i,j,k,RhoQ3_comp)    = rho_arr(i,j,k)*qp_arr(i,j,k);
        });
    }
 
    // Fill interior ghost cells and periodic boundaries
    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 Kessler::Copy_State_to_Micro ( const amrex::MultiFab &  cons_in )

overridevirtual

Initializes the Microphysics module.

Parameters

[in]

cons_in

Conserved variables input

Reimplemented from NullMoist.

{
    // Get the temperature, density, theta, qt and qp from input
    for ( MFIter mfi(cons_in); mfi.isValid(); ++mfi) {
        const auto& box3d = mfi.tilebox();
 
        auto states_array = cons_in.array(mfi);
 
        auto qt_array    = mic_fab_vars[MicVar_Kess::qt]->array(mfi);
        auto qv_array    = mic_fab_vars[MicVar_Kess::qv]->array(mfi);
        auto qc_array    = mic_fab_vars[MicVar_Kess::qcl]->array(mfi);
 
        auto qp_array    = mic_fab_vars[MicVar_Kess::qp]->array(mfi);
 
        auto rho_array   = mic_fab_vars[MicVar_Kess::rho]->array(mfi);
        auto theta_array = mic_fab_vars[MicVar_Kess::theta]->array(mfi);
        auto tabs_array  = mic_fab_vars[MicVar_Kess::tabs]->array(mfi);
        auto pres_array  = mic_fab_vars[MicVar_Kess::pres]->array(mfi);
 
        // getPgivenRTh returns Pa. Kessler stores pressure in mbar / hPa for the
        // qsat helper path, so convert here after forming temperature and density.
        ParallelFor( box3d, [=] AMREX_GPU_DEVICE (int i, int j, int k)
        {
            rho_array(i,j,k)   = states_array(i,j,k,Rho_comp);
            theta_array(i,j,k) = states_array(i,j,k,RhoTheta_comp)/states_array(i,j,k,Rho_comp);
            qv_array(i,j,k)    = states_array(i,j,k,RhoQ1_comp)/states_array(i,j,k,Rho_comp);
            qc_array(i,j,k)    = states_array(i,j,k,RhoQ2_comp)/states_array(i,j,k,Rho_comp);
            qp_array(i,j,k)    = states_array(i,j,k,RhoQ3_comp)/states_array(i,j,k,Rho_comp);
            qt_array(i,j,k)    = qv_array(i,j,k) + qc_array(i,j,k);
 
            tabs_array(i,j,k)  = getTgivenRandRTh(states_array(i,j,k,Rho_comp),
                                                  states_array(i,j,k,RhoTheta_comp),
                                                  qv_array(i,j,k));
            pres_array(i,j,k)  = getPgivenRTh(states_array(i,j,k,RhoTheta_comp), qv_array(i,j,k)) * Real(0.01);
        });
    }
}

Referenced by Update_Micro_Vars().

Here is the call graph for this function:

Here is the caller graph for this function:

Define()

void Kessler::Define ( SolverChoice &  sc )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        // Use one latent-over-cp factor for both the saturation solve and theta
        // update. L_v comes from ERF_Constants.H; c_p comes from SolverChoice.
        m_fac_cond = L_v / sc.c_p;
        m_do_cond  = (!sc.use_shoc);
    }

Init()

void Kessler::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

Initializes the Microphysics module.

Parameters

[in]	cons_in	Conserved variables input
[in]	qc_in	Cloud variables input
[in,out]	qv_in	Vapor variables input
[in]	qi_in	Ice variables input
[in]	grids	The boxes on which we will evolve the solution
[in]	geom	Geometry associated with these MultiFabs and grids
[in]	dt_advance	Timestep for the advance

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_Kess::rain_accum};
 
    // initialize microphysics variables
    for (auto ivar = 0; ivar < MicVar_Kess::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.);
    }
 
    // Set class data members
    for ( MFIter mfi(cons_in, TileNoZ()); mfi.isValid(); ++mfi) {
        const auto& box3d = mfi.tilebox();
 
        const auto& lo = lbound(box3d);
        const auto& hi = ubound(box3d);
 
        nlev = box3d.length(2);
        zlo  = lo.z;
        zhi  = hi.z;
    }
}

Here is the call graph for this function:

Qmoist_Ptr()

amrex::MultiFab* Kessler::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 Kessler::Qmoist_Restart_Vars ( const SolverChoice &  , std::vector< int > &  a_idx, std::vector< std::string > &  a_names  ) const

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        a_idx.clear();
        a_names.clear();
 
        // NOTE: These are the indices to access into qmoist (not mic_fab_vars)
        a_idx.push_back(0); a_names.push_back("RainAccum");
    }

Qmoist_Size()

int Kessler::Qmoist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return Kessler::m_qmoist_size; }

Qstate_Moist_NumConc_Size()

int Kessler::Qstate_Moist_NumConc_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return Kessler::n_qstate_moist_numconc_size; }

Qstate_Moist_Size()

int Kessler::Qstate_Moist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return Kessler::n_qstate_moist_size; }

Set_dzmin()

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

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        m_dzmin = dz_min;
    }

Update_Micro_Vars()

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

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        this->Copy_State_to_Micro(cons_in);
    }

Here is the call graph for this function:

Update_State_Vars()

void Kessler::Update_State_Vars ( amrex::MultiFab &  cons_in, const amrex::MultiFab &    )

inlineoverridevirtual

Reimplemented from NullMoist.

    {
        this->Copy_Micro_to_State(cons_in);
    }

Here is the call graph for this function:

Member Data Documentation

CFL_MAX

constexpr amrex::Real Kessler::CFL_MAX = kessler_sedimentation_cfl_max

staticconstexprprivate

dt

amrex::Real Kessler::dt

private

Referenced by Advance().

m_detJ_cc

amrex::MultiFab* Kessler::m_detJ_cc

private

m_do_cond

bool Kessler::m_do_cond

private

Referenced by Define().

m_dzmin

amrex::Real Kessler::m_dzmin

private

Referenced by Set_dzmin().

m_fac_cond

amrex::Real Kessler::m_fac_cond

private

Referenced by Define().

m_geom

amrex::Geometry Kessler::m_geom

private

m_qmoist_size

int Kessler::m_qmoist_size = 1

private

Referenced by Qmoist_Ptr(), and Qmoist_Size().

m_z_phys_nd

amrex::MultiFab* Kessler::m_z_phys_nd

private

mic_fab_vars

amrex::Array<FabPtr, MicVar_Kess::NumVars> Kessler::mic_fab_vars

private

Referenced by Qmoist_Ptr().

MicVarMap

amrex::Vector<int> Kessler::MicVarMap

private

Referenced by Qmoist_Ptr().

n_qstate_moist_numconc_size

int Kessler::n_qstate_moist_numconc_size = 0

private

Referenced by Qstate_Moist_NumConc_Size().

n_qstate_moist_size

int Kessler::n_qstate_moist_size = 3

private

Referenced by Qstate_Moist_Size().

nlev

int Kessler::nlev

private

zhi

int Kessler::zhi

private

zlo

int Kessler::zlo

private

---

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

• Source/Microphysics/Kessler/ERF_Kessler.H
• Source/Microphysics/Kessler/ERF_InitKessler.cpp
• Source/Microphysics/Kessler/ERF_Kessler.cpp
• Source/Microphysics/Kessler/ERF_UpdateKessler.cpp