ERF_Kessler.H

Go to the documentation of this file.

#ifndef ERF_Kessler_H
#define ERF_Kessler_H
 
#include <string>
#include <vector>
#include <memory>
 
#include <AMReX_FArrayBox.H>
#include <AMReX_Geometry.H>
#include <AMReX_TableData.H>
#include <AMReX_MultiFabUtil.H>
 
#include "ERF_Constants.H"
#include "ERF_KesslerUtils.H"
#include "ERF_MicrophysicsUtils.H"
#include "ERF_IndexDefines.H"
#include "ERF_DataStruct.H"
#include "ERF_NullMoist.H"
#include "ERF_SurfacePrecipitation.H"
 
namespace MicVar_Kess {
   enum {
      // independent variables
      rho=0, // density
      theta, // liquid/ice water potential temperature
      tabs,  // temperature
      pres,  // pressure
      // non-precipitating vars
      qt,    // total cloud
      qv,    // cloud vapor
      qcl,   // cloud water
      // precipitating vars
      qp,    // total precip
      // derived vars
      rain_accum,
      NumVars
  };
}
 
class Kessler : public NullMoist {
 
    using FabPtr = std::shared_ptr<amrex::MultiFab>;
 
public:
    // constructor
    Kessler () {}
 
    // destructor
    virtual ~Kessler () = default;
 
    // cloud physics
    void AdvanceKessler (const SolverChoice &solverChoice);
 
    // Set up for first time
    void
    Define (SolverChoice& sc) override
    {
        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());
    }
 
    // init
    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;
 
    // Import minimum dz at this level
    void
    Set_dzmin (const amrex::Real dz_min) override
    {
        m_dzmin = dz_min;
    }
 
    // Copy state into micro vars
    void
    Copy_State_to_Micro (const amrex::MultiFab& cons_in) override;
 
    // Copy state into micro vars
    void
    Copy_Micro_to_State (amrex::MultiFab& cons_in) override;
 
    using NullMoist::Update_Micro_Vars;
 
    // update micro vars
    void
    Update_Micro_Vars (amrex::MultiFab& cons_in) override
    {
        this->Copy_State_to_Micro(cons_in);
    }
 
    // update state vars
    void
    Update_State_Vars (amrex::MultiFab& cons_in,
                       const amrex::MultiFab& /*z_phys_nd*/) override
    {
        this->Copy_Micro_to_State(cons_in);
    }
 
    // wrapper to advance micro vars
    void
    Advance (const amrex::Real& dt_advance,
             const SolverChoice& solverChoice) override
    {
        dt = dt_advance;
 
        this->AdvanceKessler(solverChoice);
    }
 
    amrex::MultiFab*
    Qmoist_Ptr (const int& varIdx) override
    {
        AMREX_ALWAYS_ASSERT(varIdx < m_qmoist_size);
        return mic_fab_vars[MicVarMap[varIdx]].get();
    }
 
    int
    Qmoist_Size () override { return Kessler::m_qmoist_size; }
 
    int
    Qstate_Moist_Size () override { return Kessler::n_qstate_moist_size; }
 
    int
    Qstate_Moist_NumConc_Size () override { return Kessler::n_qstate_moist_numconc_size; }
 
    void
    Qmoist_Restart_Vars (const SolverChoice& /*a_sc*/,
                         std::vector<int>& a_idx,
                         std::vector<std::string>& a_names) const override
    {
        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");
    }
 
    SurfacePrecipAccumulationSources
    Get_Surface_Precip_Accumulation_Ptrs (const int&) const override
    {
        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;
    }
 
private:
    // Number of qmoist variables (rain_accum)
    int m_qmoist_size = 1;
 
    // Number of qstate variables
    int n_qstate_moist_size = 3;
 
    // Number of qstate variables that are number concentrations
    int n_qstate_moist_numconc_size = 0;
 
    // CFL MAX for vertical advection
    static constexpr amrex::Real CFL_MAX = kessler_sedimentation_cfl_max;
 
    // MicVar map (Qmoist indices -> MicVar enum)
    amrex::Vector<int> MicVarMap;
 
    // geometry
    amrex::Geometry m_geom;
 
    // timestep
    amrex::Real dt;
 
    // Minimum dz at this level
    amrex::Real m_dzmin;
 
    // number of vertical levels
    int nlev, zlo, zhi;
 
    // constants
    amrex::Real m_fac_cond;
    bool m_do_cond;
    MoistureType m_moisture_type = MoistureType::None;
 
    // Pointer to terrain data
    amrex::MultiFab* m_z_phys_nd;
    amrex::MultiFab* m_detJ_cc;
 
    // independent variables
    amrex::Array<FabPtr, MicVar_Kess::NumVars> mic_fab_vars;
};
#endif