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 <AMReX_iMultiFab.H>
#include "ERF_DataStruct.H"
#include "ERF_IndexDefines.H"
#include "ERF_SurfacePrecipitation.H"
#include "ERF_SedimentationFlux.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&,
                                        const amrex::MultiFab* base_state = nullptr) = 0;
 
    /*! \brief update ERF state variables from microphysics variables */
    virtual void Update_State_Vars_Lev (const int&, amrex::MultiFab&, const amrex::MultiFab&) = 0;
 
    /*! Refresh diagnostic Q projections after particle redistribution, without advancing sources. */
    virtual void Update_Diagnostic_State_Lev (const int&, amrex::MultiFab&, const amrex::MultiFab&) {}
 
    /*! \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 scheme-native surface precipitation accumulators and their kg/m^2 conversion factors */
    virtual SurfacePrecipAccumulationSources
    Get_Surface_Precip_Accumulation_Ptrs (const int&) const
    {
        return {};
    }
 
    /*! \brief The sedimentation face fluxes of the most recent Advance at a level, or null
     *         when the moisture model does not sediment there (see ERF_SedimentationFlux.H) */
    virtual const SedimentationFlux* Get_Sed_Flux (const int& /*lev*/) const { return nullptr; }
 
    /*! \brief Hand the moisture model at a level the inflow through the top of its fine
     *         patches for the next Advance, or null (see ERF_SedimentationFlux.H) */
    virtual void Set_Sed_Inflow (const int& /*lev*/, const amrex::MultiFab* /*inflow*/) { }
 
    /*! \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 moist (water-related) state variables that are number concentrations */
    virtual int Get_Qstate_Moist_NumConc_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 Whether a Q-state offset is a projection rather than host-transported state. */
    virtual bool Qstate_Is_Diagnostic (int /*q*/) const { return false; }
 
    /*! \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 Import ERF's land/water mask at this level.
     *
     *  The mask is held by pointer, not copied, so a mask that is retagged after
     *  this call (e.g. buildings set to 2 in init_zphys) is picked up. Callers
     *  must re-issue this after any rebuild of lmask_lev, since init_stuff
     *  replaces the unique_ptr. */
    virtual void Set_Lmask (const int lev,
                            amrex::iMultiFab* lmask) 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::WDM6)
             || (a_moisture_type == MoistureType::Kessler)
             || (a_moisture_type == MoistureType::Kessler_NoRain)
             || (a_moisture_type == MoistureType::SatAdj)
             || (a_moisture_type == MoistureType::MoistNoCondensation)
             || (a_moisture_type == MoistureType::SBM)
             || (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