#include <ERF_Kessler.H>

Inheritance diagram for Kessler:

Collaboration diagram for Kessler:

[legend]

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

SurfacePrecipAccumulationSources	Get_Surface_Precip_Accumulation_Ptrs (const int &) const override

virtual void	Update_Micro_Vars (amrex::MultiFab &)

virtual void	Update_Micro_Vars (amrex::MultiFab &cons_in, const amrex::MultiFab *)

Public Member Functions inherited from NullMoist
	NullMoist ()

virtual	~NullMoist ()=default

virtual void	Update_Micro_Vars (amrex::MultiFab &cons_in, const amrex::MultiFab *)

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

MoistureType	m_moisture_type = MoistureType::None

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

46 {}

◆ ~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;
         // NOTE: coef carries only the reference vertical spacing. The physical
         //       spacing is supplied by the inverse Jacobian in the tendency below,
         //       since detJ = dz_phys/CellSize(2). Dividing by m_dzmin here as well
         //       would apply the vertical metric twice. m_dzmin is still the correct
         //       length scale for the substep (CFL) count, which must bound the
         //       thinnest cell in the domain.
         Real coef = dtn * m_geom.InvCellSize(2);
  
         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)
         {
             // The face state and the donor-cap limiter read rho/qp at k-1, which is a ghost
             // cell whenever a box boundary is interior in z. The previous substep updated qp
             // in valid cells only, so refresh ghosts here; otherwise the two sides of a
             // shared z face see different donor values and the column budget does not close.
             mic_fab_vars[MicVar_Kess::qp]->FillBoundary(m_geom.periodicity());
  
             for ( MFIter mfi(*tabs, TileNoZ()); 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.growntilebox();
  
         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.

     {
         m_moisture_type = sc.moisture_type;
         // 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.uses_shoc_family());
     }

Here is the call graph for this function:

◆ Get_Surface_Precip_Accumulation_Ptrs()

SurfacePrecipAccumulationSources Kessler::Get_Surface_Precip_Accumulation_Ptrs ( const int & ) const

inlineoverridevirtual

Reimplemented from NullMoist.

     {
         if (m_moisture_type == MoistureType::Kessler_NoRain) {
             return {};
         }
  
         SurfacePrecipAccumulationSources sources;
         sources.rain = {mic_fab_vars[MicVar_Kess::rain_accum].get(), rhor / amrex::Real(1000.0)};
         return sources;
     }

◆ 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.

124 { return Kessler::m_qmoist_size; }

◆ Qstate_Moist_NumConc_Size()

int Kessler::Qstate_Moist_NumConc_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

130 { return Kessler::n_qstate_moist_numconc_size; }

Kessler::n_qstate_moist_numconc_size

int n_qstate_moist_numconc_size

Definition: ERF_Kessler.H:164

◆ Qstate_Moist_Size()

int Kessler::Qstate_Moist_Size ( )

inlineoverridevirtual

Reimplemented from NullMoist.

127 { return Kessler::n_qstate_moist_size; }

Kessler::n_qstate_moist_size

int n_qstate_moist_size

Definition: ERF_Kessler.H:161

◆ Set_dzmin()

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

inlineoverridevirtual

Reimplemented from NullMoist.

     {
         m_dzmin = dz_min;
     }

◆ Update_Micro_Vars() [1/3]

virtual void NullMoist::Update_Micro_Vars

inline

35 { }

◆ Update_Micro_Vars() [2/3]

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_Micro_Vars() [3/3]

virtual void NullMoist::Update_Micro_Vars

inline

                                                {
         Update_Micro_Vars(cons_in);
     }

◆ 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_moisture_type

MoistureType Kessler::m_moisture_type = MoistureType::None

private

Referenced by Define(), and Get_Surface_Precip_Accumulation_Ptrs().

◆ 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 Get_Surface_Precip_Accumulation_Ptrs(), and 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

Public Member Functions

Private Types

Private Attributes

Static Private Attributes

Member Typedef Documentation

◆ FabPtr

Constructor & Destructor Documentation

◆ Kessler()

◆ ~Kessler()

Member Function Documentation

◆ Advance()

◆ AdvanceKessler()

◆ Copy_Micro_to_State()

◆ Copy_State_to_Micro()

◆ Define()

◆ Get_Surface_Precip_Accumulation_Ptrs()

◆ Init()

◆ Qmoist_Ptr()

◆ Qmoist_Restart_Vars()

◆ Qmoist_Size()

◆ Qstate_Moist_NumConc_Size()

◆ Qstate_Moist_Size()

◆ Set_dzmin()

◆ Update_Micro_Vars() [1/3]

◆ Update_Micro_Vars() [2/3]

◆ Update_Micro_Vars() [3/3]

◆ Update_State_Vars()

Member Data Documentation

◆ CFL_MAX

◆ dt

◆ m_detJ_cc

◆ m_do_cond

◆ m_dzmin

◆ m_fac_cond

◆ m_geom

◆ m_moisture_type

◆ m_qmoist_size

◆ m_z_phys_nd

◆ mic_fab_vars

◆ MicVarMap

◆ n_qstate_moist_numconc_size

◆ n_qstate_moist_size

◆ nlev

◆ zhi

◆ zlo