#include <ERF_NOAHMP.H>

Inheritance diagram for NOAHMP:

Collaboration diagram for NOAHMP:

[legend]

Public Member Functions
	NOAHMP ()

virtual	~NOAHMP ()=default

void	Define (SolverChoice &sc) override

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, amrex::Vector< amrex::Vector< std::string >> &nc_init_file) 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 SurfacePrecipAccumulationSources &precip_sources, const amrex::Real &elapsed_time, const amrex::Real &dt, const int &nstep, const bool updated_lev0, amrex::MultiFab *z_nd) 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 (const std::string &varname) override

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

int	Lsm_FluxIndex (const std::string &varname) override

void	Lsm_Set_Lev0_Data_Ptr (const int &varIdx, amrex::MultiFab *lev0_data_ptr) override

void	Lsm_Set_Lev0_Flux_Ptr (const int &varIdx, amrex::MultiFab *lev0_flux_ptr) override

bool	Get_Update_Status () override

int	Get_LSM_Step () const override

void	Set_LSM_Step (int step) override

void	Write_Lsm_Restart (const std::string &dir) const override

void	Read_Lsm_Restart (const std::string &dir) override

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

bool	time_to_fire (const amrex::Real &elapsed_time)

void	stage_forcing (const amrex::MFIter &mfi, const erf_noahmp::NoahmpBlockViews &blk, const amrex::Box &bx, const int &klo, const int &lev, const bool is_moist, amrex::MultiFab &cons_in, amrex::MultiFab &xvel_in, amrex::MultiFab &yvel_in, amrex::MultiFab *z_nd, const erf_noahmp::PrecipSlots &precip, amrex::Vector< erf_noahmp::ClampedPrecipCell > &clamped_cells, amrex::Vector< erf_noahmp::InvariantPrecipCell > &invariant_cells)

void	read_results (const amrex::MFIter &mfi, const erf_noahmp::NoahmpBlockViews &blk, const amrex::Box &bx, const amrex::Box &gbx, amrex::MultiFab &cons_in)

erf_noahmp::PrecipSlots	collect_precip_sources (const SurfacePrecipAccumulationSources &precip_sources)

void	prepare_precip_snapshots (const int &lev, const erf_noahmp::PrecipSlots &precip)

void	advance_precip_snapshots (const int &lev, const erf_noahmp::PrecipSlots &precip)

void	report_precip_diagnostics (const int &lev, const amrex::Vector< erf_noahmp::ClampedPrecipCell > &clamped_cells, const amrex::Vector< erf_noahmp::InvariantPrecipCell > &invariant_cells)

int	soil_data_idx (int g, int k) const

void	m_ensure_nsoil_resolved ()

virtual void	Init (const int &, const amrex::MultiFab &, const amrex::Geometry &, const amrex::Geometry &, amrex::Vector< amrex::BCRec > &, amrex::IntVect &, const amrex::Real &, amrex::Vector< amrex::Vector< std::string >> &)

virtual void	Init (const int &lev, const amrex::MultiFab &cons_in, const amrex::MultiFab &, const amrex::MultiFab &, 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 > &, amrex::Vector< amrex::Vector< std::string >> &nc_init_file)

Public Member Functions inherited from NullSurf
	NullSurf ()

virtual	~NullSurf ()=default

virtual void	Init (const int &lev, const amrex::MultiFab &cons_in, const amrex::MultiFab &, const amrex::MultiFab &, 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 > &, amrex::Vector< amrex::Vector< std::string >> &nc_init_file)

virtual void	Advance (const double &)

virtual void	Advance (const amrex::Real &, const amrex::Real &, const amrex::Real &)

virtual void	Update_Micro_Vars (amrex::MultiFab &)

virtual void	Update_Lsm_Vars (amrex::MultiFab &, amrex::MultiFab &, amrex::MultiFab &)

virtual void	Copy_State_to_Lsm (const amrex::MultiFab &, const amrex::MultiFab &, const amrex::MultiFab &)

virtual void	Copy_Lsm_to_State (amrex::MultiFab &)

virtual void	Update_State_Vars (amrex::MultiFab &)

virtual void	set_precip_input (const amrex::MultiFab *)

virtual void	set_terrain_inputs (const amrex::Vector< std::unique_ptr< amrex::MultiFab >> &, const amrex::Vector< std::unique_ptr< amrex::iMultiFab >> &)

virtual int	Lsm_Type ()

virtual void	WriteCheckpoint (const int &, const std::string &) const

virtual void	ReadCheckpoint (const int &, const std::string &)

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

virtual void	Lsm_Set_Source_Data_Ptr (const int &, amrex::MultiFab *)

virtual void	Lsm_Set_Source_Flux_Ptr (const int &, amrex::MultiFab *)

virtual int	Lsm_Unmapped_Size ()

virtual amrex::MultiFab *	Lsm_Unmapped_Ptr (const int &)

virtual void	Lsm_Set_Source_Unmapped_Ptr (const int &, amrex::MultiFab *)

virtual amrex::Geometry	Lsm_Atmos_Geom ()

virtual void	Lsm_Interpolate_From_Source (const amrex::Geometry &, const amrex::Geometry &, const amrex::IntVect &, LSMTransferMode)

virtual void	Lsm_Regrid_Level (const int &, const amrex::MultiFab &, const amrex::MultiFab &, const amrex::MultiFab &, const amrex::Geometry &, const amrex::Geometry &, amrex::Vector< amrex::BCRec > &, amrex::IntVect &, const amrex::Real &, std::unique_ptr< amrex::MultiFab > &, amrex::Vector< amrex::Vector< std::string >> &, const amrex::Geometry &, const amrex::Geometry &, const amrex::IntVect &, const bool)

Static Public Member Functions
static std::string	m_precip_snapshot_name (const std::string &dir, int l, int s)

Public Attributes
bool	m_nsoil_resolved = false

Static Public Attributes
static constexpr int	m_num_soil_groups = 3

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

Private Member Functions
void	with_land_comm (const std::function< void(NoahmpIO_type &)> &fn) const

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_geom0

amrex::Geometry	m_lsm_geom

amrex::IntVect	m_refRatio

amrex::Vector< amrex::BCRec >	m_domain_bcs_type

int	m_itimestep = 0

amrex::Real	m_dtbl = std::numeric_limits<amrex::Real>::max()

int	khi_lsm = -1

int	m_nz_lsm = 1

amrex::Real	m_dz_lsm = one

amrex::Vector< FabPtr >	lsm_fab_data

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

amrex::Vector< amrex::MultiFab * >	lsm_lev0_data

amrex::Array< amrex::MultiFab *, LsmFlux_NOAHMP::NumVars >	lsm_lev0_flux {}

int	m_nsoil = 4

NoahmpIO_vector	noahmpio_vect

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

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

amrex::Vector< amrex::Array< std::unique_ptr< amrex::MultiFab >, NoahmpPrecipSlot::NumSlots > >	m_precip_accum_prev

amrex::Array< std::unique_ptr< amrex::MultiFab >, NoahmpPrecipSlot::NumSlots >	m_precip_accum_restored

int	m_lev = 0

bool	m_updated = false

bool	m_has_nc_file = false

bool	m_checked_radiation_inputs = false

bool	m_warned_radiation_inputs = false

int	m_first_advance_nstep = -1

bool	m_radiation_feeds_lsm = false

std::string	m_radiation_model_name

Member Typedef Documentation

◆ FabPtr

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

private

Constructor & Destructor Documentation

◆ NOAHMP()

NOAHMP::NOAHMP ( )

inline

67 {}

◆ ~NOAHMP()

virtual NOAHMP::~NOAHMP ( )

virtualdefault

Member Function Documentation

◆ advance_precip_snapshots()

void NOAHMP::advance_precip_snapshots	(	const int &	lev,
		const erf_noahmp::PrecipSlots &	precip
	)

 {
     if (!precip.have_any) { return; }
     for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
         if (precip.has[s]) {
             MultiFab::Copy(*m_precip_accum_prev[lev][s], *precip.accum[s], 0, 0, 1, 0);
         }
     }
 }

◆ 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 SurfacePrecipAccumulationSources &	precip_sources,
		const amrex::Real &	elapsed_time,
		const amrex::Real &	dt,
		const int &	nstep,
		const bool	updated_lev0,
		amrex::MultiFab *	z_nd
	)

overridevirtual

Reimplemented from NullSurf.

 {
     // The ERF step this level's first Advance call saw: 0 on a run started from
     // scratch, the restart step on a restarted run. The radiation-input check below
     // uses it to tell a coupling that never fires from one that has not fired yet.
     if (m_first_advance_nstep < 0) { m_first_advance_nstep = nstep; }
  
     if (!m_has_nc_file) {
         // Skip interpolation if lev 0 was just updated: Noah runs post-step, so
         // the fluxes & data still hold lsm_undefined values.
         if (!updated_lev0) {
             interp_from_lev0(lev, cons_in, nstep);
         } else {
             m_updated = false;
         }
     } else {
         // time_to_fire lets Noah-MP advance one NOAH_TIMESTEP per call and fires at most
         // once per ERF step, so an ERF step longer than NOAH_TIMESTEP leaves the land clock
         // further behind the atmosphere's every step: with dt = 7200 s against a 3600 s
         // land step the run completes normally while the land surface advances half as
         // fast. Checked here because this is the first place the real step is known --
         // Init receives a dummy dt of zero.
         AMREX_ALWAYS_ASSERT_WITH_MESSAGE(dt <= m_dtbl,
             "Noah-MP: the ERF timestep exceeds the Noah-MP timestep (NOAH_TIMESTEP in "
             "namelist.erf). Noah-MP advances at most one NOAH_TIMESTEP per ERF step, so the "
             "land surface would fall behind the atmosphere; raise NOAH_TIMESTEP or reduce the "
             "ERF timestep.");
  
         // Gate on the subcycling schedule (identical on every rank).
         if (!time_to_fire(elapsed_time)) { return; }
  
         Box domain = m_geom.Domain();
  
         Print () << "Noah-MP driver at level " << lev << " started at time step: " << nstep+1 << std::endl;
  
         // stage_forcing replaces a radiation input that is not is_valid_lsm_value (still
         // the lsm_undefined sentinel, or non-finite) with zero. Look at what is actually
         // there before the land model integrates on it. On a run started from scratch the
         // radiation model runs before the land model within a step (pre-dycore vs
         // post-step) and RRTMGP always computes on step 0, so the first land step already
         // sees whatever the radiation model is going to supply. On a restarted run that is
         // not so: the fields are part of the LSM checkpoint data, but a regrid at restart
         // rebuilds the level and NOAHMP::Init re-installs the sentinel, and RRTMGP
         // recomputes only on its erf.rad_freq_in_steps schedule -- the sentinel can be
         // legitimate and transient. So keep checking each land step until valid values
         // arrive, and reserve the abort for the case that is certainly broken.
         //
         // What a missing input means depends on the radiation model. RRTMGP writes these
         // fields, and so does TwoStream (every step, for Noah-MP), so with either an input
         // still missing on a run started from scratch is a coupling that never reaches this
         // level, and running on zero would be a 0 K sky (on an idealized grassland patch
         // t_sfc falls about 48 K in one land hour): abort. On a restarted run, warn and
         // integrate on zero until the next radiation update fills the fields. Any other
         // radiation model does not write them, the start-up warning in
         // SolverChoice::init_params has already said so, and zero is the intended
         // fallback: say it once more here, at the level concerned.
         if (!m_checked_radiation_inputs) {
             const std::pair<int, const char*> rad_inputs[] = {
                 {LsmData_NOAHMP::sw_flux_dn,       "downwelling shortwave (SWDOWN)"},
                 {LsmData_NOAHMP::lw_flux_dn,       "downwelling longwave (GLW)"},
                 {LsmData_NOAHMP::cos_zenith_angle, "solar zenith angle (COSZEN)"}};
             std::string invalid;
             for (const auto& [idx, what] : rad_inputs) {
                 const MultiFab& mf = *lsm_fab_data[idx];
                 // The complement of is_valid_lsm_value over the whole field: max catches
                 // the sentinel and +inf, contains_inf catches -inf (which a max test alone
                 // passes while stage_forcing zeroes every cell), contains_nan the rest.
                 // All three reduce over ranks, so the verdict below is identical on every
                 // rank.
                 if (mf.max(0) >= lsm_undefined || mf.contains_nan(0, 1) || mf.contains_inf(0, 1)) {
                     invalid += std::string(invalid.empty() ? "" : ", ") + what;
                 }
             }
             if (invalid.empty()) {
                 m_checked_radiation_inputs = true;
             } else if (m_radiation_feeds_lsm) {
                 if (m_first_advance_nstep == 0) {
                     amrex::Abort("Noah-MP at level " + std::to_string(lev) + " found no valid "
                                  + invalid + " although erf.radiation_model = "
                                  + m_radiation_model_name + ", which should supply them before "
                                  "the first land step. Check that the radiation model updates "
                                  "at all (for RRTMGP, erf.rad_freq_in_steps > 0) and that its "
                                  "coupling to the land model reaches this level; running on "
                                  "zero radiation would be a 0 K sky.");
                 }
                 if (!m_warned_radiation_inputs) {
                     m_warned_radiation_inputs = true;
                     amrex::Print() << "WARNING: Noah-MP at level " << lev << " found no valid "
                                    << invalid << " on its first land step after a restart or "
                                       "regrid and is using zero in its place until the next "
                                    << m_radiation_model_name << " update writes them (for "
                                       "RRTMGP, every erf.rad_freq_in_steps steps). This warning "
                                       "is printed once; the run aborts only when the inputs are "
                                       "already missing on a run started from scratch.\n";
                 }
             } else {
                 m_checked_radiation_inputs = true;
                 amrex::Print() << "WARNING: Noah-MP at level " << lev << " found no valid "
                                << invalid << " from the radiation model and is using zero in "
                                   "its place; the land surface will receive no radiative "
                                   "forcing there. This warning is printed once.\n";
             }
         }
  
         bool is_moist = (cons_in.nComp() > RhoQ1_comp);
  
         int klo = domain.smallEnd(2);
  
         // Collect the typed precip slots, then seed the per-level previous-accumulation
         // snapshots the delta kernel differences against (ERF_NOAHMP_Precip.cpp).
         const erf_noahmp::PrecipSlots precip = collect_precip_sources(precip_sources);
         prepare_precip_snapshots(lev, precip);
  
         // Cells the guards touched this call; reported after the box loop.
         Vector<erf_noahmp::ClampedPrecipCell>   clamped_cells;
         Vector<erf_noahmp::InvariantPrecipCell> invariant_cells;
  
         // Loop over blocks: ERF -> Noahmp, drive the land model, Noahmp -> ERF.
         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));
  
             // Only tiles at the lower z boundary
             if (bx.smallEnd(2) != klo) { continue; }
  
             bx.makeSlab(2,klo);
             gbx.makeSlab(2,klo);
  
             // The NoahmpIO block and its pinned staging buffers for this box,
             // all co-indexed by idb, bundled into one handle.
             const erf_noahmp::NoahmpBlockViews blk {
                 &noahmpio_vect[idb],
                 noahmp_input_tmp[idb]->array(),
                 noahmp_output_tmp[idb]->array()
             };
  
             // (1-3) ERF forcing -> pinned input -> NoahmpIO arrays.
             stage_forcing(mfi, blk, bx, klo, lev, is_moist,
                           cons_in, xvel_in, yvel_in, z_nd,
                           precip, clamped_cells, invariant_cells);
  
             // (4) Drive Noah-MP. Mirror the authoritative counter into the block first.
             blk.io->itimestep = m_itimestep;
             blk.io->DriverMain();
  
             // (5-6) NoahmpIO results -> pinned output -> ERF coupling fields.
             read_results(mfi, blk, bx, gbx, cons_in);
         }
  
         // Retire the firing index only after every block has consumed it, so the first
         // firing reports ITIMESTEP == 1 and reaches Noah-MP's first-call init (#3618).
         m_itimestep += 1;   // once per firing, in lockstep on every rank
  
         // Advance the snapshots now that this call's RAINBL/SR have been consumed.
         advance_precip_snapshots(lev, precip);
  
         // Report any cells the guards clamped / rescaled (never silent).
         report_precip_diagnostics(lev, clamped_cells, invariant_cells);
  
         for (auto ivar = 0; ivar < LsmFlux_NOAHMP::NumVars; ++ivar) {
             lsm_fab_flux[ivar]->FillBoundary(m_geom.periodicity());
         }
         Print () << "Noah-MP driver at level " << lev << " completed" << std::endl;
     }
 }

Here is the call graph for this function:

◆ collect_precip_sources()

erf_noahmp::PrecipSlots NOAHMP::collect_precip_sources ( const SurfacePrecipAccumulationSources & precip_sources )

 {
     erf_noahmp::PrecipSlots p;
     const SurfacePrecipAccumulationSource slot_src[NoahmpPrecipSlot::NumSlots] = {
         precip_sources.total, precip_sources.rain, precip_sources.snow,
         precip_sources.graupel, precip_sources.hail };
     for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
         p.accum[s]  = slot_src[s].accum;
         p.factor[s] = slot_src[s].native_to_kg_m2;
         p.has[s]    = (slot_src[s].accum != nullptr);
     }
     p.have_any = surface_precip_has_any_source(precip_sources);
     return p;
 }

Here is the call graph for this function:

◆ Define()

void NOAHMP::Define ( SolverChoice & sc )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         // Whether the configured radiation model writes Noah-MP's radiation inputs
         // (SWDOWN, GLW, COSZEN); see the first-land-step check in Advance_With_State.
         m_radiation_feeds_lsm = sc.rad_feeds_lsm();
         m_radiation_model_name = amrex::getEnumNameString(sc.rad_type);
     }

Here is the call graph for this function:

◆ Get_LSM_Step()

int NOAHMP::Get_LSM_Step ( ) const

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         return m_itimestep;
     }

◆ Get_Update_Status()

bool NOAHMP::Get_Update_Status ( )

inlineoverridevirtual

Reimplemented from NullSurf.

205 { return m_updated; }

◆ Init() [1/3]

virtual void NullSurf::Init

inline

34 { }

◆ Init() [2/3]

void NOAHMP::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,
		amrex::Vector< amrex::Vector< std::string >> &	nc_init_file
	)

overridevirtual

Reimplemented from NullSurf.

 {
     // Install Noah-MP's fatal-error handler once: route NoahmpIO_fatal() through
     // amrex::Abort so a fatal error propagates via MPI_Abort. See NoahmpFatal.H.
     static const bool noahmp_fatal_installed = []() {
         // The driver's own aborts pass no message: it WRITEs the reason to standard output
         // on rank 0 first, and that line is usually lost when the job is killed. NOAHMP::Init
         // checks the files the driver opens beforehand (noahmp_preflight); what reaches
         // this default is a problem inside one of them, so point at the likely ones.
         NoahmpIO_set_fatal_handler([](const char* msg){
             amrex::Abort(msg ? msg :
                 "Noah-MP fatal error in the Fortran driver. Its explanation is written to "
                 "standard output on rank 0 and is usually lost when the job stops; check for a "
                 "malformed namelist.erf (every *_TIMESTEP and *_OPTION is an integer), a "
                 "NoahmpTable.TBL that does not match the land-use scheme (MMINLU), or a land "
                 "setup file missing one of the fields Noah-MP reads.");
         });
         return true;
     }();
     amrex::ignore_unused(noahmp_fatal_installed);
  
     // Noah-MP's own physics checks end the run with a bare Fortran STOP (27 of them, e.g.
     // "Error: Solar radiation budget problem in NoahMP LSM"), which exits with status 0.
     // main() installs an atexit trap that turns any exit() while AMReX is still
     // initialised into a failure status; see install_exit_trap in main.cpp.
  
     // dt is a placeholder: ERF::make_lsm_at_level passes zero, because the level's step is
     // not known yet when the level is built. Nothing here may depend on it; the step is
     // checked against NOAH_TIMESTEP in Advance_With_State, where it is real.
     amrex::ignore_unused(dt);
  
     m_lev   = lev;
     m_geom  = geom;
     m_geom0 = geom0;
  
     // Init runs again when a level is rebuilt (a regrid, including the one a restart
     // can trigger), and the setVal below re-installs the lsm_undefined sentinel in the
     // radiation inputs; make Advance_With_State re-check them rather than trust a
     // verdict from before the wipe, and let it see that this is a rebuild.
     m_checked_radiation_inputs = false;
     m_warned_radiation_inputs  = false;
     m_first_advance_nstep      = -1;
     m_domain_bcs_type = domain_bcs_type;
     m_refRatio = refRatio;
  
     Box domain = geom.Domain();
  
     // Resolve NSOIL from erf.lsm_nsoil before building the collective LSM fabs (same
     // value the parent used via Lsm_Data_Size()); namelist NSOIL asserted below.
     m_ensure_nsoil_resolved();
  
     // The fixed 2D fields are identity-mapped; their names mirror the enum order.
     LsmDataMap.resize(m_lsm_data_size);
     LsmDataName.resize(m_lsm_data_size);
     for (int i(0); i < LsmData_NOAHMP::NumVars; ++i) { LsmDataMap[i] = i; }
     {
         // Names from the same registry as the enum, so they cannot drift.
         const std::vector<std::string> fixed_names = {
             NOAHMP_LSMDATA_FIELDS(NOAHMP_QUOTE)
         };
         AMREX_ALWAYS_ASSERT(int(fixed_names.size()) == LsmData_NOAHMP::NumVars);
         for (int i(0); i < LsmData_NOAHMP::NumVars; ++i) { LsmDataName[i] = fixed_names[i]; }
     }
     // Per-layer soil profile: 3 groups of m_nsoil, layer index 1-based (WRF SMOIS_k).
     {
         const char* group[m_num_soil_groups] = {"smois", "sh2o", "tslb"};
         for (int g(0); g < m_num_soil_groups; ++g) {
             for (int k(0); k < m_nsoil; ++k) {
                 int idx = soil_data_idx(g,k);
                 LsmDataMap[idx]  = idx;
                 LsmDataName[idx] = std::string(group[g]) + "_" + std::to_string(k+1);
             }
         }
     }
  
     LsmFluxMap  = {LsmFlux_NOAHMP::t_flux         , LsmFlux_NOAHMP::q_flux         ,
                    LsmFlux_NOAHMP::tau13          , LsmFlux_NOAHMP::tau23          };
     LsmFluxName = {"t_flux"         , "q_flux"         ,
                    "tau13"          , "tau23"          };
  
     // NOTE: relies on all boxes in ba spanning zlo..zhi; otherwise dm/ba no longer
     //       line up and lsm data/flux vars can't be copied directly 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 (CC), runtime-sized (fixed 2D fields + 3*m_nsoil) so soil scales
     // with NSOIL. lsm_lev0_data pointers are populated later by the parent.
     lsm_fab_data.resize(m_lsm_data_size);
     lsm_lev0_data.resize(m_lsm_data_size, nullptr);
     for (auto ivar = 0; ivar < m_lsm_data_size; ++ivar) {
         lsm_fab_data[ivar] = std::make_shared<MultiFab>(ba_lsm, dm, 1, ng);
         lsm_fab_data[ivar]->setVal(lsm_undefined);
     }
  
     // Create the fluxes (CC with ghost cells for averaging)
     for (auto ivar = 0; ivar < LsmFlux_NOAHMP::NumVars; ++ivar) {
         lsm_fab_flux[ivar] = std::make_shared<MultiFab>(ba_lsm, dm, 1, ng);
         lsm_fab_flux[ivar]->setVal(lsm_undefined);
     }
  
     // Level 0 always runs the Noah-MP driver: the driver reads its land state from the
     // file ERF_SETUP_FILE_01 in namelist.erf names, whatever ERF's own initialization is,
     // and there is no coarser level for the other branch (interp_from_lev0) to take it
     // from. This used to follow only from ERF::nc_init_file's static default being
     // {{""}} -- one empty string at level 0, so the vector below is never empty there,
     // with or without erf.nc_init_file_0 -- which is how an idealized run could use
     // Noah-MP at all. Say it outright so it does not rest on that placeholder.
     // A finer level runs the driver only if it has an init file of its own.
     m_has_nc_file = (lev == 0) || (!nc_init_file[lev].empty());
     if (m_has_nc_file) {
         Print() << "Noah-MP initialization started" << std::endl;
  
         noahmp_preflight(lev);
  
         // Size noahmpio_vect to the local boxes. A rank owning no boxes leaves it
         // empty and relies on the class-level m_itimestep/m_dtbl instead.
         if (cons_in.local_size() > 0) {
             noahmpio_vect.resize(cons_in.local_size(), lev);
         }
  
         // 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 the multifab and noahmpio objects together, using the
         // multifab to set the per-box bounds on each noahmpio object.
         int idb = 0;
         for (MFIter mfi(cons_in); mfi.isValid(); ++mfi, ++idb) {
  
             Box bx = mfi.tilebox();
  
             AMREX_ALWAYS_ASSERT_WITH_MESSAGE(bx.smallEnd(2) == klo,
                 "NoahMP Init: box does not start at klo; z-decomposed grids are unsupported.");
  
             bx.makeSlab(2,klo);
  
             // Pinned buffers per box; output carries the 2D outputs + 3 soil groups.
             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 + m_num_soil_groups*m_nsoil, The_Pinned_Arena());
  
             NoahmpIO_type* noahmpio = &noahmpio_vect[idb];
  
             noahmpio->blkid = idb;
             noahmpio->level = lev;
             noahmpio->ScalarInitDefault();
             noahmpio->rank = ParallelDescriptor::MyProc();
             noahmpio->comm = MPI_Comm_c2f(ParallelDescriptor::Communicator());
  
             // namelist.erf holds noahmpio-specific parameters, read Fortran-side.
             noahmpio->ReadNamelist();
  
             // Assert namelist NSOIL matches erf.lsm_nsoil (used to size the fabs) so a
             // mismatch fails loudly rather than truncating the soil diagnostics.
             AMREX_ALWAYS_ASSERT_WITH_MESSAGE(noahmpio->nsoil == m_nsoil,
                 "namelist.erf NSOIL does not match erf.lsm_nsoil (default 4); "
                 "set erf.lsm_nsoil to the Noah-MP soil-layer count");
  
             // NetCDF land-file headers (also Fortran-side)
             noahmpio->ReadLandHeader();
  
             // Set domain/memory/tile bounds from the tile. All three are set to the
             // same bounds for now; may change for special memory management later.
             noahmpio->xstart = bx.smallEnd(0);
             noahmpio->xend   = bx.bigEnd(0);
             noahmpio->ystart = bx.smallEnd(1);
             noahmpio->yend   = bx.bigEnd(1);
  
             // Domain, tile, and memory bounds are all equal for now (single-slab model).
             auto set_grid_bounds = [](NoahmpIO_type* io, int x0, int x1, int y0, int y1) {
                 io->ids=io->its=io->ims=x0; io->ide=io->ite=io->ime=x1;
                 io->jds=io->jts=io->jms=y0; io->jde=io->jte=io->jme=y1;
                 io->kds=io->kts=io->kms=1;  io->kde=io->kte=io->kme=2;
             };
             set_grid_bounds(noahmpio, noahmpio->xstart, noahmpio->xend, noahmpio->ystart, noahmpio->yend);
  
             // Allocate Fortran IO memory from the bounds above + namelist/header info
             noahmpio->VarInitDefault();
  
             // NoahmpTable.TBL input
             noahmpio->ReadTable();
  
             // Read/initialize from the NetCDF land file
             noahmpio->ReadLandMain();
  
             // Compute initial values not supplied by the land file
             noahmpio->InitMain();
         }
  
         // Initial land plotfile (tag 0); must run on the land-owning subcomm, not the
         // full comm, or a land-free rank never joins the collective nf90_create.
         Print() << "Noah-MP writing lnd.nc file at lev: " << lev << std::endl;
         with_land_comm([](NoahmpIO_type& noahmpio) { noahmpio.WriteLand(0); });
  
         // Broadcast DTBL and the initial substep counter so the firing decision is
         // identical on every rank. Land-free ranks use max-reduction-losing sentinels.
         m_dtbl      = noahmpio_vect.empty() ? std::numeric_limits<Real>::lowest()
                                             : static_cast<Real>(noahmpio_vect[0].DTBL);
         m_itimestep = noahmpio_vect.empty() ? std::numeric_limits<int>::lowest()
                                             : noahmpio_vect[0].itimestep;
         ParallelDescriptor::ReduceRealMax(m_dtbl);
         ParallelDescriptor::ReduceIntMax(m_itimestep);
  
         // Guard against a decomposition in which no rank owns a land box.
         // DTBL is real(NOAH_TIMESTEP) from namelist.erf, and NOAH_TIMESTEP defaults to
         // -9999 in the driver, so this is what an absent NOAH_TIMESTEP looks like. (It is
         // not about land: noahmpio_vect is sized by boxes, land or not, so every rank that
         // owns a box contributes a DTBL to the max.)
         AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_dtbl > Real(0.0),
             "Noah-MP: the Noah-MP timestep is not positive. Set NOAH_TIMESTEP (in seconds, "
             "an integer) in namelist.erf.");
         // The ERF-step-versus-NOAH_TIMESTEP constraint is enforced in Advance_With_State:
         // the dt this function receives is a placeholder zero (see the top of Init), so a
         // check against it here -- there used to be one -- could never fire.
  
         Print() << "Noah-MP initialization completed" << std::endl;
     } // has nc_init_file
  
 };

Here is the call graph for this function:

◆ Init() [3/3]

virtual void NullSurf::Init

inline

     {
         Init(lev, cons_in, geom, geom0,
              domain_bcs_type, refRatio, dt_advance,
              nc_init_file);
     }

◆ interp_from_lev0()

void NOAHMP::interp_from_lev0	(	const int &	lev,
		amrex::MultiFab &	cons_in,
		const int &	nstep
	)

 {
     amrex::ignore_unused(cons_in);
  
     Print () << "Noah-MP interpolation at level " << lev << " started at time step: " << nstep+1 << std::endl;
     m_updated = true;
  
     //
     // These fields have no vertical extent: Init collapses them to a single z index at
     // every level and carries the soil profile in components rather than in cells, so
     // there is nothing in the vertical for the interpolation to do.  It must therefore be
     // handed a ratio of 1 in z even when the levels really are refined in the vertical --
     // a ratio greater than 1 makes the interpolater ask for a layer of coarse ghost cells
     // in z that these MultiFabs do not, and cannot, carry.
     //
     // NOTE: m_refRatio is the ratio between level 0 and this level, which is what we need
     //       since we interpolate from level 0 (m_geom0) rather than from the parent.
     //
     const IntVect rr2d(m_refRatio[0], m_refRatio[1], 1);
  
     for (int ivar(0); ivar<m_lsm_data_size; ++ivar) {
         InterpFromCoarseLevel(*lsm_fab_data[ivar], lsm_fab_data[ivar]->nGrowVect(),
                               IntVect(0,0,0), // do NOT fill ghost cells outside the domain
                               *lsm_lev0_data[ivar], 0, 0, 1,
                               m_geom0, m_geom,
                               rr2d, &cell_cons_interp,
                               m_domain_bcs_type, BCVars::cons_bc);
     }
  
     // SurfaceLayer filled the noah flux where lsm_undefined existed, so the
     // coarse-grid flux is complete and safe to interpolate.
     for (int ivar(0); ivar<LsmFlux_NOAHMP::NumVars; ++ivar) {
         InterpFromCoarseLevel(*lsm_fab_flux[ivar], lsm_fab_flux[ivar]->nGrowVect(),
                               IntVect(0,0,0), // do NOT fill ghost cells outside the domain
                               *lsm_lev0_flux[ivar], 0, 0, 1,
                               m_geom0, m_geom,
                               rr2d, &cell_cons_interp,
                               m_domain_bcs_type, BCVars::cons_bc);
     }
     Print () << "Noah-MP interpolation at level " << lev << " completed" << std::endl;
 }

◆ 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.

136 { m_ensure_nsoil_resolved(); return NOAHMP::m_lsm_data_size; }

Here is the call graph for this function:

◆ Lsm_DataIndex()

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

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         int varIdx = -1;
         std::string lc_varname = amrex::toLower(varname);
         for (int idx(0); idx<m_lsm_data_size; ++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.

140 { return NOAHMP::m_lsm_flux_size; }

NOAHMP::m_lsm_flux_size

int m_lsm_flux_size

Definition: ERF_NOAHMP.H:335

◆ Lsm_FluxIndex()

int NOAHMP::Lsm_FluxIndex ( const 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; // -1 if this model does not carry that flux; callers probe with this
     }

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.

131 { return m_lsm_geom; }

◆ Lsm_Set_Lev0_Data_Ptr()

void NOAHMP::Lsm_Set_Lev0_Data_Ptr	(	const int &	varIdx,
		amrex::MultiFab *	lev0_data_ptr
	)

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         AMREX_ALWAYS_ASSERT(varIdx >= 0 && varIdx < m_lsm_data_size);
         lsm_lev0_data[varIdx] = lev0_data_ptr;
     }

Here is the call graph for this function:

◆ Lsm_Set_Lev0_Flux_Ptr()

void NOAHMP::Lsm_Set_Lev0_Flux_Ptr	(	const int &	varIdx,
		amrex::MultiFab *	lev0_flux_ptr
	)

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         AMREX_ALWAYS_ASSERT(varIdx >= 0 && varIdx < int(LsmFlux_NOAHMP::NumVars));
         lsm_lev0_flux[varIdx] = lev0_flux_ptr;
     }

Here is the call graph for this function:

◆ m_ensure_nsoil_resolved()

void NOAHMP::m_ensure_nsoil_resolved ( )

inline

                                     {
         if (m_nsoil_resolved) { return; }
         amrex::ParmParse pp_nsoil("erf");
         pp_nsoil.queryAdd("lsm_nsoil", m_nsoil);
         AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_nsoil >= 1, "erf.lsm_nsoil must be >= 1");
         m_lsm_data_size = LsmData_NOAHMP::NumVars + m_num_soil_groups*m_nsoil;
         m_nsoil_resolved = true;
     }

Referenced by Lsm_Data_Size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ m_precip_snapshot_name()

static std::string NOAHMP::m_precip_snapshot_name	(	const std::string &	dir,
		int	l,
		int	s
	)

inlinestatic

                                                                 {
         return dir + "/precip_accum_prev_Level_" + std::to_string(l)
                    + "_slot_" + std::to_string(s);
     }

◆ Plot_Landfile()

void NOAHMP::Plot_Landfile ( const int & nstep )

overridevirtual

Reimplemented from NullSurf.

 {
     with_land_comm([nstep](NoahmpIO_type& noahmpio) { noahmpio.WriteLand(nstep); });
 }

◆ prepare_precip_snapshots()

void NOAHMP::prepare_precip_snapshots	(	const int &	lev,
		const erf_noahmp::PrecipSlots &	precip
	)

 {
     if (!precip.have_any) { return; }
  
     if (int(m_precip_accum_prev.size()) <= lev) { m_precip_accum_prev.resize(lev+1); }
     auto& prev = m_precip_accum_prev[lev];
     for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
         if (precip.has[s] && prev[s] == nullptr) {
             // Zero ghost cells + setVal(0) so no cell is uninitialized (garbage prev
             // -> ~1e25 deltas -> Noah-MP water-balance abort); only the slab is read.
             prev[s] = std::make_unique<MultiFab>(
                 precip.accum[s]->boxArray(), precip.accum[s]->DistributionMap(), 1, 0);
             prev[s]->setVal(0.0);
             if (m_precip_accum_restored[s]) {
                 // Restart: ParallelCopy handles a changed decomposition; consume once.
                 prev[s]->ParallelCopy(*m_precip_accum_restored[s], 0, 0, 1);
                 m_precip_accum_restored[s].reset();
             } else {
                 MultiFab::Copy(*prev[s], *precip.accum[s], 0, 0, 1, 0);
             }
         }
     }
 }

◆ Read_Lsm_Restart()

void NOAHMP::Read_Lsm_Restart ( const std::string & dir )

overridevirtual

Reimplemented from NullSurf.

 {
     // Same collective-scope split as Write_Lsm_Restart.
     with_land_comm([&dir](NoahmpIO_type& noahmpio) { noahmpio.ReadRestart(dir); });
  
     // Read saved precip snapshots into a staging store; the first Advance copies them
     // into the live snapshots. Legacy checkpoints lack the files -> Advance cold-seeds.
     for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
         const std::string name = m_precip_snapshot_name(dir, m_lev, s);
         if (amrex::FileExists(name + "_H")) {
             auto mf = std::make_unique<amrex::MultiFab>();
             amrex::VisMF::Read(*mf, name);
             m_precip_accum_restored[s] = std::move(mf);
         }
     }
 }

◆ read_results()

void NOAHMP::read_results	(	const amrex::MFIter &	mfi,
		const erf_noahmp::NoahmpBlockViews &	blk,
		const amrex::Box &	bx,
		const amrex::Box &	gbx,
		amrex::MultiFab &	cons_in
	)

 {
     NoahmpIO_type* noahmpio = blk.io;
  
     // 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);
  
     const Array4<const Real>& CONS = cons_in.const_array(mfi);
  
     // Mechanical result destinations (RRTMGP coupling + return-term diagnostics),
     // bound from NOAHMP_RESULT_FIELDS to stay in sync with the scatter below.
 #define NOAHMP_BIND_RESULT(alias,lsm,out) Array4<Real> alias = lsm_fab_data[LsmData_NOAHMP::lsm]->array(mfi);
     NOAHMP_RESULT_FIELDS(NOAHMP_BIND_RESULT)
 #undef NOAHMP_BIND_RESULT
     // Sentinels (this core does not compute them; always lsm_undefined below).
     Array4<Real> SMSTAV_o    = lsm_fab_data[LsmData_NOAHMP::smstav]->array(mfi);
     Array4<Real> SMSTOT_o    = lsm_fab_data[LsmData_NOAHMP::smstot]->array(mfi);
  
     // Per-layer soil output fabs (3 groups x m_nsoil) in a device-visible vector so
     // the scatter loops over any NSOIL. Layout: g in {0:smois,1:sh2o,2:tslb}, k in [0,nsoil).
     const int nsoil = m_nsoil;
     const int n_soil_fld = m_num_soil_groups*nsoil;
     Gpu::DeviceVector<Array4<Real>> soil_arr_d(n_soil_fld);
     {
         Vector<Array4<Real>> soil_arr_h(n_soil_fld);
         for (int g(0); g < 3; ++g) {
             for (int k(0); k < nsoil; ++k) {
                 soil_arr_h[g*nsoil+k] = lsm_fab_data[soil_data_idx(g,k)]->array(mfi);
             }
         }
         Gpu::copyAsync(Gpu::hostToDevice, soil_arr_h.begin(), soil_arr_h.end(), soil_arr_d.begin());
         Gpu::streamSynchronize();
     }
     Array4<Real>* soil_arr = soil_arr_d.data();
     const int soil_out_base = NoahmpOutputComp::NumComps; // soil outputs start here
  
     // SurfaceLayer flux destinations
     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);
  
     Array4<Real> noah_output_arr = blk.output;
  
     // (5) Copy NoahmpIO results into the pinned output buffer; banded albedos and
     // the soil profile are read explicitly. SMSTAV/SMSTOT are emitted lsm_undefined.
     LoopOnCpu(bx, [&] (int i, int j, int ) noexcept
     {
 #define NOAHMP_READ_OUT_2D(comp,member) noah_output_arr(i,j,0,NoahmpOutputComp::comp) = noahmpio->member(i,j);
         NOAHMP_OUTPUT_2D_FIELDS(NOAHMP_READ_OUT_2D)
 #undef NOAHMP_READ_OUT_2D
         // Banded radiation reads (VIS=1, NIR=2)
         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);
         // Soil profile, one 2D component per layer (Fortran layer index is 1-based).
         for (int k(0); k < nsoil; ++k) {
             noah_output_arr(i,j,0,soil_out_base + 0*nsoil + k) = noahmpio->SMOIS(i,k+1,j);
             noah_output_arr(i,j,0,soil_out_base + 1*nsoil + k) = noahmpio->SH2O (i,k+1,j);
             noah_output_arr(i,j,0,soil_out_base + 2*nsoil + k) = noahmpio->TSLB (i,k+1,j);
         }
     });
  
     // (6) Copy Noahmp results to ERF (device; from pinned buffer): per-field math
     // (flux ÷rho, -9999 fill guard, sentinels, soil loop), deliberately not table-driven.
     ParallelFor(gbx, [=,Cp_d_d=Cp_d,L_v_d=L_v,lsm_undefined_d=lsm_undefined]
                          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);
  
         // Noah-MP returns -9999 for cells it does not process (sea-ice/open-water);
         // HFX is Noah-MP's processed-cell gate; it is not a statement that
         // every physical output is valid. tau13/tau23 are nodal in xz/yz;
         // the 2D MFs carry 1 ghost cell for averaging.
         const Real hfx_lsm = noah_output_arr(ii,jj,0,NoahmpOutputComp::hfx);
         const noahmp_result_policy::CellPolicy cell_policy(hfx_lsm);
         // Noah-MP returns HFX,LH [W/m2] and TAU [N/m2] (rho included); divide by
         // rho for the kinematic MOST form ERF stores. Exner factor on t_flux is
         // omitted to match WRF (<~1% error near surface, ~6-7% at p~800 hPa).
         const Real rho_l = CONS(ii,jj,k,Rho_comp);
         const auto fluxes = cell_policy.select_fluxes(
             noah_output_arr(ii,jj,0,NoahmpOutputComp::lh),
             noah_output_arr(ii,jj,0,NoahmpOutputComp::tau_ew),
             noah_output_arr(ii,jj,0,NoahmpOutputComp::tau_ns),
             rho_l, Cp_d_d, L_v_d, lsm_undefined_d);
         t_flux_arr(i,j,k) = fluxes.temperature;
         q_flux_arr(i,j,k) = fluxes.mixing_ratio;
         tau13_arr(i,j,k)  = fluxes.tau_ew;
         tau23_arr(i,j,k)  = fluxes.tau_ns;
  
         // Processed cells retain field-specific validity checks. Unprocessed
         // cells invalidate the complete provider result set.
         if (cell_policy.processed) {
 #define NOAHMP_COPY_RESULT(alias,lsm,out)                                      \
         {                                                                       \
             const Real value = noah_output_arr(ii,jj,0,NoahmpOutputComp::out);  \
             alias(i,j,0) = cell_policy.select(                                  \
                 value, lsm_undefined_d, NoahmpOutputComp::out);                \
         }
         NOAHMP_RESULT_FIELDS(NOAHMP_COPY_RESULT)
 #undef NOAHMP_COPY_RESULT
             // Not computed by this core -> sentinel, not a misleading 0.
             SMSTAV_o(i,j,0) = lsm_undefined_d;
             SMSTOT_o(i,j,0) = lsm_undefined_d;
             for (int s(0); s < n_soil_fld; ++s) {
                 const Real value = noah_output_arr(ii,jj,0,soil_out_base + s);
                 soil_arr[s](i,j,0) = cell_policy.select(value, lsm_undefined_d, -1);
             }
         } else {
 #define NOAHMP_UNDEF_RESULT(alias,lsm,out) alias(i,j,0) = lsm_undefined_d;
             NOAHMP_RESULT_FIELDS(NOAHMP_UNDEF_RESULT)
 #undef NOAHMP_UNDEF_RESULT
             SMSTAV_o(i,j,0) = lsm_undefined_d;
             SMSTOT_o(i,j,0) = lsm_undefined_d;
             for (int s(0); s < n_soil_fld; ++s) {
                 soil_arr[s](i,j,0) = lsm_undefined_d;
             }
         }
     });
     // The scatter kernel reads soil_arr_d; sync before it is destroyed.
     Gpu::streamSynchronize();
 }

Here is the call graph for this function:

◆ report_precip_diagnostics()

void NOAHMP::report_precip_diagnostics	(	const int &	lev,
		const amrex::Vector< erf_noahmp::ClampedPrecipCell > &	clamped_cells,
		const amrex::Vector< erf_noahmp::InvariantPrecipCell > &	invariant_cells
	)

 {
     if (!clamped_cells.empty()) {
         const int nshow = amrex::min(int(clamped_cells.size()), 50);
         amrex::AllPrint aprint;
         aprint << "WARNING: NOAHMP precip guard (level " << lev << "): clamped "
                << clamped_cells.size() << " non-physical interval-precip cell(s) (> "
                << lsm_max_precip_interval << " mm):\n";
         for (int c(0); c < nshow; ++c) {
             aprint << "    (i,j)=(" << clamped_cells[c].i << "," << clamped_cells[c].j
                    << ") raw=" << clamped_cells[c].raw_mm << " mm\n";
         }
         if (int(clamped_cells.size()) > nshow) {
             aprint << "    ... and " << (int(clamped_cells.size()) - nshow) << " more\n";
         }
     }
  
     if (!invariant_cells.empty()) {
         const int nshow = amrex::min(int(invariant_cells.size()), 50);
         amrex::AllPrint aprint;
         aprint << "WARNING: NOAHMP precip invariant (level " << lev << "): rescaled frozen "
                << "components in " << invariant_cells.size() << " cell(s) where "
                << "MP_SNOW+MP_GRAUP exceeded MP_RAINNC:\n";
         for (int c(0); c < nshow; ++c) {
             aprint << "    (i,j)=(" << invariant_cells[c].i << "," << invariant_cells[c].j
                    << ") frozen=" << invariant_cells[c].froz_mm
                    << " mm > total=" << invariant_cells[c].total_mm << " mm\n";
         }
         if (int(invariant_cells.size()) > nshow) {
             aprint << "    ... and " << (int(invariant_cells.size()) - nshow) << " more\n";
         }
     }
 }

◆ Set_LSM_Step()

void NOAHMP::Set_LSM_Step ( int step )

inlineoverridevirtual

Reimplemented from NullSurf.

     {
         m_itimestep = step;
         for (auto& noahmpio : noahmpio_vect) {
             noahmpio.itimestep = step;
         }
     }

◆ soil_data_idx()

int NOAHMP::soil_data_idx	(	int	g,
		int	k
	)		const

inline

                                            {
         return LsmData_NOAHMP::NumVars + g*m_nsoil + k;
     }

◆ stage_forcing()

void NOAHMP::stage_forcing	(	const amrex::MFIter &	mfi,
		const erf_noahmp::NoahmpBlockViews &	blk,
		const amrex::Box &	bx,
		const int &	klo,
		const int &	lev,
		const bool	is_moist,
		amrex::MultiFab &	cons_in,
		amrex::MultiFab &	xvel_in,
		amrex::MultiFab &	yvel_in,
		amrex::MultiFab *	z_nd,
		const erf_noahmp::PrecipSlots &	precip,
		amrex::Vector< erf_noahmp::ClampedPrecipCell > &	clamped_cells,
		amrex::Vector< erf_noahmp::InvariantPrecipCell > &	invariant_cells
	)

 {
     NoahmpIO_type* noahmpio = blk.io;
  
     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);
  
     const Array4<const Real> z_nd_arr = (z_nd) ? z_nd->const_array(mfi) :
                                                  Array4<const Real> {};
  
     // Forcing pulled from the coupling data fields
     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);
  
     // Pinned (host-accessible, GPU-usable) staging buffer
     Array4<Real> noah_input_arr = blk.input;
  
     // Per-slot precip views (current + previous snapshot) and their native->kg/m^2
     // factors. Read only inside the device kernel; absent slots guarded by slot_present.
     const bool hp = precip.have_any;
     GpuArray<Array4<const Real>, NoahmpPrecipSlot::NumSlots> accum_now, accum_prv;
     GpuArray<Real, NoahmpPrecipSlot::NumSlots> accum_fac;
     GpuArray<int,  NoahmpPrecipSlot::NumSlots> slot_present;
     for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
         slot_present[s] = (hp && precip.has[s]) ? 1 : 0;
         accum_fac[s]    = precip.factor[s];
         if (slot_present[s]) {
             accum_now[s] = precip.accum[s]->const_array(mfi);
             accum_prv[s] = m_precip_accum_prev[lev][s]->const_array(mfi);
         }
     }
     const int kklo = klo;
  
     // (1) Stage ERF forcing into the pinned buffer (device).
     Real zref_default = noahmpio->ZLVL;
     ParallelFor(bx, [=,zero_d=zero] 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_d;
         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::dz8w)    = two * ((z_nd_arr) ? Compute_Zrel_AtCellCenter(i,j,kklo,z_nd_arr) : zref_default);
         // The radiation inputs come from whichever radiation model writes them, and
         // NOAHMP::Init setVal'd every lsm_fab_data to lsm_undefined (1e150 in double,
         // 1e18 in single). A model that does not write them -- erf.radiation_model unset,
         // or a model whose radiation -> land direction is not wired -- therefore leaves
         // the sentinel here, and taking it raw had Noah-MP integrating on ~2e149 W/m^2 of
         // shortwave while the run exited 0.
         //
         // Apply the shared validity test (is_valid_lsm_value in ERF_Constants.H, the
         // same test RRTMGP applies to its own LSM inputs) and fall back to zero, which
         // is what "no radiation reaching the surface" physically means.
         {
             const Real sw_in = SWDOWN(i,j,0);
             const Real lw_in = GLW(i,j,0);
             const Real cz_in = COSZEN(i,j,0);
             noah_input_arr(i,j,0,NoahmpInputComp::swdown) = is_valid_lsm_value(sw_in) ? sw_in : zero_d;
             noah_input_arr(i,j,0,NoahmpInputComp::glw)    = is_valid_lsm_value(lw_in) ? lw_in : zero_d;
             noah_input_arr(i,j,0,NoahmpInputComp::coszen) = is_valid_lsm_value(cz_in) ? cz_in : zero_d;
         }
  
         // RAW water-equivalent interval precip [mm]: per slot d = max(0, (now-prev)
         // * native_to_kg_m2). Host applies the guard and derives SR / MP_RAINNC.
         Real drain = zero_d, dsnow = zero_d, dgraup = zero_d;
         if (hp) {
             Real dd[NoahmpPrecipSlot::NumSlots];
             for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
                 dd[s] = slot_present[s]
                     ? amrex::max(zero_d, (accum_now[s](i,j,kklo) - accum_prv[s](i,j,kklo)) * accum_fac[s])
                     : zero_d;
             }
             // Hail is folded into MP_GRAUP (no ERF scheme fills the hail slot
             // today); to feed it separately, stage dd[hail] into MP_HAIL instead.
             dsnow  = dd[NoahmpPrecipSlot::snow];
             dgraup = dd[NoahmpPrecipSlot::graupel] + dd[NoahmpPrecipSlot::hail];
             const Real dfroz = dsnow + dgraup;
             // Total: scheme's `total` slot, else rain + frozen.
             drain = slot_present[NoahmpPrecipSlot::total]
                   ? dd[NoahmpPrecipSlot::total]
                   : (dd[NoahmpPrecipSlot::rain] + dfroz);
         }
         noah_input_arr(i,j,0,NoahmpInputComp::rainbl)   = drain;
         noah_input_arr(i,j,0,NoahmpInputComp::mp_snow)  = dsnow;
         noah_input_arr(i,j,0,NoahmpInputComp::mp_graup) = dgraup;
     });
  
     // (2) Wait for the kernel before host access.
     Gpu::streamSynchronize();
  
     // (3) Copy pinned staged data to NoahmpIO on the host (3D members take the k/j
     // transpose (i,1,j), 2D take (i,j)); precip is derived below.
     LoopOnCpu(bx, [&,zero_d=zero,one_d=one,lsm_max_precip_interval_d=lsm_max_precip_interval]
                       (int i, int j, int ) noexcept
     {
 #define NOAHMP_STAGE_IN_3D(comp,member) noahmpio->member(i,1,j) = noah_input_arr(i,j,0,NoahmpInputComp::comp);
 #define NOAHMP_STAGE_IN_2D(comp,member) noahmpio->member(i,j)   = noah_input_arr(i,j,0,NoahmpInputComp::comp);
         NOAHMP_INPUT_3D_FIELDS(NOAHMP_STAGE_IN_3D)
         NOAHMP_INPUT_2D_FIELDS(NOAHMP_STAGE_IN_2D)
 #undef NOAHMP_STAGE_IN_3D
 #undef NOAHMP_STAGE_IN_2D
         // Guard the RAW total, then derive SR / MP_RAINNC. Clamped cells are
         // reported after the box loop (never silent).
         Real dsnow_h  = noah_input_arr(i,j,0,NoahmpInputComp::mp_snow);
         Real dgraup_h = noah_input_arr(i,j,0,NoahmpInputComp::mp_graup);
         Real drain_h  = noah_input_arr(i,j,0,NoahmpInputComp::rainbl);
         if (drain_h > lsm_max_precip_interval_d) {
             clamped_cells.push_back(erf_noahmp::ClampedPrecipCell{i, j, drain_h});
             drain_h = lsm_max_precip_interval_d;
         }
         // Frozen/total invariant: MP_SNOW+MP_GRAUP are subsets of MP_RAINNC; if
         // their sum exceeds it, rescale the frozen components down and record the cell.
         Real dfroz_h = dsnow_h + dgraup_h;
         const Real inv_tol = Real(1.0e-6) * (one_d + drain_h);
         if (dfroz_h > drain_h + inv_tol) {
             invariant_cells.push_back(erf_noahmp::InvariantPrecipCell{i, j, dfroz_h, drain_h});
             if (dfroz_h > zero_d) {
                 const Real scale = drain_h / dfroz_h;   // <= 1
                 dsnow_h  *= scale;
                 dgraup_h *= scale;
                 dfroz_h   = dsnow_h + dgraup_h;         // == drain_h (to round-off)
             }
         }
         noahmpio->RAINBL(i,j)    = drain_h;                                       // [mm]
         noahmpio->SR(i,j)        = (drain_h > zero_d) ? amrex::min(one_d, dfroz_h/drain_h) : zero_d; // [-]
         noahmpio->MP_RAINNC(i,j) = drain_h;                                       // [mm]
         noahmpio->MP_SNOW(i,j)   = dsnow_h;                                       // [mm]
         noahmpio->MP_GRAUP(i,j)  = dgraup_h;                                      // [mm] (includes folded hail)
         // 0 = "no hail" (a real value, not a sentinel; lsm_undefined would corrupt opt_snf=4)
         noahmpio->MP_HAIL(i,j)   = zero_d;                                        // [mm]
     });
 }

Here is the call graph for this function:

◆ time_to_fire()

bool NOAHMP::time_to_fire ( const amrex::Real & elapsed_time )

 {
     Real NOAH_time = static_cast<Real>(m_itimestep-1) * m_dtbl;
     if (elapsed_time < NOAH_time) {
         m_updated = false;
         return false;
     }
  
     m_updated = true;
     return true;
 }

◆ with_land_comm()

void NOAHMP::with_land_comm ( const std::function< void(NoahmpIO_type &)> & fn ) const

private

 {
     auto& blocks = const_cast<NoahmpIO_vector&>(noahmpio_vect);
 #ifdef AMREX_USE_MPI
     const int color = blocks.empty() ? MPI_UNDEFINED : 1;
     MPI_Comm land_comm = MPI_COMM_NULL;
     MPI_Comm_split(ParallelDescriptor::Communicator(), color,
                    ParallelDescriptor::MyProc(), &land_comm);
     if (land_comm == MPI_COMM_NULL) return; // land-free rank
     const int land_comm_f = static_cast<int>(MPI_Comm_c2f(land_comm));
     for (NoahmpIO_type& noahmpio : blocks) {
         const int saved = noahmpio.comm;
         noahmpio.comm   = land_comm_f;
         fn(noahmpio);
         noahmpio.comm   = saved;
     }
     MPI_Comm_free(&land_comm);
 #else
     for (NoahmpIO_type& noahmpio : blocks) {
         fn(noahmpio);
     }
 #endif
 }

◆ Write_Lsm_Restart()

void NOAHMP::Write_Lsm_Restart ( const std::string & dir ) const

overridevirtual

Reimplemented from NullSurf.

 {
     // NetCDF (land-owning ranks) and VisMF below (full communicator) are separate
     // collective scopes; a land-free early `return` here would skip the VisMF call.
     with_land_comm([&dir](NoahmpIO_type& noahmpio) { noahmpio.WriteRestart(dir); });
  
     // Also save the precip snapshots so the next land call after restart differences
     // against the same baseline (no precip dropped or double-counted).
     if (m_lev < int(m_precip_accum_prev.size())) {
         for (int s(0); s < NoahmpPrecipSlot::NumSlots; ++s) {
             if (m_precip_accum_prev[m_lev][s]) {
                 amrex::VisMF::Write(*m_precip_accum_prev[m_lev][s],
                                     m_precip_snapshot_name(dir, m_lev, s));
             }
         }
     }
 }

Member Data Documentation

◆ khi_lsm

int NOAHMP::khi_lsm = -1

private

◆ lsm_fab_data

amrex::Vector<FabPtr> 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().

◆ lsm_lev0_data

amrex::Vector<amrex::MultiFab*> NOAHMP::lsm_lev0_data

private

Referenced by Lsm_Set_Lev0_Data_Ptr().

◆ lsm_lev0_flux

amrex::Array<amrex::MultiFab*, LsmFlux_NOAHMP::NumVars> NOAHMP::lsm_lev0_flux {}

private

Referenced by Lsm_Set_Lev0_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_checked_radiation_inputs

bool NOAHMP::m_checked_radiation_inputs = false

private

◆ m_domain_bcs_type

amrex::Vector<amrex::BCRec> NOAHMP::m_domain_bcs_type

private

◆ m_dtbl

amrex::Real NOAHMP::m_dtbl = std::numeric_limits<amrex::Real>::max()

private

◆ m_dz_lsm

amrex::Real NOAHMP::m_dz_lsm = one

private

◆ m_first_advance_nstep

int NOAHMP::m_first_advance_nstep = -1

private

◆ m_geom

amrex::Geometry NOAHMP::m_geom

private

◆ m_geom0

amrex::Geometry NOAHMP::m_geom0

private

◆ m_has_nc_file

bool NOAHMP::m_has_nc_file = false

private

◆ m_itimestep

int NOAHMP::m_itimestep = 0

private

Referenced by Get_LSM_Step(), and Set_LSM_Step().

◆ m_lev

int NOAHMP::m_lev = 0

private

◆ m_lsm_data_size

int NOAHMP::m_lsm_data_size = LsmData_NOAHMP::NumVars

private

Referenced by Lsm_Data_Size(), Lsm_DataIndex(), Lsm_Set_Lev0_Data_Ptr(), and m_ensure_nsoil_resolved().

◆ 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_nsoil

int NOAHMP::m_nsoil = 4

private

Referenced by m_ensure_nsoil_resolved(), and soil_data_idx().

◆ m_nsoil_resolved

bool NOAHMP::m_nsoil_resolved = false

Referenced by m_ensure_nsoil_resolved().

◆ m_num_soil_groups

constexpr int NOAHMP::m_num_soil_groups = 3

staticconstexpr

Referenced by m_ensure_nsoil_resolved().

◆ m_nz_lsm

int NOAHMP::m_nz_lsm = 1

private

◆ m_precip_accum_prev

amrex::Vector<amrex::Array<std::unique_ptr<amrex::MultiFab>, NoahmpPrecipSlot::NumSlots> > NOAHMP::m_precip_accum_prev

private

◆ m_precip_accum_restored

amrex::Array<std::unique_ptr<amrex::MultiFab>, NoahmpPrecipSlot::NumSlots> NOAHMP::m_precip_accum_restored

private

◆ m_radiation_feeds_lsm

bool NOAHMP::m_radiation_feeds_lsm = false

private

Referenced by Define().

◆ m_radiation_model_name

std::string NOAHMP::m_radiation_model_name

private

Referenced by Define().

◆ m_refRatio

amrex::IntVect NOAHMP::m_refRatio

private

◆ m_updated

bool NOAHMP::m_updated = false

private

Referenced by Get_Update_Status().

◆ m_warned_radiation_inputs

bool NOAHMP::m_warned_radiation_inputs = false

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

Referenced by Set_LSM_Step().

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

Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP.H
Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP_Advance.cpp
Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP_Init.cpp
Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP_IO.cpp
Source/LandSurfaceModel/Noah-MP/ERF_NOAHMP_Precip.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Member Typedef Documentation

◆ FabPtr

Constructor & Destructor Documentation

◆ NOAHMP()

◆ ~NOAHMP()

Member Function Documentation

◆ advance_precip_snapshots()

◆ Advance_With_State()

◆ collect_precip_sources()

◆ Define()

◆ Get_LSM_Step()

◆ Get_Update_Status()

◆ Init() [1/3]

◆ Init() [2/3]

◆ Init() [3/3]

◆ interp_from_lev0()

◆ Lsm_Data_Ptr()

◆ Lsm_Data_Size()

◆ Lsm_DataIndex()

◆ Lsm_DataName()

◆ Lsm_Flux_Ptr()

◆ Lsm_Flux_Size()

◆ Lsm_FluxIndex()

◆ Lsm_FluxName()

◆ Lsm_Geom()

◆ Lsm_Set_Lev0_Data_Ptr()

◆ Lsm_Set_Lev0_Flux_Ptr()

◆ m_ensure_nsoil_resolved()

◆ m_precip_snapshot_name()

◆ Plot_Landfile()

◆ prepare_precip_snapshots()

◆ Read_Lsm_Restart()

◆ read_results()

◆ report_precip_diagnostics()

◆ Set_LSM_Step()

◆ soil_data_idx()

◆ stage_forcing()

◆ time_to_fire()

◆ with_land_comm()

◆ Write_Lsm_Restart()

Member Data Documentation

◆ khi_lsm

◆ lsm_fab_data

◆ lsm_fab_flux

◆ lsm_lev0_data

◆ lsm_lev0_flux

◆ LsmDataMap

◆ LsmDataName

◆ LsmFluxMap

◆ LsmFluxName

◆ m_checked_radiation_inputs

◆ m_domain_bcs_type

◆ m_dtbl

◆ m_dz_lsm

◆ m_first_advance_nstep

◆ m_geom

◆ m_geom0

◆ m_has_nc_file

◆ m_itimestep

◆ m_lev

◆ m_lsm_data_size

◆ m_lsm_flux_size

◆ m_lsm_geom

◆ m_nsoil

◆ m_nsoil_resolved

◆ m_num_soil_groups

◆ m_nz_lsm

◆ m_precip_accum_prev

◆ m_precip_accum_restored

◆ m_radiation_feeds_lsm

◆ m_radiation_model_name

◆ m_refRatio

◆ m_updated