ERF_Microphysics.H

Go to the documentation of this file.

/*! @file ERF_Microphysics.H
 *  \brief Contains the base class for microphysics
 */
 
#ifndef ERF_MICROPHYSICS_H
#define ERF_MICROPHYSICS_H
 
#include <vector>
#include <string>
#include <AMReX_MultiFab.H>
#include "ERF_DataStruct.H"
#include "ERF_IndexDefines.H"
 
/*! \brief Base class for microphysics interface */
class Microphysics {
 
public:
 
    /*! \brief Null constructor */
    Microphysics () { }
 
    /*! \brief default destructor */
    virtual ~Microphysics () = default;
 
    /*! \brief define the microphysics object */
    virtual void Define (const int&, SolverChoice&) = 0;
 
    /*! \brief initialize the microphysics object */
    virtual void Init (const int&,
                       const amrex::MultiFab&,
                       const amrex::BoxArray&,
                       const amrex::Geometry&,
                       const amrex::Real&,
                       std::unique_ptr<amrex::MultiFab>&,
                       std::unique_ptr<amrex::MultiFab>&) = 0;
 
    /*! \brief finish initializations steps that require flow variables */
    virtual void FinishInit (const int&,
                             amrex::MultiFab&,
                             const amrex::Vector<std::unique_ptr<amrex::MultiFab>>& ) = 0;
 
    /*! \brief advance microphysics for one time step */
    virtual void Advance (const int&,
                          const amrex::Real&,
                          const int&,
                          const amrex::Real&,
                          const SolverChoice&,
                          amrex::Vector<amrex::Vector<amrex::MultiFab>>&,
                          const amrex::Vector<std::unique_ptr<amrex::MultiFab>>&,
                          const amrex::GpuArray<ERF_BC, AMREX_SPACEDIM*2>& ) = 0;
 
    /*! \brief update microphysics variables from ERF state variables */
    virtual void Update_Micro_Vars_Lev (const int&, amrex::MultiFab&) = 0;
 
    /*! \brief update ERF state variables from microphysics variables */
    virtual void Update_State_Vars_Lev (const int&, amrex::MultiFab&, const amrex::MultiFab&) = 0;
 
    /*! \brief average down moisture multifabs from finest_level to 0 (AMR coverage); no-op for non-Lagrangian models */
    virtual void AverageDownMicroVars (const int /*finest_level*/) { }
 
    /*! \brief get pointer to a moisture variable */
    virtual amrex::MultiFab* Get_Qmoist_Ptr (const int&, const int&) = 0;
 
    /*! \brief get the number of moisture model variables */
    virtual int Get_Qmoist_Size (const int&) = 0;
 
    /*! \brief get the number of  microphysics conserved moist (water-related) state variables */
    virtual int Get_Qstate_Moist_Size () = 0;
 
    /*! \brief get the number of  microphysics conserved non-moist (non-water, i.e., other vapor/condensed species) state variables */
    virtual int Get_Qstate_NonMoist_Size () = 0;
 
    /*! \brief get total number of conserved state variables */
    inline int Get_Qstate_Size()
    {
        return Get_Qstate_Moist_Size() + Get_Qstate_NonMoist_Size();
    }
 
    /*! \brief get the indices and names of moisture model variables for restart
               at a given level */
    virtual void Get_Qmoist_Restart_Vars (int,
                                          const SolverChoice&,
                                          std::vector<int>&,
                                          std::vector<std::string>& ) const = 0;
 
    /*! \brief Returns a list of additional plot variable names */
    virtual void GetPlotVarNames (amrex::Vector<std::string>& a_vec) const = 0;
 
    /*! \brief Fills in a MultiFab for plotting */
    virtual void GetPlotVar (const std::string& a_name,
                             amrex::MultiFab& a_mf,
                             const int a_lev) const = 0;
 
    /*! \brief Import minimum dz at this level */
    virtual void Set_dzmin (const int lev,
                            const amrex::Real dz_min) const = 0;
 
    /*! \brief Define the nudging+set width for real BCs */
    virtual void Set_RealWidth (const int lev,
                                const int real_width) const = 0;
 
    /*! \brief query if a specified moisture model is Eulerian or Lagrangian */
    static MoistureModelType modelType (const MoistureType a_moisture_type)
    {
        if (    (a_moisture_type == MoistureType::SAM)
             || (a_moisture_type == MoistureType::SAM_NoIce)
             || (a_moisture_type == MoistureType::SAM_NoPrecip_NoIce)
             || (a_moisture_type == MoistureType::Morrison)
             || (a_moisture_type == MoistureType::Morrison_NoIce)
             || (a_moisture_type == MoistureType::WSM6)
             || (a_moisture_type == MoistureType::Kessler)
             || (a_moisture_type == MoistureType::Kessler_NoRain)
             || (a_moisture_type == MoistureType::SatAdj)
             || (a_moisture_type == MoistureType::None) ) {
            return MoistureModelType::Eulerian;
        } else if ( (a_moisture_type == MoistureType::SuperDroplets) ) {
            return MoistureModelType::Lagrangian;
        } else {
            amrex::Abort("Dont know this moisture_type!") ;
            return MoistureModelType::Undefined;
        }
    }
private:
 
};
#endif