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	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	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 = 1
int	n_qstate_moist_size = 3
amrex::Vector< int >	MicVarMap
amrex::Geometry	m_geom
amrex::BoxArray	m_gtoe
amrex::Real	dt
int	nlev
int	zlo
int	zhi
int	m_axis
amrex::Real	m_fac_cond
amrex::Real	m_fac_fus
amrex::Real	m_fac_sub
amrex::Real	m_gOcp
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 = 0.5

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.

{
    auto tabs  = mic_fab_vars[MicVar_Kess::tabs];
    if (solverChoice.moisture_type == MoistureType::Kessler){
        auto dz = m_geom.CellSize(2);
        auto domain = m_geom.Domain();
        int k_lo = domain.smallEnd(2);
        int k_hi = domain.bigEnd(2);
 
        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/dz;
 
        // Saturation and evaporation calculations go first
        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);
 
            const auto& tbx = mfi.tilebox();
 
            // Expose for GPU
            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(0.0, qv_array(i,j,k));
                qc_array(i,j,k) = std::max(0.0, qc_array(i,j,k));
                qp_array(i,j,k) = std::max(0.0, qp_array(i,j,k));
 
                //------- Autoconversion/accretion
                Real qcc, auto_r, accrr;
                Real qsat, dtqsat;
                Real dq_clwater_to_rain, dq_rain_to_vapor, dq_clwater_to_vapor, dq_vapor_to_clwater;
 
                Real pressure = pres_array(i,j,k);
                erf_qsatw(tabs_array(i,j,k), pressure, qsat);
                erf_dtqsatw(tabs_array(i,j,k), pressure, dtqsat);
 
                if (qsat <= 0.0) {
                    amrex::Warning("qsat computed as non-positive; setting to 0.!");
                    qsat = 0.0;
                }
 
                // If there is precipitating water (i.e. rain), and the cell is not saturated
                // then the rain water can evaporate leading to extraction of latent heat, hence
                // reducing temperature and creating negative buoyancy
 
                dq_clwater_to_rain  = 0.0;
                dq_rain_to_vapor    = 0.0;
                dq_vapor_to_clwater = 0.0;
                dq_clwater_to_vapor = 0.0;
 
                //Real fac = qsat*4093.0*L_v/(Cp_d*std::pow(tabs_array(i,j,k)-36.0,2));
                //Real fac = qsat*L_v*L_v/(Cp_d*R_v*tabs_array(i,j,k)*tabs_array(i,j,k));
                Real fac = (L_v/Cp_d)*dtqsat;
 
                // If water vapor content exceeds saturation value, then vapor condenses to water and latent heat is released, increasing temperature
                if (qv_array(i,j,k) > qsat) {
                    dq_vapor_to_clwater = std::min(qv_array(i,j,k), (qv_array(i,j,k)-qsat)/(1.0 + fac));
                }
 
                // If water vapor is less than the saturated value, then the cloud water can evaporate,
                // leading to evaporative cooling and reducing temperature
                if (qv_array(i,j,k) < qsat && qc_array(i,j,k) > 0.0) {
                    dq_clwater_to_vapor = std::min(qc_array(i,j,k), (qsat - qv_array(i,j,k))/(1.0 + fac));
                }
 
                if (qp_array(i,j,k) > 0.0 && qv_array(i,j,k) < qsat) {
                    Real C = 1.6 + 124.9*std::pow(0.001*rho_array(i,j,k)*qp_array(i,j,k),0.2046);
                    dq_rain_to_vapor = 1.0/(0.001*rho_array(i,j,k))*(1.0 - qv_array(i,j,k)/qsat)*C*std::pow(0.001*rho_array(i,j,k)*qp_array(i,j,k),0.525)/
                        (5.4e5 + 2.55e6/(pressure*qsat))*dtn;
                    // The negative sign is to make this variable (vapor formed from evaporation)
                    // a positive quantity (as qv/qs < 1)
                    dq_rain_to_vapor = std::min({qp_array(i,j,k), dq_rain_to_vapor});
 
                    // Removing latent heat due to evaporation from rain water to water vapor, reduces the (potential) temperature
                }
 
                // If there is cloud water present then do accretion and autoconversion to rain
                if (qc_array(i,j,k) > 0.0) {
                    qcc = qc_array(i,j,k);
 
                    auto_r = 0.0;
                    if (qcc > qcw0) {
                        auto_r = alphaelq;
                    }
 
                    accrr = 0.0;
                    accrr = 2.2 * std::pow(qp_array(i,j,k) , 0.875);
                    dq_clwater_to_rain = dtn *(accrr*qcc + auto_r*(qcc - qcw0));
 
                    // If the amount of change is more than the amount of qc present, then dq = qc
                    dq_clwater_to_rain = std::min(dq_clwater_to_rain, qc_array(i,j,k));
                }
 
                qv_array(i,j,k) += -dq_vapor_to_clwater + dq_clwater_to_vapor + dq_rain_to_vapor;
                qc_array(i,j,k) +=  dq_vapor_to_clwater - dq_clwater_to_vapor - dq_clwater_to_rain;
                qp_array(i,j,k) +=  dq_clwater_to_rain - 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 * (dq_vapor_to_clwater - dq_clwater_to_vapor - dq_rain_to_vapor);
 
                qv_array(i,j,k) = std::max(0.0, qv_array(i,j,k));
                qc_array(i,j,k) = std::max(0.0, qc_array(i,j,k));
                qp_array(i,j,k) = std::max(0.0, qp_array(i,j,k));
 
                qt_array(i,j,k) = qv_array(i,j,k) + qc_array(i,j,k);
            });
        }
 
        // Precompute terminal velocity for substepping
        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
            {
                Real rho_avg, qp_avg;
 
                if (k==k_lo) {
                    rho_avg = rho_array(i,j,k);
                    qp_avg  = qp_array(i,j,k);
                } else if (k==k_hi+1) {
                    rho_avg = rho_array(i,j,k-1);
                    qp_avg  = qp_array(i,j,k-1);
                } else {
                    rho_avg = 0.5*(rho_array(i,j,k-1) + rho_array(i,j,k)); // Convert to g/cm^3
                    qp_avg = 0.5*(qp_array(i,j,k-1)  + qp_array(i,j,k));
                }
 
                qp_avg = std::max(0.0, qp_avg);
 
                Real V_terminal = 36.34*std::pow(rho_avg*0.001*qp_avg, 0.1346)*std::pow(rho_avg/1.16, -0.5); // in m/s
 
                // NOTE: Fz is the sedimentation flux from the advective operator.
                //       In the terrain-following coordinate system, the z-deriv in
                //       the divergence uses the normal velocity (Omega). However,
                //       there are no u/v components to the sedimentation velocity.
                //       Therefore, we simply end up with a division by detJ when
                //       evaluating the source term: dJinv * (flux_hi - flux_lo) * dzinv.
                fz_array(i,j,k) = rho_avg*V_terminal*qp_avg;
            });
        } // mfi
 
        // Compute number of substeps from maximum terminal velocity
        Real wt_max;
        int n_substep;
        auto const& ma_fz_arr = fz.const_arrays();
        GpuTuple<Real> max = ParReduce(TypeList<ReduceOpMax>{},
                                       TypeList<Real>{},
                                       fz, IntVect(0),
                                       [=] AMREX_GPU_DEVICE (int box_no, int i, int j, int k) noexcept
                                       -> GpuTuple<Real>
                                       {
                                           return { ma_fz_arr[box_no](i,j,k) };
                                       });
        wt_max = get<0>(max) + std::numeric_limits<Real>::epsilon();
        n_substep = int( std::ceil(wt_max * coef / CFL_MAX) );
        AMREX_ALWAYS_ASSERT(n_substep >= 1);
        coef /= Real(n_substep);
        dtn  /= Real(n_substep);
 
        // Substep the vertical advection
        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));
 
                // Update vertical flux every substep
                ParallelFor(tbz, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
                {
                    Real rho_avg, qp_avg;
                    if (k==k_lo) {
                        rho_avg = rho_array(i,j,k);
                        qp_avg  = qp_array(i,j,k);
                    } else if (k==k_hi+1) {
                        rho_avg = rho_array(i,j,k-1);
                        qp_avg  = qp_array(i,j,k-1);
                    } else {
                        rho_avg = 0.5*(rho_array(i,j,k-1) + rho_array(i,j,k)); // Convert to g/cm^3
                        qp_avg = 0.5*(qp_array(i,j,k-1)  + qp_array(i,j,k));
                    }
 
                    qp_avg = std::max(0.0, qp_avg);
 
                    Real V_terminal = 36.34*std::pow(rho_avg*0.001*qp_avg, 0.1346)*std::pow(rho_avg/1.16, -0.5); // in m/s
 
                    // NOTE: Fz is the sedimentation flux from the advective operator.
                    //       In the terrain-following coordinate system, the z-deriv in
                    //       the divergence uses the normal velocity (Omega). However,
                    //       there are no u/v components to the sedimentation velocity.
                    //       Therefore, we simply end up with a division by detJ when
                    //       evaluating the source term: dJinv * (flux_hi - flux_lo) * dzinv.
                    fz_array(i,j,k) = rho_avg*V_terminal*qp_avg;
 
                    if(k==k_lo){
                        rain_accum_array(i,j,k) = rain_accum_array(i,j,k) + rho_avg*qp_avg*V_terminal*dtn/1000.0*1000.0; // Divide by rho_water and convert to mm
                    }
                });
 
                // Update precip every substep
                ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
                {
                    // Jacobian determinant
                    Real dJinv = (dJ_array) ? 1.0/dJ_array(i,j,k) : 1.0;
 
                    if(std::fabs(fz_array(i,j,k+1)) < 1e-14) fz_array(i,j,k+1) = 0.0;
                    if(std::fabs(fz_array(i,j,k  )) < 1e-14) fz_array(i,j,k  ) = 0.0;
                    Real dq_sed = dJinv * (1.0/rho_array(i,j,k)) * (fz_array(i,j,k+1) - fz_array(i,j,k)) * coef;
                    if(std::fabs(dq_sed) < 1e-14) dq_sed = 0.0;
 
                    qp_array(i,j,k) +=  dq_sed;
                    qp_array(i,j,k)  = std::max(0.0, qp_array(i,j,k));
                });
            } // mfi
        } // nsub
    }
 
 
    if (solverChoice.moisture_type == MoistureType::Kessler_NoRain){
 
        // get the temperature, density, theta, qt and qc from input
        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);
 
            const auto& box3d = mfi.tilebox();
 
            // Expose for GPU
            Real d_fac_cond = m_fac_cond;
 
            ParallelFor(box3d, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
            {
                qc_array(i,j,k) = std::max(0.0, qc_array(i,j,k));
 
                //------- Autoconversion/accretion
                Real qsat, dtqsat;
                Real dq_clwater_to_vapor, dq_vapor_to_clwater;
 
                Real pressure = pres_array(i,j,k);
                erf_qsatw(tabs_array(i,j,k), pressure, qsat);
                erf_dtqsatw(tabs_array(i,j,k), pressure, dtqsat);
 
                // If there is precipitating water (i.e. rain), and the cell is not saturated
                // then the rain water can evaporate leading to extraction of latent heat, hence
                // reducing temperature and creating negative buoyancy
 
                dq_vapor_to_clwater = 0.0;
                dq_clwater_to_vapor = 0.0;
 
                //Real fac = qsat*4093.0*L_v/(Cp_d*std::pow(tabs_array(i,j,k)-36.0,2));
                //Real fac = qsat*L_v*L_v/(Cp_d*R_v*tabs_array(i,j,k)*tabs_array(i,j,k));
                Real fac = (L_v/Cp_d)*dtqsat;
 
                // If water vapor content exceeds saturation value, then vapor condenses to water and latent heat is released, increasing temperature
                if (qv_array(i,j,k) > qsat){
                    dq_vapor_to_clwater = std::min(qv_array(i,j,k), (qv_array(i,j,k)-qsat)/(1.0 + fac));
                }
                // If water vapor is less than the saturated value, then the cloud water can evaporate, leading to evaporative cooling and
                // reducing temperature
                if (qv_array(i,j,k) < qsat && qc_array(i,j,k) > 0.0){
                    dq_clwater_to_vapor = std::min(qc_array(i,j,k), (qsat - qv_array(i,j,k))/(1.0 + fac));
                }
 
                qv_array(i,j,k) += -dq_vapor_to_clwater + dq_clwater_to_vapor;
                qc_array(i,j,k) +=  dq_vapor_to_clwater - dq_clwater_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 * (dq_vapor_to_clwater - dq_clwater_to_vapor);
 
                qv_array(i,j,k) = std::max(0.0, qv_array(i,j,k));
                qc_array(i,j,k) = std::max(0.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 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);
 
        // Get pressure, theta, temperature, density, and qt, qp
        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)) * 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.

    {
        m_fac_cond = lcond / sc.c_p;
        m_fac_fus = lfus / sc.c_p;
        m_fac_sub = lsub / sc.c_p;
        m_gOcp = CONST_GRAV / sc.c_p;
        m_axis = sc.ave_plane;
    }

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_gtoe = grids;
 
    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();
    }

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_Size()

int Kessler::Qstate_Moist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

{ return Kessler::n_qstate_moist_size; }

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 )

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 = 0.5

staticconstexprprivate

dt

amrex::Real Kessler::dt

private

Referenced by Advance().

m_axis

int Kessler::m_axis

private

Referenced by Define().

m_detJ_cc

amrex::MultiFab* Kessler::m_detJ_cc

private

m_fac_cond

amrex::Real Kessler::m_fac_cond

private

Referenced by Define().

m_fac_fus

amrex::Real Kessler::m_fac_fus

private

Referenced by Define().

m_fac_sub

amrex::Real Kessler::m_fac_sub

private

Referenced by Define().

m_geom

amrex::Geometry Kessler::m_geom

private

m_gOcp

amrex::Real Kessler::m_gOcp

private

Referenced by Define().

m_gtoe

amrex::BoxArray Kessler::m_gtoe

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_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