LandSurface Class Reference

Wrapper class for managing land surface models across AMR levels. More...

#include <ERF_LandSurface.H>

Collaboration diagram for LandSurface:

Public Member Functions
	LandSurface ()
	~LandSurface ()=default
void	ReSize (const int &nlev)
template<class NewSurfModel >
void	SetModel ()
void	Define (const int &lev, SolverChoice &sc)
void	Init (const int &lev, const amrex::MultiFab &cons_in, const amrex::Geometry &geom, const amrex::Geometry &geom0, amrex::Vector< amrex::BCRec > &domain_bcs_type, amrex::IntVect &refRatio, const amrex::Real &dt_advance, amrex::Vector< amrex::Vector< std::string >> &nc_init_file)
void	Advance (const int &lev, amrex::MultiFab &cons_in, amrex::MultiFab &xvel_in, amrex::MultiFab &yvel_in, amrex::MultiFab *hfx3_out, amrex::MultiFab *qfx3_out, const SurfacePrecipAccumulationSources &precip_sources, const double &time_d, const double &dt_advance_d, const int &nstep, const bool updated_lev0)
void	Advance (const int &lev, const double &dt_advance_d)
void	Plot (const int &lev, const int &nstep)
void	Update_Micro_Vars_Lev (const int &lev, amrex::MultiFab &cons_in)
void	Update_State_Vars_Lev (const int &lev, amrex::MultiFab &cons_in)
amrex::MultiFab *	Get_Data_Ptr (const int &lev, const int &varIdx)
amrex::MultiFab *	Get_Data_Ptr (const int &lev, const std::string &varname)
bool	Has_Model () const
amrex::MultiFab *	Get_Flux_Ptr (const int &lev, const int &varIdx)
amrex::Geometry	Get_Lsm_Geom (const int &lev)
int	Get_Data_Size ()
int	Get_Flux_Size ()
std::string	Get_DataName (const int &varIdx)
amrex::Vector< std::string >	Get_DataNames ()
int	Get_DataIdx (const int &lev, std::string &varname)
void	Set_Lev0_Data_Ptr (const int &lev)
std::string	Get_FluxName (const int &varIdx)
int	Get_FluxIdx (const int &lev, std::string &varname)
void	Set_Lev0_Flux_Ptr (const int &lev)
bool	Get_LSM_Update_Status (const int &lev)
std::unordered_map< std::string, std::string > &	Get_WRFInputNames ()
int	Get_LSM_Step (const int &lev) const
void	Set_LSM_Step (const int &lev, int step)
void	Write_Lsm_Restart (const int &lev, const std::string &dir) const
void	Read_Lsm_Restart (const int &lev, const std::string &dir)
void	Plot_Lsm_Data (double time, int finest_level, const amrex::Vector< int > &level_steps, const amrex::Vector< amrex::IntVect > &ref_ratio)
template<class SurfModelType >
SurfModelType *	get_model_lev (const int &lev)

Private Attributes
amrex::Vector< std::unique_ptr< NullSurf > >	m_lsm_model
std::string	plot_file_lsm {"plt_lsm_"}
amrex::Vector< amrex::Geometry >	m_lsm_geom_lev
amrex::Vector< amrex::MultiFab >	m_lsm_data_lev

Detailed Description

Wrapper class for managing land surface models across AMR levels.

Constructor & Destructor Documentation

LandSurface()

LandSurface::LandSurface ( )

inline

{ }

~LandSurface()

LandSurface::~LandSurface ( )

default

Member Function Documentation

Advance() [1/2]

void LandSurface::Advance ( const int &  lev, amrex::MultiFab &  cons_in, amrex::MultiFab &  xvel_in, amrex::MultiFab &  yvel_in, amrex::MultiFab *  hfx3_out, amrex::MultiFab *  qfx3_out, const SurfacePrecipAccumulationSources &  precip_sources, const double &  time_d, const double &  dt_advance_d, const int &  nstep, const bool  updated_lev0  )

inline

    {
        amrex::Real time = static_cast<amrex::Real>(time_d);
        amrex::Real dt_advance = static_cast<amrex::Real>(dt_advance_d);
        m_lsm_model[lev]->Advance_With_State(lev, cons_in, xvel_in, yvel_in,
                                             hfx3_out, qfx3_out,
                                             precip_sources,
                                             time, dt_advance, nstep, updated_lev0);
    }

Advance() [2/2]

void LandSurface::Advance ( const int &  lev, const double &  dt_advance_d  )

inline

    {
        amrex::Real dt_advance = static_cast<amrex::Real>(dt_advance_d);
        m_lsm_model[lev]->Advance(dt_advance);
    }

Define()

void LandSurface::Define ( const int &  lev, SolverChoice &  sc  )

inline

    {
        m_lsm_model[lev]->Define(sc);
    }

Get_Data_Ptr() [1/2]

amrex::MultiFab* LandSurface::Get_Data_Ptr ( const int &  lev, const int &  varIdx  )

inline

{ return m_lsm_model[lev]->Lsm_Data_Ptr(varIdx); }

Referenced by Plot_Lsm_Data(), and Set_Lev0_Data_Ptr().

Here is the caller graph for this function:

Get_Data_Ptr() [2/2]

amrex::MultiFab* LandSurface::Get_Data_Ptr ( const int &  lev, const std::string &  varname  )

inline

    {
        std::string name = varname;
        const int index = m_lsm_model[lev]->Lsm_DataIndex(name);
        return (index >= 0) ? m_lsm_model[lev]->Lsm_Data_Ptr(index) : nullptr;
    }

Get_Data_Size()

int LandSurface::Get_Data_Size ( )

inline

{ return m_lsm_model[0]->Lsm_Data_Size(); }

Referenced by Get_DataNames(), Plot_Lsm_Data(), and Set_Lev0_Data_Ptr().

Here is the caller graph for this function:

Get_DataIdx()

int LandSurface::Get_DataIdx ( const int &  lev, std::string &  varname  )

inline

{ return m_lsm_model[lev]->Lsm_DataIndex(varname); }

Get_DataName()

std::string LandSurface::Get_DataName ( const int &  varIdx )

inline

{ return m_lsm_model[0]->Lsm_DataName(varIdx); }

Referenced by Get_DataNames(), and Plot_Lsm_Data().

Here is the caller graph for this function:

Get_DataNames()

amrex::Vector<std::string> LandSurface::Get_DataNames ( )

inline

    {
        amrex::Vector<std::string> names;
        if (m_lsm_model.empty() || m_lsm_model[0] == nullptr) {
            return names;
        }
        const int nvars = Get_Data_Size();
        names.reserve(nvars);
        for (int var = 0; var < nvars; ++var) {
            names.push_back(Get_DataName(var));
        }
        return names;
    }

Here is the call graph for this function:

Get_Flux_Ptr()

amrex::MultiFab* LandSurface::Get_Flux_Ptr ( const int &  lev, const int &  varIdx  )

inline

{ return m_lsm_model[lev]->Lsm_Flux_Ptr(varIdx); }

Referenced by Set_Lev0_Flux_Ptr().

Here is the caller graph for this function:

Get_Flux_Size()

int LandSurface::Get_Flux_Size ( )

inline

{ return m_lsm_model[0]->Lsm_Flux_Size(); }

Referenced by Set_Lev0_Flux_Ptr().

Here is the caller graph for this function:

Get_FluxIdx()

int LandSurface::Get_FluxIdx ( const int &  lev, std::string &  varname  )

inline

{ return m_lsm_model[lev]->Lsm_FluxIndex(varname); }

Get_FluxName()

std::string LandSurface::Get_FluxName ( const int &  varIdx )

inline

{ return m_lsm_model[0]->Lsm_FluxName(varIdx); }

Get_Lsm_Geom()

amrex::Geometry LandSurface::Get_Lsm_Geom ( const int &  lev )

inline

{ return m_lsm_model[lev]->Lsm_Geom(); }

Referenced by Plot_Lsm_Data().

Here is the caller graph for this function:

Get_LSM_Step()

int LandSurface::Get_LSM_Step ( const int &  lev ) const

inline

{ return m_lsm_model[lev]->Get_LSM_Step(); }

Get_LSM_Update_Status()

bool LandSurface::Get_LSM_Update_Status ( const int &  lev )

inline

{ return m_lsm_model[lev]->Get_Update_Status(); }

get_model_lev()

template<class SurfModelType >

SurfModelType* LandSurface::get_model_lev ( const int &  lev )

inline

                                                 {
        return static_cast<SurfModelType*>(m_lsm_model[lev].get());
    }

Get_WRFInputNames()

std::unordered_map<std::string,std::string>& LandSurface::Get_WRFInputNames ( )

inline

{ return m_lsm_model[0]->Lsm_WRFInputNames(); }

Has_Model()

bool LandSurface::Has_Model ( ) const

inline

{ return !m_lsm_model.empty() && m_lsm_model[0] != nullptr; }

Init()

void LandSurface::Init ( const int &  lev, const amrex::MultiFab &  cons_in, const amrex::Geometry &  geom, const amrex::Geometry &  geom0, amrex::Vector< amrex::BCRec > &  domain_bcs_type, amrex::IntVect &  refRatio, const amrex::Real &  dt_advance, amrex::Vector< amrex::Vector< std::string >> &  nc_init_file  )

inline

    {
        m_lsm_model[lev]->Init(lev, cons_in, geom, geom0,
                               domain_bcs_type, refRatio,
                               dt_advance, nc_init_file);
    }

Plot()

void LandSurface::Plot ( const int &  lev, const int &  nstep  )

inline

    {
        m_lsm_model[lev]->Plot_Landfile(nstep);
    }

Plot_Lsm_Data()

void LandSurface::Plot_Lsm_Data ( double  time, int  finest_level, const amrex::Vector< int > &  level_steps, const amrex::Vector< amrex::IntVect > &  ref_ratio  )

inline

    {
        // Note we must use finest_level here rather than m_lsm_model.size(), which is
        //    (max_level+1) -- the models at levels that have not (yet) been created
        //    have been allocated but not Define'd or Init'ed, so their data pointers
        //    are still null
        int nlev = finest_level + 1;
        int nvar = this->Get_Data_Size();
        amrex::Vector<std::string> varnames;
 
        // Only write if we have valid pointers
        if (this->Get_Data_Ptr(0,0)) {
            varnames.resize(nvar);
            m_lsm_geom_lev.resize(nlev);
            m_lsm_data_lev.resize(nlev);
            std::string plotfilename = amrex::Concatenate(plot_file_lsm, level_steps[0], 5);
            for (int lev(0); lev<nlev; ++lev) {
                m_lsm_geom_lev[lev] = this->Get_Lsm_Geom(lev);
 
                amrex::MultiFab* mf_lsm = this->Get_Data_Ptr(lev,0);
                amrex::IntVect ng(0,0,0);
                amrex::BoxArray ba = mf_lsm->boxArray();
                amrex::DistributionMapping dm = mf_lsm->DistributionMap();
                m_lsm_data_lev[lev].define(ba, dm, nvar, ng);
                for (int n(0); n<nvar; ++n) {
                    mf_lsm = this->Get_Data_Ptr(lev,n);
                    amrex::MultiFab::Copy(m_lsm_data_lev[lev],*(mf_lsm),0,n,1,0);
                    if (lev==0) varnames[n] = this->Get_DataName(n);
                }
            }
            WriteMultiLevelPlotfile (plotfilename, nlev, GetVecOfConstPtrs(m_lsm_data_lev),
                                     varnames, m_lsm_geom_lev, static_cast<amrex::Real>(time),
                                     level_steps, ref_ratio);
            m_lsm_geom_lev.clear();
            m_lsm_data_lev.clear();
        }
    }

Here is the call graph for this function:

Read_Lsm_Restart()

void LandSurface::Read_Lsm_Restart ( const int &  lev, const std::string &  dir  )

inline

{ m_lsm_model[lev]->Read_Lsm_Restart(dir); }

ReSize()

void LandSurface::ReSize ( const int &  nlev )

inline

{ m_lsm_model.resize(nlev); }

Referenced by ERF::ERF_shared().

Here is the caller graph for this function:

Set_Lev0_Data_Ptr()

void LandSurface::Set_Lev0_Data_Ptr ( const int &  lev )

inline

                                       {
        // Ensure the same type of model for copy in place of flux data
        if ( (lev > 0) && typeid(m_lsm_model[lev]) == typeid(m_lsm_model[0]) ) {
            int ndata = this->Get_Data_Size();
            for (int varIdx(0); varIdx<ndata; ++varIdx) {
                amrex::MultiFab* Lev0_Data_Ptr = this->Get_Data_Ptr(0, varIdx);
                m_lsm_model[lev]->Lsm_Set_Lev0_Data_Ptr(varIdx, Lev0_Data_Ptr);
            }
        } else {
            amrex::Abort("Differing types of land surface models across levels is not supported!");
        }
    }

Here is the call graph for this function:

Set_Lev0_Flux_Ptr()

void LandSurface::Set_Lev0_Flux_Ptr ( const int &  lev )

inline

                                       {
        // Ensure the same type of model for copy in place of flux data
        if ( (lev > 0) && typeid(m_lsm_model[lev]) == typeid(m_lsm_model[0]) ) {
            int nflux = this->Get_Flux_Size();
            for (int varIdx(0); varIdx<nflux; ++varIdx) {
                amrex::MultiFab* Lev0_Flux_Ptr = this->Get_Flux_Ptr(0, varIdx);
                m_lsm_model[lev]->Lsm_Set_Lev0_Flux_Ptr(varIdx, Lev0_Flux_Ptr);
            }
        } else {
            amrex::Abort("Differing types of land surface models across levels is not supported!");
        }
    }

Here is the call graph for this function:

Set_LSM_Step()

void LandSurface::Set_LSM_Step ( const int &  lev, int  step  )

inline

{ m_lsm_model[lev]->Set_LSM_Step(step); }

SetModel()

template<class NewSurfModel >

void LandSurface::SetModel ( )

inline

    {
        for (int lev(0); lev<m_lsm_model.size(); ++lev) {
            m_lsm_model[lev] = std::make_unique<NewSurfModel>();
        }
    }

Update_Micro_Vars_Lev()

void LandSurface::Update_Micro_Vars_Lev ( const int &  lev, amrex::MultiFab &  cons_in  )

inline

    {
        m_lsm_model[lev]->Update_Micro_Vars(cons_in);
    }

Update_State_Vars_Lev()

void LandSurface::Update_State_Vars_Lev ( const int &  lev, amrex::MultiFab &  cons_in  )

inline

    {
        m_lsm_model[lev]->Update_State_Vars(cons_in);
    }

Write_Lsm_Restart()

void LandSurface::Write_Lsm_Restart ( const int &  lev, const std::string &  dir  ) const

inline

{ m_lsm_model[lev]->Write_Lsm_Restart(dir); }

Member Data Documentation

m_lsm_data_lev

amrex::Vector<amrex::MultiFab> LandSurface::m_lsm_data_lev

private

Referenced by Plot_Lsm_Data().

m_lsm_geom_lev

amrex::Vector<amrex::Geometry> LandSurface::m_lsm_geom_lev

private

Referenced by Plot_Lsm_Data().

m_lsm_model

amrex::Vector<std::unique_ptr<NullSurf> > LandSurface::m_lsm_model

private

Referenced by Advance(), Define(), Get_Data_Ptr(), Get_Data_Size(), Get_DataIdx(), Get_DataName(), Get_DataNames(), Get_Flux_Ptr(), Get_Flux_Size(), Get_FluxIdx(), Get_FluxName(), Get_Lsm_Geom(), Get_LSM_Step(), Get_LSM_Update_Status(), get_model_lev(), Get_WRFInputNames(), Has_Model(), Init(), Plot(), Read_Lsm_Restart(), ReSize(), Set_Lev0_Data_Ptr(), Set_Lev0_Flux_Ptr(), Set_LSM_Step(), SetModel(), Update_Micro_Vars_Lev(), Update_State_Vars_Lev(), and Write_Lsm_Restart().

plot_file_lsm

std::string LandSurface::plot_file_lsm {"plt_lsm_"}

private

Referenced by Plot_Lsm_Data().

---

The documentation for this class was generated from the following file:

• Source/LandSurfaceModel/ERF_LandSurface.H