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

#include <ERF_LandSurface.H>

Collaboration diagram for LandSurface:

[legend]

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::MultiFab &u_in, const amrex::MultiFab &v_in, const amrex::Geometry &geom, const amrex::Geometry &geom0, amrex::Vector< amrex::BCRec > &domain_bcs_type, amrex::IntVect &refRatio, const amrex::Real &dt_advance, std::unique_ptr< amrex::MultiFab > &z_phys_nd, amrex::Vector< amrex::Vector< std::string >> &nc_init_file)

void	Init (const int &lev, const amrex::MultiFab &cons_in, const amrex::MultiFab &u_in, const amrex::MultiFab &v_in, const amrex::Geometry &geom, const amrex::Real &dt_advance, std::unique_ptr< amrex::MultiFab > &z_phys_nd)

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, amrex::MultiFab *z_nd)

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

void	Advance (const int &lev, const amrex::Real &dt, const amrex::Real &time, const amrex::Real &start_time)

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

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

void	Update_Lsm_Vars_Lev (const int &lev, amrex::MultiFab &cons_in, amrex::MultiFab &u_in, amrex::MultiFab &v_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, const std::string &varname)

void	Set_Source_Ptrs (const int &lev, const int &source_lev)

void	Initialize_From_Source (const int &lev, const int &source_lev, const amrex::IntVect &ref_ratio, const LSMTransferMode mode)

void	Remake_Level (const int &lev, const amrex::MultiFab &cons_in, const amrex::MultiFab &u_in, const amrex::MultiFab &v_in, const amrex::Geometry &geom, const amrex::Geometry &geom0, amrex::Vector< amrex::BCRec > &domain_bcs_type, amrex::IntVect &ref_ratio, const amrex::Real &dt_advance, std::unique_ptr< amrex::MultiFab > &z_phys_nd, amrex::Vector< amrex::Vector< std::string >> &nc_init_file, const int source_lev=-1, const amrex::IntVect &source_ref_ratio=amrex::IntVect(1))

void	Set_Lev0_Data_Ptr (const int &lev)

std::string	Get_FluxName (const int &varIdx)

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

void	Set_Lev0_Flux_Ptr (const int &lev)

bool	Get_LSM_Update_Status (const int &lev)

bool	Runs_Own_Land_Driver (const int &lev) const

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 (const PlotFileType plotfile_type, double time, const amrex::Vector< int > &level_steps, const amrex::Vector< amrex::IntVect > &ref_ratio, const int finest_level)

void	set_LSM_precip_input (const int &lev, const amrex::MultiFab *precip_in)

void	set_LSM_terrain_inputs (const int &lev, const amrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab >>> &sst_in, const amrex::Vector< amrex::Vector< std::unique_ptr< amrex::iMultiFab >>> &lmask_in)

template<class SurfModelType >
SurfModelType *	get_model_lev (const int &lev)

void	WriteCheckpoint (const int &lev, const std::string &checkpointname) const

void	ReadCheckpoint (const int &lev, const std::string &checkpointname)

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

23 { }

◆ ~LandSurface()

LandSurface::~LandSurface ( )

default

Member Function Documentation

◆ Advance() [1/3]

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,
		amrex::MultiFab *	z_nd
	)

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, z_nd);
     }

◆ Advance() [2/3]

void LandSurface::Advance	(	const int &	lev,
		const amrex::Real &	dt,
		const amrex::Real &	time,
		const amrex::Real &	start_time
	)

inline

     {
         m_lsm_model[lev]->Advance(dt, time, start_time);
     }

◆ Advance() [3/3]

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

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

Referenced by TwoStreamRadiation::advance(), 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

162 { 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,
		const std::string &	varname
	)

inline

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

Referenced by TwoStreamRadiation::advance().

Here is the caller graph for this function:

◆ Get_DataName()

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

inline

168 { 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

156 { 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

165 { 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,
		const std::string &	varname
	)

inline

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

◆ Get_FluxName()

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

inline

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

◆ Get_Lsm_Geom()

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

inline

159 { 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

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

◆ Get_LSM_Update_Status()

bool LandSurface::Get_LSM_Update_Status ( const int & lev )

inline

302 { 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

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

◆ Has_Model()

bool LandSurface::Has_Model ( ) const

inline

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

◆ Init() [1/2]

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

inline

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

Referenced by Init().

Here is the caller graph for this function:

◆ Init() [2/2]

void LandSurface::Init	(	const int &	lev,
		const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	u_in,
		const amrex::MultiFab &	v_in,
		const amrex::Geometry &	geom,
		const amrex::Real &	dt_advance,
		std::unique_ptr< amrex::MultiFab > &	z_phys_nd
	)

inline

     {
         amrex::Vector<amrex::BCRec> domain_bcs_type;
         amrex::IntVect refRatio(1);
         amrex::Vector<amrex::Vector<std::string>> nc_init_file;
         Init(lev, cons_in, u_in, v_in, geom, geom,
              domain_bcs_type, refRatio, dt_advance,
              z_phys_nd, nc_init_file);
     }

Here is the call graph for this function:

◆ Initialize_From_Source()

void LandSurface::Initialize_From_Source	(	const int &	lev,
		const int &	source_lev,
		const amrex::IntVect &	ref_ratio,
		const LSMTransferMode	mode
	)

inline

Initializes a level from a source level using the requested state mode.

     {
         Set_Source_Ptrs(lev, source_lev);
         m_lsm_model[lev]->Lsm_Interpolate_From_Source(
             m_lsm_model[source_lev]->Lsm_Atmos_Geom(),
             m_lsm_model[source_lev]->Lsm_Geom(), ref_ratio, mode);
     }

Here is the call graph for this function:

◆ 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	(	const PlotFileType	plotfile_type,
		double	time,
		const amrex::Vector< int > &	level_steps,
		const amrex::Vector< amrex::IntVect > &	ref_ratio,
		const int	finest_level
	)

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 nlev_valid = 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 <= finest_level; ++lev) {
                 m_lsm_geom_lev[lev] = this->Get_Lsm_Geom(lev);
  
                 if (m_lsm_geom_lev[lev].Domain().isEmpty()) {
                     nlev_valid--;
                     continue;
                 }
  
                 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);
                 }
             }
             if (plotfile_type == PlotFileType::Amrex
 #ifdef ERF_USE_NETCDF
                 || plotfile_type == PlotFileType::Netcdf
 #endif
                 ) {
 #ifdef ERF_USE_NETCDF
                 // NetCDF output of the land-surface fields is not implemented yet, so fall back
                 // to the AMReX format -- which is what these plotfiles were before the plotfile
                 // type was consulted here -- rather than silently writing nothing at all.
                 warn_nc_lsm_plot_fallback(plotfile_type);
 #endif
                 WriteMultiLevelPlotfile (plotfilename, nlev_valid, GetVecOfConstPtrs(m_lsm_data_lev),
                                             varnames, m_lsm_geom_lev, static_cast<amrex::Real>(time),
                                             level_steps, ref_ratio);
             } else {
                 amrex::Abort("Dont know this plotfile_type");
             }
  
             m_lsm_geom_lev.clear();
             m_lsm_data_lev.clear();
         }
  
         if (nlev_valid > 0 && m_lsm_model[0]->Lsm_Type() == LSM_Type::SLM)
         {
             amrex::Vector<amrex::MultiFab> fab_2d(finest_level+1);
             amrex::Vector<amrex::Geometry> geom_2d(finest_level+1);
             amrex::Vector<std::string> varnames_2d;
             std::string plotfilename_2d = amrex::Concatenate(plot_file_lsm + "2D_", level_steps[0], 5);
             for (int lev = 0; lev <= finest_level; ++lev) {
                 static_cast<SLM*>(m_lsm_model[lev].get())->writeSLM_Data(plotfile_type, static_cast<amrex::Real>(time), plot_file_lsm, level_steps[0], lev, finest_level, fab_2d[lev], geom_2d[lev], varnames_2d);
             }
             // For a NetCDF run writeSLM_Data has already written these fields itself, one file
             // per level, so only the AMReX format is assembled here.
             if (plotfile_type == PlotFileType::Amrex) {
                 amrex::WriteMultiLevelPlotfile(plotfilename_2d, finest_level+1, GetVecOfConstPtrs(fab_2d), varnames_2d, geom_2d, static_cast<amrex::Real>(time), level_steps, ref_ratio);
             }
         }
     }

Here is the call graph for this function:

◆ Read_Lsm_Restart()

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

inline

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

◆ ReadCheckpoint()

void LandSurface::ReadCheckpoint	(	const int &	lev,
		const std::string &	checkpointname
	)

inline

     {
         m_lsm_model[lev]->ReadCheckpoint(lev, checkpointname);
     }

◆ Remake_Level()

void LandSurface::Remake_Level	(	const int &	lev,
		const amrex::MultiFab &	cons_in,
		const amrex::MultiFab &	u_in,
		const amrex::MultiFab &	v_in,
		const amrex::Geometry &	geom,
		const amrex::Geometry &	geom0,
		amrex::Vector< amrex::BCRec > &	domain_bcs_type,
		amrex::IntVect &	ref_ratio,
		const amrex::Real &	dt_advance,
		std::unique_ptr< amrex::MultiFab > &	z_phys_nd,
		amrex::Vector< amrex::Vector< std::string >> &	nc_init_file,
		const int	source_lev = `-1`,
		const amrex::IntVect &	source_ref_ratio = `amrex::IntVect(1)`
	)

inline

Rebuilds a land-surface level after ERF remakes its atmospheric grid.

     {
         const bool has_source = source_lev >= 0;
         if (has_source) {
             Set_Source_Ptrs(lev, source_lev);
         }
  
         const amrex::Geometry& source_geom = has_source
             ? m_lsm_model[source_lev]->Lsm_Atmos_Geom() : geom;
         const amrex::Geometry& source_lsm_geom = has_source
             ? m_lsm_model[source_lev]->Lsm_Geom() : geom;
         m_lsm_model[lev]->Lsm_Regrid_Level(
             lev, cons_in, u_in, v_in, geom, geom0, domain_bcs_type,
             ref_ratio, dt_advance, z_phys_nd, nc_init_file,
             source_geom, source_lsm_geom, source_ref_ratio, has_source);
     }

Here is the call graph for this function:

◆ ReSize()

void LandSurface::ReSize ( const int & nlev )

inline

28 { m_lsm_model.resize(nlev); }

Referenced by ERF::ERF_shared().

Here is the caller graph for this function:

◆ Runs_Own_Land_Driver()

bool LandSurface::Runs_Own_Land_Driver ( const int & lev ) const

inline

     {
         return lev >= 0 && lev < static_cast<int>(m_lsm_model.size()) && m_lsm_model[lev] &&
                m_lsm_model[lev]->Runs_Own_Land_Driver();
     }

◆ 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_precip_input()

void LandSurface::set_LSM_precip_input	(	const int &	lev,
		const amrex::MultiFab *	precip_in
	)

inline

     {
         m_lsm_model[lev]->set_precip_input(precip_in);
     }

◆ Set_LSM_Step()

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

inline

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

◆ set_LSM_terrain_inputs()

void LandSurface::set_LSM_terrain_inputs	(	const int &	lev,
		const amrex::Vector< amrex::Vector< std::unique_ptr< amrex::MultiFab >>> &	sst_in,
		const amrex::Vector< amrex::Vector< std::unique_ptr< amrex::iMultiFab >>> &	lmask_in
	)

inline

     {
         m_lsm_model[lev]->set_terrain_inputs(sst_in[lev], lmask_in[lev]);
     }

◆ Set_Source_Ptrs()

void LandSurface::Set_Source_Ptrs	(	const int &	lev,
		const int &	source_lev
	)

inline

Registers a source level's exposed state with a destination level.

     {
         AMREX_ALWAYS_ASSERT(lev > 0);
         AMREX_ALWAYS_ASSERT(source_lev >= 0);
         AMREX_ALWAYS_ASSERT(m_lsm_model[lev]->Lsm_Type() == m_lsm_model[source_lev]->Lsm_Type());
  
         const int ndata = m_lsm_model[lev]->Lsm_Data_Size();
         AMREX_ALWAYS_ASSERT(ndata == m_lsm_model[source_lev]->Lsm_Data_Size());
         for (int varIdx(0); varIdx<ndata; ++varIdx) {
             m_lsm_model[lev]->Lsm_Set_Source_Data_Ptr(
                 varIdx, m_lsm_model[source_lev]->Lsm_Data_Ptr(varIdx));
         }
  
         const int nflux = m_lsm_model[lev]->Lsm_Flux_Size();
         AMREX_ALWAYS_ASSERT(nflux == m_lsm_model[source_lev]->Lsm_Flux_Size());
         for (int varIdx(0); varIdx<nflux; ++varIdx) {
             m_lsm_model[lev]->Lsm_Set_Source_Flux_Ptr(
                 varIdx, m_lsm_model[source_lev]->Lsm_Flux_Ptr(varIdx));
         }
  
         const int nunmapped = m_lsm_model[lev]->Lsm_Unmapped_Size();
         AMREX_ALWAYS_ASSERT(nunmapped == m_lsm_model[source_lev]->Lsm_Unmapped_Size());
         for (int varIdx(0); varIdx<nunmapped; ++varIdx) {
             m_lsm_model[lev]->Lsm_Set_Source_Unmapped_Ptr(
                 varIdx, m_lsm_model[source_lev]->Lsm_Unmapped_Ptr(varIdx));
         }
     }

Referenced by Initialize_From_Source(), and Remake_Level().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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_Lsm_Vars_Lev()

void LandSurface::Update_Lsm_Vars_Lev	(	const int &	lev,
		amrex::MultiFab &	cons_in,
		amrex::MultiFab &	u_in,
		amrex::MultiFab &	v_in
	)

inline

     {
         m_lsm_model[lev]->Update_Lsm_Vars(cons_in, u_in, v_in);
     }

◆ 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

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

◆ WriteCheckpoint()

void LandSurface::WriteCheckpoint	(	const int &	lev,
		const std::string &	checkpointname
	)		const

inline

     {
         m_lsm_model[lev]->WriteCheckpoint(lev, checkpointname);
     }

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

◆ 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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LandSurface()

◆ ~LandSurface()

Member Function Documentation

◆ Advance() [1/3]

◆ Advance() [2/3]

◆ Advance() [3/3]

◆ Define()

◆ Get_Data_Ptr() [1/2]

◆ Get_Data_Ptr() [2/2]

◆ 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() [1/2]

◆ Init() [2/2]

◆ Initialize_From_Source()

◆ Plot()

◆ Plot_Lsm_Data()

◆ Read_Lsm_Restart()

◆ ReadCheckpoint()

◆ Remake_Level()

◆ ReSize()

◆ Runs_Own_Land_Driver()

◆ Set_Lev0_Data_Ptr()

◆ Set_Lev0_Flux_Ptr()

◆ set_LSM_precip_input()

◆ Set_LSM_Step()

◆ set_LSM_terrain_inputs()

◆ Set_Source_Ptrs()

◆ SetModel()

◆ Update_Lsm_Vars_Lev()

◆ Update_Micro_Vars_Lev()

◆ Update_State_Vars_Lev()

◆ Write_Lsm_Restart()

◆ WriteCheckpoint()

Member Data Documentation

◆ m_lsm_data_lev

◆ m_lsm_geom_lev

◆ m_lsm_model

◆ plot_file_lsm