#include <ERF_NOAHMP.H>

Inheritance diagram for NOAHMP:

Collaboration diagram for NOAHMP:

[legend]

Public Member Functions
	NOAHMP ()

virtual	~NOAHMP ()=default

void	Define (SolverChoice &) override

void	Init (const int &lev, const amrex::MultiFab &cons_in, const amrex::Geometry &geom, const amrex::Real &dt) override

void	Advance_With_State (const int &lev, amrex::MultiFab &cons_in, amrex::MultiFab &xvel_in, amrex::MultiFab &yvel_in, amrex::MultiFab hfx3_out, amrex::MultiFab qfx3_out, const amrex::Real &elapsed_time, const amrex::Real &dt, const int &nstep) override

void	Plot_Landfile (const int &nstep) override

amrex::MultiFab *	Lsm_Data_Ptr (const int &varIdx) override

amrex::MultiFab *	Lsm_Flux_Ptr (const int &varIdx) override

amrex::Geometry	Lsm_Geom () override

int	Lsm_Data_Size () override

int	Lsm_Flux_Size () override

std::string	Lsm_DataName (const int &varIdx) override

int	Lsm_DataIndex (std::string varname) override

std::string	Lsm_FluxName (const int &varIdx) override

int	Lsm_FluxIndex (std::string varname) override

Public Member Functions inherited from NullSurf
	NullSurf ()

virtual	~NullSurf ()=default

virtual void	Advance (const amrex::Real &)

virtual void	Update_Micro_Vars (amrex::MultiFab &)

virtual void	Update_State_Vars (amrex::MultiFab &)

virtual void	Copy_State_to_Micro (const amrex::MultiFab &)

virtual void	Copy_Micro_to_State (amrex::MultiFab &)

virtual std::unordered_map< std::string, std::string > &	Lsm_WRFInputNames ()

Private Types
using	FabPtr = std::shared_ptr< amrex::MultiFab >

Private Attributes
int	m_lsm_data_size = LsmData_NOAHMP::NumVars

int	m_lsm_flux_size = LsmFlux_NOAHMP::NumVars

amrex::Vector< int >	LsmDataMap

amrex::Vector< int >	LsmFluxMap

amrex::Vector< std::string >	LsmDataName

amrex::Vector< std::string >	LsmFluxName

amrex::Geometry	m_geom

amrex::Geometry	m_lsm_geom

amrex::Real	m_dt

int	khi_lsm

int	m_nz_lsm = 1

amrex::Real	m_dz_lsm = one

amrex::Array< FabPtr, LsmData_NOAHMP::NumVars >	lsm_fab_data

amrex::Array< FabPtr, LsmFlux_NOAHMP::NumVars >	lsm_fab_flux

NoahmpIO_vector	noahmpio_vect

amrex::Vector< std::unique_ptr< amrex::FArrayBox > >	noahmp_input_tmp

amrex::Vector< std::unique_ptr< amrex::FArrayBox > >	noahmp_output_tmp

int	m_plot_int_1 = -1

Member Typedef Documentation

◆ FabPtr

using NOAHMP::FabPtr = std::shared_ptr<amrex::MultiFab>

private

Constructor & Destructor Documentation

◆ NOAHMP()

NOAHMP::NOAHMP ( )

inline

90 {}

◆ ~NOAHMP()

virtual NOAHMP::~NOAHMP ( )

virtualdefault

Member Function Documentation

◆ Advance_With_State()

void NOAHMP::Advance_With_State	(	const int &	lev,
		amrex::MultiFab &	cons_in,
		amrex::MultiFab &	xvel_in,
		amrex::MultiFab &	yvel_in,
		amrex::MultiFab *	hfx3_out,
		amrex::MultiFab *	qfx3_out,
		const amrex::Real &	elapsed_time,
		const amrex::Real &	dt,
		const int &	nstep
	)

overridevirtual

Reimplemented from NullSurf.

 {
     // Verify we need to take another LSM step
     Real NOAH_time = static_cast<Real>(noahmpio_vect[0].itimestep-1) * static_cast<Real>(noahmpio_vect[0].DTBL);
     if (elapsed_time < NOAH_time) { return; }
  
     Box domain = m_geom.Domain();
  
     Print () << "Noah-MP driver started at time step: " << nstep+1 << std::endl;
  
     bool is_moist = (cons_in.nComp() > RhoQ1_comp);
  
     int klo = domain.smallEnd(2);
  
     // Loop over blocks to copy forcing data to Noahmp, drive the land model,
     // and copy data back to ERF Multifabs.
     int idb = 0;
     for (MFIter mfi(cons_in); mfi.isValid(); ++mfi, ++idb) {
  
         Box bx  = mfi.tilebox();
         Box gbx = mfi.tilebox(IntVect(0,0,0),IntVect(1,1,0));
  
         // Check if tile is at the lower boundary in lower z direction
         if (bx.smallEnd(2) != klo) { continue; }
  
         bx.makeSlab(2,klo);
         gbx.makeSlab(2,klo);
  
         // For limiting when populating ghost cells
         int i_lo = bx.smallEnd(0); int i_hi = bx.bigEnd(0);
         int j_lo = bx.smallEnd(1); int j_hi = bx.bigEnd(1);
  
         NoahmpIO_type* noahmpio = &noahmpio_vect[idb];
  
         const Array4<const Real>& U_PHY  = xvel_in.const_array(mfi);
         const Array4<const Real>& V_PHY  = yvel_in.const_array(mfi);
         const Array4<const Real>& CONS   = cons_in.const_array(mfi);
  
         // Into NOAH-MP
         const Array4<const Real>& SWDOWN = lsm_fab_data[LsmData_NOAHMP::sw_flux_dn]->const_array(mfi);
         const Array4<const Real>& GLW    = lsm_fab_data[LsmData_NOAHMP::lw_flux_dn]->const_array(mfi);
         const Array4<const Real>& COSZEN = lsm_fab_data[LsmData_NOAHMP::cos_zenith_angle]->const_array(mfi);
  
         // Out of NOAH-MP
         Array4<Real> TSK           = lsm_fab_data[LsmData_NOAHMP::t_sfc]->array(mfi);
         Array4<Real> EMISS         = lsm_fab_data[LsmData_NOAHMP::sfc_emis]->array(mfi);
         Array4<Real> ALBSFCDIR_VIS = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dir_vis]->array(mfi);
         Array4<Real> ALBSFCDIR_NIR = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dir_nir]->array(mfi);
         Array4<Real> ALBSFCDIF_VIS = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dif_vis]->array(mfi);
         Array4<Real> ALBSFCDIF_NIR = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dif_nir]->array(mfi);
  
         // NOTE: Need to expose stresses and get stresses from NOAHMP
         Array4<Real> q_flux_arr    = lsm_fab_flux[LsmFlux_NOAHMP::q_flux]->array(mfi);
         Array4<Real> t_flux_arr    = lsm_fab_flux[LsmFlux_NOAHMP::t_flux]->array(mfi);
         Array4<Real> tau13_arr     = lsm_fab_flux[LsmFlux_NOAHMP::tau13]->array(mfi);
         Array4<Real> tau23_arr     = lsm_fab_flux[LsmFlux_NOAHMP::tau23]->array(mfi);
  
         // Use The_Pinned_Arena() for host-accessible memory that can be used with GPU
         Array4<Real> noah_input_arr  =  noahmp_input_tmp[idb]->array();
         Array4<Real> noah_output_arr =  noahmp_output_tmp[idb]->array();
  
         // Copy forcing data from ERF to Noahmp.
         ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
         {
             Real qv = (is_moist) ? CONS(i,j,k,RhoQ1_comp)/CONS(i,j,k,Rho_comp) : zero;
             noah_input_arr(i,j,0,NoahmpInputComp::u_phy)   = myhalf*(U_PHY(i,j,k)+U_PHY(i+1,j,k));
             noah_input_arr(i,j,0,NoahmpInputComp::v_phy)   = myhalf*(V_PHY(i,j,k)+V_PHY(i  ,j+1,k));
             noah_input_arr(i,j,0,NoahmpInputComp::t_phy)   = getTgivenRandRTh(CONS(i,j,k,Rho_comp),CONS(i,j,k,RhoTheta_comp),qv);
             noah_input_arr(i,j,0,NoahmpInputComp::qv_curr) = qv;
             noah_input_arr(i,j,0,NoahmpInputComp::p8w)     = getPgivenRTh(CONS(i,j,k,RhoTheta_comp),qv);
             noah_input_arr(i,j,0,NoahmpInputComp::swdown)  = SWDOWN(i,j,0);
             noah_input_arr(i,j,0,NoahmpInputComp::glw)     = GLW(i,j,0);
             noah_input_arr(i,j,0,NoahmpInputComp::coszen)  = COSZEN(i,j,0);
         });
  
         // Synchronize to ensure GPU kernel is complete before host access
         Gpu::streamSynchronize();
  
         // Now on the host, copy data to NoahmpIO arrays
         LoopOnCpu(bx, [&] (int i, int j, int ) noexcept
         {
             noahmpio->U_PHY(i,1,j)   = noah_input_arr(i,j,0,NoahmpInputComp::u_phy);
             noahmpio->V_PHY(i,1,j)   = noah_input_arr(i,j,0,NoahmpInputComp::v_phy);
             noahmpio->T_PHY(i,1,j)   = noah_input_arr(i,j,0,NoahmpInputComp::t_phy);
             noahmpio->QV_CURR(i,1,j) = noah_input_arr(i,j,0,NoahmpInputComp::qv_curr);
             noahmpio->P8W(i,1,j)     = noah_input_arr(i,j,0,NoahmpInputComp::p8w);
             noahmpio->SWDOWN(i,j)    = noah_input_arr(i,j,0,NoahmpInputComp::swdown);
             noahmpio->GLW(i,j)       = noah_input_arr(i,j,0,NoahmpInputComp::glw);
             noahmpio->COSZEN(i,j)    = noah_input_arr(i,j,0,NoahmpInputComp::coszen);
         });
  
         // Call the noahmpio driver code. This runs the land model forcing for
         // each object in noahmpio_vect that represent a block in the domain.
         noahmpio->itimestep += 1;
         noahmpio->DriverMain();
  
         // Copy results from NoahmpIO back to temporary arrays
         LoopOnCpu(bx, [&] (int i, int j, int ) noexcept
         {
             noah_output_arr(i,j,0,NoahmpOutputComp::hfx)           = noahmpio->HFX(i,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::lh)            = noahmpio->LH(i,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::tau_ew)        = noahmpio->TAU_EW(i,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::tau_ns)        = noahmpio->TAU_NS(i,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::tsk)           = noahmpio->TSK(i,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::emiss)         = noahmpio->EMISS(i,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::albsfcdir_vis) = noahmpio->ALBSFCDIRXY(i,1,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::albsfcdir_nir) = noahmpio->ALBSFCDIRXY(i,2,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::albsfcdif_vis) = noahmpio->ALBSFCDIFXY(i,1,j);
             noah_output_arr(i,j,0,NoahmpOutputComp::albsfcdif_nir) = noahmpio->ALBSFCDIFXY(i,2,j);
         });
  
         // Copy forcing data from Noahmp to ERF
         ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
         {
             // Limit indices to the valid box. FillBoundary will pick these up below.
             int ii = std::min(std::max(i,i_lo),i_hi);
             int jj = std::min(std::max(j,j_lo),j_hi);
  
             // SurfaceLayer fluxes at CC.
             // Noah-MP returns the -9999 fill value for cells it does NOT process
             // (sea-ice / open-water points, which still have LANDMASK=1). Applying
             // that as a flux gives -9999/(rho*Cp) ~ -7.6 K*m/s and crashes the
             // lowest cell to ~200 K. Detect the fill and instead write the
             // lsm_flux_undefined sentinel; the surface layer then falls back to
             // the MOST flux for those cells (see ERF_SurfaceLayer.cpp).
             // NOTE: tau13/tau23 are nodal in xz/yz; the 2D MFs have 1 ghost cell
             //       so the surface layer can average them.
             Real hfx_lsm = noah_output_arr(ii,jj,0,NoahmpOutputComp::hfx);
             if (hfx_lsm > Real(-9990.0)) {
                 t_flux_arr(i,j,k) = hfx_lsm/(CONS(ii,jj,k,Rho_comp)*Cp_d);
                 q_flux_arr(i,j,k) = noah_output_arr(ii,jj,0,NoahmpOutputComp::lh)/(CONS(ii,jj,k,Rho_comp)*L_v);
                 tau13_arr(i,j,k)  = noah_output_arr(ii,jj,0,NoahmpOutputComp::tau_ew)/CONS(ii,jj,k,Rho_comp);
                 tau23_arr(i,j,k)  = noah_output_arr(ii,jj,0,NoahmpOutputComp::tau_ns)/CONS(ii,jj,k,Rho_comp);
             } else {
                 t_flux_arr(i,j,k) = lsm_flux_undefined;
                 q_flux_arr(i,j,k) = lsm_flux_undefined;
                 tau13_arr(i,j,k)  = lsm_flux_undefined;
                 tau23_arr(i,j,k)  = lsm_flux_undefined;
             }
  
             // RRTMGP variables
             TSK(i,j,0)           = noah_output_arr(ii,jj,0,NoahmpOutputComp::tsk);
             EMISS(i,j,0)         = noah_output_arr(ii,jj,0,NoahmpOutputComp::emiss);
             ALBSFCDIR_VIS(i,j,0) = noah_output_arr(ii,jj,0,NoahmpOutputComp::albsfcdir_vis);
             ALBSFCDIR_NIR(i,j,0) = noah_output_arr(ii,jj,0,NoahmpOutputComp::albsfcdir_nir);
             ALBSFCDIF_VIS(i,j,0) = noah_output_arr(ii,jj,0,NoahmpOutputComp::albsfcdif_vis);
             ALBSFCDIF_NIR(i,j,0) = noah_output_arr(ii,jj,0,NoahmpOutputComp::albsfcdif_nir);
         });
     }
  
     // Fill the ghost cells
     for (auto ivar = 0; ivar < LsmFlux_NOAHMP::NumVars; ++ivar) {
         lsm_fab_flux[ivar]->FillBoundary(m_geom.periodicity());
     }
     Print () << "Noah-MP driver completed" << std::endl;
 };

Here is the call graph for this function:

◆ Define()

void NOAHMP::Define ( SolverChoice & )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         // NOTE: We should parse constants from sc here if needed,
     }

◆ Init()

void NOAHMP::Init	(	const int &	lev,
		const amrex::MultiFab &	cons_in,
		const amrex::Geometry &	geom,
		const amrex::Real &	dt
	)

overridevirtual

Reimplemented from NullSurf.

 {
  
     m_dt   = dt;
     m_geom = geom;
  
     Box domain = geom.Domain();
     khi_lsm    = domain.smallEnd(2) - 1;
  
     LsmDataMap.resize(m_lsm_data_size);
     LsmDataMap = {LsmData_NOAHMP::t_sfc             , LsmData_NOAHMP::sfc_emis          ,
                   LsmData_NOAHMP::sfc_alb_dir_vis   , LsmData_NOAHMP::sfc_alb_dir_nir   ,
                   LsmData_NOAHMP::sfc_alb_dif_vis   , LsmData_NOAHMP::sfc_alb_dif_nir   ,
                   LsmData_NOAHMP::cos_zenith_angle  , LsmData_NOAHMP::sw_flux_dn        ,
                   LsmData_NOAHMP::sw_flux_dn_dir_vis, LsmData_NOAHMP::sw_flux_dn_dir_nir,
                   LsmData_NOAHMP::sw_flux_dn_dif_vis, LsmData_NOAHMP::sw_flux_dn_dif_nir,
                   LsmData_NOAHMP::lw_flux_dn        };
     LsmDataName.resize(m_lsm_data_size);
     LsmDataName = {"t_sfc"             , "sfc_emis"          ,
                    "sfc_alb_dir_vis"   , "sfc_alb_dir_nir"   ,
                    "sfc_alb_dif_vis"   , "sfc_alb_dif_nir"   ,
                    "cos_zenith_angle"  , "sw_flux_dn"        ,
                    "sw_flux_dn_dir_vis", "sw_flux_dn_dir_nir",
                    "sw_flux_dn_dif_vis", "sw_flux_dn_dif_nir",
                    "lw_flux_dn"        };
  
  
     LsmFluxMap.resize(m_lsm_flux_size);
     LsmFluxMap = {LsmFlux_NOAHMP::t_flux         , LsmFlux_NOAHMP::q_flux         ,
                   LsmFlux_NOAHMP::tau13          , LsmFlux_NOAHMP::tau23          };
     LsmFluxName.resize(m_lsm_flux_size);
     LsmFluxName = {"t_flux"         , "q_flux"         ,
                    "tau13"          , "tau23"          };
  
     ParmParse pp("erf");
     pp.query("plot_int_1" , m_plot_int_1);
  
     // NOTE: All boxes in ba extend from zlo to zhi, so this transform is valid.
     //       If that were to change, the dm and new ba are no longer valid and
     //       direct copying between lsm data/flux vars cannot be done in a parfor.
  
     // Set 2D box array for lsm data
     IntVect ng(1,1,0);
     BoxArray ba = cons_in.boxArray();
     DistributionMapping dm = cons_in.DistributionMap();
     BoxList bl_lsm = ba.boxList();
     for (auto& b : bl_lsm) { b.setRange(2,0); }
     BoxArray ba_lsm(std::move(bl_lsm));
  
     // Set up lsm geometry
     const RealBox& dom_rb = m_geom.ProbDomain();
     const Real*    dom_dx = m_geom.CellSize();
     RealBox lsm_rb = dom_rb;
     Real lsm_dx[AMREX_SPACEDIM] = {AMREX_D_DECL(dom_dx[0],dom_dx[1],m_dz_lsm)};
     Real lsm_z_hi = dom_rb.lo(2);
     Real lsm_z_lo = lsm_z_hi - Real(m_nz_lsm)*lsm_dx[2];
     lsm_rb.setHi(2,lsm_z_hi); lsm_rb.setLo(2,lsm_z_lo);
     m_lsm_geom.define( ba_lsm.minimalBox(), lsm_rb, m_geom.Coord(), m_geom.isPeriodic() );
  
     // Create the data
     for (auto ivar = 0; ivar < LsmData_NOAHMP::NumVars; ++ivar) {
         // State vars are CC
         lsm_fab_data[ivar] = std::make_shared<MultiFab>(ba_lsm, dm, 1, ng);
  
         // NOTE: Radiation steps first so we set values
         //       to reasonable initialization for coupling
         Real val_to_set = zero;
         if (ivar == LsmData_NOAHMP::t_sfc) {
             val_to_set = Real(300.0);
         } else if (ivar == LsmData_NOAHMP::sfc_emis) {
             val_to_set = Real(0.9);
         } else if ( (ivar>=LsmData_NOAHMP::sfc_alb_dir_vis) &&
                     (ivar<=LsmData_NOAHMP::sfc_alb_dif_nir) ) {
             val_to_set = Real(0.06);
         } else {
             val_to_set = zero;
         }
         lsm_fab_data[ivar]->setVal(val_to_set);
     }
  
     // Create the fluxes
     for (auto ivar = 0; ivar < LsmFlux_NOAHMP::NumVars; ++ivar) {
         // NOTE: Fluxes are CC with ghost cells for averaging
         lsm_fab_flux[ivar] = std::make_shared<MultiFab>(ba_lsm, dm, 1, IntVect(1,1,0));
         lsm_fab_flux[ivar]->setVal(0.);
     }
  
     Print() << "Noah-MP initialization started" << std::endl;
  
     // Set noahmpio_vect to the size of local blocks (boxes)
     noahmpio_vect.resize(cons_in.local_size(), lev);
  
     // Allocate pinned buffer space for all the boxes
     noahmp_input_tmp.resize(cons_in.local_size());
     noahmp_output_tmp.resize(cons_in.local_size());
  
     int klo = domain.smallEnd(2);
  
     // Iterate over multifab and noahmpio object together. Multifabs is
     // used to extract size of blocks and set bounds for noahmpio objects.
     int idb = 0;
     for (MFIter mfi(cons_in); mfi.isValid(); ++mfi, ++idb) {
  
         // Get bounds for the tile
         Box bx = mfi.tilebox();
  
         // Check if tile is at the lower boundary in lower z direction
         if (bx.smallEnd(2) != klo) { continue; }
  
         // Make a slab
         bx.makeSlab(2,klo);
  
         // Allocate pinned buffers for each box
         noahmp_input_tmp[idb]  = std::make_unique<FArrayBox>(bx, NoahmpInputComp::NumComps , The_Pinned_Arena());
         noahmp_output_tmp[idb] = std::make_unique<FArrayBox>(bx, NoahmpOutputComp::NumComps, The_Pinned_Arena());
  
         // Get reference to the noahmpio object
         NoahmpIO_type* noahmpio = &noahmpio_vect[idb];
  
         // Pass idb context to noahmpio
         noahmpio->blkid = idb;
  
         // Pass level context to noahmpio
         noahmpio->level = lev;
  
         // Initialize scalar values
         noahmpio->ScalarInitDefault();
  
         // Store the rank of process for noahmp
         noahmpio->rank = ParallelDescriptor::MyProc();
  
         // Store parallel communicator for noahmp
         noahmpio->comm = MPI_Comm_c2f(ParallelDescriptor::Communicator());
  
         // Read namelist.erf file. This file contains
         // noahmpio specific parameters and is read by
         // the Fortran side of the implementation.
         noahmpio->ReadNamelist();
  
         // Read the headers from the NetCDF land file. This is also
         // implemented on the Fortran side of things currently.
         noahmpio->ReadLandHeader();
  
         // Extract tile bounds and set them to their corresponding
         // noahmpio variables. At present we will set all the variables
         // corresponding to domain, memory, and tile to the same bounds.
         // This will be changed later if we want to do special memory
         // management for expensive use cases.
         noahmpio->xstart = bx.smallEnd(0);
         noahmpio->xend   = bx.bigEnd(0);
         noahmpio->ystart = bx.smallEnd(1);
         noahmpio->yend   = bx.bigEnd(1);
  
         // Domain bounds
         noahmpio->ids = noahmpio->xstart;
         noahmpio->ide = noahmpio->xend;
         noahmpio->jds = noahmpio->ystart;
         noahmpio->jde = noahmpio->yend;
         noahmpio->kds = 1;
         noahmpio->kde = 2;
  
         // Tile bounds
         noahmpio->its = noahmpio->xstart;
         noahmpio->ite = noahmpio->xend;
         noahmpio->jts = noahmpio->ystart;
         noahmpio->jte = noahmpio->yend;
         noahmpio->kts = 1;
         noahmpio->kte = 2;
  
         // Memory bounds
         noahmpio->ims = noahmpio->xstart;
         noahmpio->ime = noahmpio->xend;
         noahmpio->jms = noahmpio->ystart;
         noahmpio->jme = noahmpio->yend;
         noahmpio->kms = 1;
         noahmpio->kme = 2;
  
         // This procedure allocates memory in Fortran for IO variables
         // using bounds that are set above and read from namelist.erf
         // and headers from the NetCDF land file
         noahmpio->VarInitDefault();
  
         // This reads NoahmpTable.TBL file which is another input file
         // we need to set some IO variables.
         noahmpio->ReadTable();
  
         // Read and initialize data from the NetCDF land file.
         noahmpio->ReadLandMain();
  
         // Compute additional initial values that were not supplied
         // by the NetCDF land file.
         noahmpio->InitMain();
  
         // Write initial plotfile for land with the tag 0
         Print() << "Noah-MP writing lnd.nc file at lev: " << lev << std::endl;
         noahmpio->WriteLand(0);
     }
     AMREX_ALWAYS_ASSERT(m_dt <= noahmpio_vect[0].DTBL);
  
     Print() << "Noah-MP initialization completed" << std::endl;
  
 };

Here is the call graph for this function:

◆ Lsm_Data_Ptr()

amrex::MultiFab* NOAHMP::Lsm_Data_Ptr ( const int & varIdx )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int lsmIdx = LsmDataMap[varIdx];
         AMREX_ALWAYS_ASSERT(lsmIdx < NOAHMP::m_lsm_data_size && lsmIdx>=0);
         return lsm_fab_data[lsmIdx].get();
     }

Here is the call graph for this function:

◆ Lsm_Data_Size()

int NOAHMP::Lsm_Data_Size ( )

inlineoverridevirtual

Reimplemented from NullSurf.

148 { return NOAHMP::m_lsm_data_size; }

◆ Lsm_DataIndex()

int NOAHMP::Lsm_DataIndex ( std::string varname )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int varIdx = -1;
         std::string lc_varname = amrex::toLower(varname);
         for (int idx(0); idx<LsmData_NOAHMP::NumVars; ++idx) {
             if (lc_varname == amrex::toLower(LsmDataName[idx])) {
                 varIdx = idx;
             }
         }
         return varIdx;
     }

Here is the call graph for this function:

◆ Lsm_DataName()

std::string NOAHMP::Lsm_DataName ( const int & varIdx )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int lsmIdx = LsmDataMap[varIdx];
         AMREX_ALWAYS_ASSERT(lsmIdx < NOAHMP::m_lsm_data_size && lsmIdx>=0);
         return LsmDataName[lsmIdx];
     }

Here is the call graph for this function:

◆ Lsm_Flux_Ptr()

amrex::MultiFab* NOAHMP::Lsm_Flux_Ptr ( const int & varIdx )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int lsmIdx = LsmFluxMap[varIdx];
         AMREX_ALWAYS_ASSERT(lsmIdx < NOAHMP::m_lsm_flux_size && lsmIdx>=0);
         return lsm_fab_flux[lsmIdx].get();
     }

Here is the call graph for this function:

◆ Lsm_Flux_Size()

int NOAHMP::Lsm_Flux_Size ( )

inlineoverridevirtual

Reimplemented from NullSurf.

152 { return NOAHMP::m_lsm_flux_size; }

◆ Lsm_FluxIndex()

int NOAHMP::Lsm_FluxIndex ( std::string varname )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int varIdx = -1;
         std::string lc_varname = amrex::toLower(varname);
         for (int idx(0); idx<LsmFlux_NOAHMP::NumVars; ++idx) {
             if (lc_varname == amrex::toLower(LsmFluxName[idx])) {
                 varIdx = idx;
             }
         }
         return varIdx;
     }

Here is the call graph for this function:

◆ Lsm_FluxName()

std::string NOAHMP::Lsm_FluxName ( const int & varIdx )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int lsmIdx = LsmFluxMap[varIdx];
         AMREX_ALWAYS_ASSERT(lsmIdx < NOAHMP::m_lsm_flux_size && lsmIdx>=0);
         return LsmFluxName[lsmIdx];
     }

Here is the call graph for this function:

◆ Lsm_Geom()

amrex::Geometry NOAHMP::Lsm_Geom ( )

inlineoverridevirtual

Reimplemented from NullSurf.

144 { return m_lsm_geom; }

◆ Plot_Landfile()

void NOAHMP::Plot_Landfile ( const int & nstep )

overridevirtual

Reimplemented from NullSurf.

 {
     for (NoahmpIO_type &noahmpio : noahmpio_vect) {
         noahmpio.WriteLand(nstep);
     }
 }

Member Data Documentation

◆ khi_lsm

int NOAHMP::khi_lsm

private

◆ lsm_fab_data

amrex::Array<FabPtr, LsmData_NOAHMP::NumVars> NOAHMP::lsm_fab_data

private

Referenced by Lsm_Data_Ptr().

◆ lsm_fab_flux

amrex::Array<FabPtr, LsmFlux_NOAHMP::NumVars> NOAHMP::lsm_fab_flux

private

Referenced by Lsm_Flux_Ptr().

◆ LsmDataMap

amrex::Vector<int> NOAHMP::LsmDataMap

private

Referenced by Lsm_Data_Ptr(), and Lsm_DataName().

◆ LsmDataName

amrex::Vector<std::string> NOAHMP::LsmDataName

private

Referenced by Lsm_DataIndex(), and Lsm_DataName().

◆ LsmFluxMap

amrex::Vector<int> NOAHMP::LsmFluxMap

private

Referenced by Lsm_Flux_Ptr(), and Lsm_FluxName().

◆ LsmFluxName

amrex::Vector<std::string> NOAHMP::LsmFluxName

private

Referenced by Lsm_FluxIndex(), and Lsm_FluxName().

◆ m_dt

amrex::Real NOAHMP::m_dt

private

◆ m_dz_lsm

amrex::Real NOAHMP::m_dz_lsm = one

private

◆ m_geom

amrex::Geometry NOAHMP::m_geom

private

◆ m_lsm_data_size

int NOAHMP::m_lsm_data_size = LsmData_NOAHMP::NumVars

private

Referenced by Lsm_Data_Size().

◆ m_lsm_flux_size

int NOAHMP::m_lsm_flux_size = LsmFlux_NOAHMP::NumVars

private

Referenced by Lsm_Flux_Size().

◆ m_lsm_geom

amrex::Geometry NOAHMP::m_lsm_geom

private

Referenced by Lsm_Geom().

◆ m_nz_lsm

int NOAHMP::m_nz_lsm = 1

private

◆ m_plot_int_1

int NOAHMP::m_plot_int_1 = -1

private

◆ noahmp_input_tmp

amrex::Vector<std::unique_ptr<amrex::FArrayBox> > NOAHMP::noahmp_input_tmp

private

◆ noahmp_output_tmp

amrex::Vector<std::unique_ptr<amrex::FArrayBox> > NOAHMP::noahmp_output_tmp

private

◆ noahmpio_vect

NoahmpIO_vector NOAHMP::noahmpio_vect

private

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

Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP.H
Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP.cpp

Public Member Functions

Private Types

Private Attributes

Member Typedef Documentation

◆ FabPtr

Constructor & Destructor Documentation

◆ NOAHMP()

◆ ~NOAHMP()

Member Function Documentation

◆ Advance_With_State()

◆ Define()

◆ Init()

◆ Lsm_Data_Ptr()

◆ Lsm_Data_Size()

◆ Lsm_DataIndex()

◆ Lsm_DataName()

◆ Lsm_Flux_Ptr()

◆ Lsm_Flux_Size()

◆ Lsm_FluxIndex()

◆ Lsm_FluxName()

◆ Lsm_Geom()

◆ Plot_Landfile()

Member Data Documentation

◆ khi_lsm

◆ lsm_fab_data

◆ lsm_fab_flux

◆ LsmDataMap

◆ LsmDataName

◆ LsmFluxMap

◆ LsmFluxName

◆ m_dt

◆ m_dz_lsm

◆ m_geom

◆ m_lsm_data_size

◆ m_lsm_flux_size

◆ m_lsm_geom

◆ m_nz_lsm

◆ m_plot_int_1

◆ noahmp_input_tmp

◆ noahmp_output_tmp

◆ noahmpio_vect