ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
NOAHMP Class Reference

#include <ERF_NOAHMP.H>

Inheritance diagram for NOAHMP:
Collaboration diagram for NOAHMP:

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 &dt, 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 &)
 

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 = 1.0
 
amrex::Array< FabPtr, LsmData_NOAHMP::NumVarslsm_fab_data
 
amrex::Array< FabPtr, LsmFlux_NOAHMP::NumVarslsm_fab_flux
 
NoahmpIO_vector noahmpio_vect
 
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
55 {}

◆ ~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 dt,
const int &  nstep 
)
overridevirtual

Reimplemented from NullSurf.

215 {
216 
217  Box domain = m_geom.Domain();
218 
219  Print () << "Noah-MP driver started at time step: " << nstep+1 << std::endl;
220 
221  // Loop over blocks to copy forcing data to Noahmp, drive the land model,
222  // and copy data back to ERF Multifabs.
223  int idb = 0;
224  for (MFIter mfi(cons_in, false); mfi.isValid(); ++mfi, ++idb) {
225 
226  const Box& bx = mfi.tilebox();
227 
228  // Check if tile is at the lower boundary in lower z direction
229  if (bx.smallEnd(2) == domain.smallEnd(2)) {
230 
231  NoahmpIO_type* noahmpio = &noahmpio_vect[idb];
232 
233  const Array4<const Real>& U_PHY = xvel_in.const_array(mfi);
234  const Array4<const Real>& V_PHY = yvel_in.const_array(mfi);
235  const Array4<const Real>& QV_TH = cons_in.const_array(mfi);
236 
237  // Into NOAH-MP
238  const Array4<const Real>& SWDOWN = lsm_fab_data[LsmData_NOAHMP::sw_flux_dn]->const_array(mfi);
239  const Array4<const Real>& GLW = lsm_fab_data[LsmData_NOAHMP::lw_flux_dn]->const_array(mfi);
240  const Array4<const Real>& COSZEN = lsm_fab_data[LsmData_NOAHMP::cos_zenith_angle]->const_array(mfi);
241 
242  // Out of NOAH-MP
243  Array4<Real> TSK = lsm_fab_data[LsmData_NOAHMP::t_sfc]->array(mfi);
244  Array4<Real> EMISS = lsm_fab_data[LsmData_NOAHMP::sfc_emis]->array(mfi);
245  Array4<Real> ALBSFCDIR_VIS = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dir_vis]->array(mfi);
246  Array4<Real> ALBSFCDIR_NIR = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dir_nir]->array(mfi);
247  Array4<Real> ALBSFCDIF_VIS = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dif_vis]->array(mfi);
248  Array4<Real> ALBSFCDIF_NIR = lsm_fab_data[LsmData_NOAHMP::sfc_alb_dif_nir]->array(mfi);
249 
250  // NOTE: Need to expose stresses and get stresses from NOAHMP
251  Array4<Real> q_flux_arr = lsm_fab_flux[LsmFlux_NOAHMP::q_flux]->array(mfi);
252  Array4<Real> t_flux_arr = lsm_fab_flux[LsmFlux_NOAHMP::t_flux]->array(mfi);
253  //Array4<Real> tau13_arr = lsm_fab_flux[LsmFlux_NOAHMP::tau13]->array(mfi);
254  //Array4<Real> tau23_arr = lsm_fab_flux[LsmFlux_NOAHMP::tau23]->array(mfi);
255 
256  // Copy forcing data from ERF to Noahmp.
257  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int ) noexcept
258  {
259  noahmpio->U_PHY(i,1,j) = 0.5*(U_PHY(i,j,0)+U_PHY(i+1,j ,0));
260  noahmpio->V_PHY(i,1,j) = 0.5*(V_PHY(i,j,0)+V_PHY(i ,j+1,0));
261  noahmpio->T_PHY(i,1,j) = QV_TH(i,j,0,RhoTheta_comp)/QV_TH(i,j,0,Rho_comp);
262  noahmpio->QV_CURR(i,1,j) = QV_TH(i,j,0,RhoQ1_comp)/QV_TH(i,j,0,Rho_comp);
263  noahmpio->SWDOWN(i,j) = SWDOWN(i,j,0);
264  noahmpio->GLW(i,j) = GLW(i,j,0);
265  noahmpio->COSZEN(i,j) = COSZEN(i,j,0);
266  });
267 
268  // Call the noahmpio driver code. This runs the land model forcing for
269  // each object in noahmpio_vect that represent a block in the domain.
270  noahmpio->itimestep = nstep+1;
271  noahmpio->DriverMain();
272 
273  // Copy forcing data from Noahmp to ERF
274  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int ) noexcept
275  {
276  q_flux_arr(i,j,0) = noahmpio->SHBXY(i,j);
277  t_flux_arr(i,j,0) = noahmpio->EVBXY(i,j);
278  TSK(i,j,0) = noahmpio->TSK(i,j);
279  EMISS(i,j,0) = noahmpio->EMISS(i,j);
280  ALBSFCDIR_VIS(i,j,0) = noahmpio->ALBSFCDIRXY(i,1,j);
281  ALBSFCDIR_NIR(i,j,0) = noahmpio->ALBSFCDIRXY(i,2,j);
282  ALBSFCDIF_VIS(i,j,0) = noahmpio->ALBSFCDIFXY(i,1,j);
283  ALBSFCDIF_NIR(i,j,0) = noahmpio->ALBSFCDIFXY(i,2,j);
284  });
285 
286  if((nstep+1)%m_plot_int_1 == 0) {
287  noahmpio->WriteLand(nstep+1);
288  }
289  }
290  }
291  Print () << "Noah-MP driver completed" << std::endl;
292 };
#define Rho_comp
Definition: ERF_IndexDefines.H:36
#define RhoTheta_comp
Definition: ERF_IndexDefines.H:37
#define RhoQ1_comp
Definition: ERF_IndexDefines.H:42
int m_plot_int_1
Definition: ERF_NOAHMP.H:208
amrex::Array< FabPtr, LsmFlux_NOAHMP::NumVars > lsm_fab_flux
Definition: ERF_NOAHMP.H:202
NoahmpIO_vector noahmpio_vect
Definition: ERF_NOAHMP.H:205
amrex::Array< FabPtr, LsmData_NOAHMP::NumVars > lsm_fab_data
Definition: ERF_NOAHMP.H:199
amrex::Geometry m_geom
Definition: ERF_NOAHMP.H:181
@ sw_flux_dn
Definition: ERF_NOAHMP.H:32
@ sfc_emis
Definition: ERF_NOAHMP.H:26
@ sfc_alb_dir_vis
Definition: ERF_NOAHMP.H:27
@ sfc_alb_dif_nir
Definition: ERF_NOAHMP.H:30
@ lw_flux_dn
Definition: ERF_NOAHMP.H:33
@ cos_zenith_angle
Definition: ERF_NOAHMP.H:31
@ t_sfc
Definition: ERF_NOAHMP.H:25
@ sfc_alb_dir_nir
Definition: ERF_NOAHMP.H:28
@ sfc_alb_dif_vis
Definition: ERF_NOAHMP.H:29
@ t_flux
Definition: ERF_NOAHMP.H:42
@ q_flux
Definition: ERF_NOAHMP.H:41

◆ Define()

void NOAHMP::Define ( SolverChoice )
inlineoverridevirtual

Reimplemented from NullSurf.

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

◆ Init()

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

Reimplemented from NullSurf.

19 {
20 
21  m_dt = dt;
22  m_geom = geom;
23 
24  Box domain = geom.Domain();
25  khi_lsm = domain.smallEnd(2) - 1;
26 
34  LsmDataName = {"t_sfc" , "sfc_emis" ,
35  "sfc_alb_dir_vis" , "sfc_alb_dir_nir" ,
36  "sfc_alb_dif_vis" , "sfc_alb_dif_nir" ,
37  "cos_zenith_angle", "sw_flux_dn" ,
38  "lw_flux_dn" };
39 
40 
45  LsmFluxName = {"t_flux" , "q_flux" ,
46  "tau13" , "tau23" };
47 
48  ParmParse pp("erf");
49  pp.query("plot_int_1" , m_plot_int_1);
50 
51  // NOTE: All boxes in ba extend from zlo to zhi, so this transform is valid.
52  // If that were to change, the dm and new ba are no longer valid and
53  // direct copying between lsm data/flux vars cannot be done in a parfor.
54 
55  // Set 2D box array for lsm data
56  IntVect ng(0,0,0);
57  BoxArray ba = cons_in.boxArray();
58  DistributionMapping dm = cons_in.DistributionMap();
59  BoxList bl_lsm = ba.boxList();
60  for (auto& b : bl_lsm) {
61  b.setRange(2,0);
62  }
63  BoxArray ba_lsm(std::move(bl_lsm));
64 
65  // Set up lsm geometry
66  const RealBox& dom_rb = m_geom.ProbDomain();
67  const Real* dom_dx = m_geom.CellSize();
68  RealBox lsm_rb = dom_rb;
69  Real lsm_dx[AMREX_SPACEDIM] = {AMREX_D_DECL(dom_dx[0],dom_dx[1],m_dz_lsm)};
70  Real lsm_z_hi = dom_rb.lo(2);
71  Real lsm_z_lo = lsm_z_hi - Real(m_nz_lsm)*lsm_dx[2];
72  lsm_rb.setHi(2,lsm_z_hi); lsm_rb.setLo(2,lsm_z_lo);
73  m_lsm_geom.define( ba_lsm.minimalBox(), lsm_rb, m_geom.Coord(), m_geom.isPeriodic() );
74 
75  // Create the data
76  for (auto ivar = 0; ivar < LsmData_NOAHMP::NumVars; ++ivar) {
77  // State vars are CC
78  lsm_fab_data[ivar] = std::make_shared<MultiFab>(ba_lsm, dm, 1, ng);
79 
80  // NOTE: Radiation steps first so we set values
81  // to reasonable initialization for coupling
82  Real val_to_set = 0.0;
83  if (ivar == LsmData_NOAHMP::t_sfc) {
84  val_to_set = 300.0;
85  } else if (ivar == LsmData_NOAHMP::sfc_emis) {
86  val_to_set = 0.9;
87  } else if ( (ivar>=LsmData_NOAHMP::sfc_alb_dir_vis) &&
89  val_to_set = 0.06;
90  } else {
91  val_to_set = 0.0;
92  }
93  lsm_fab_data[ivar]->setVal(val_to_set);
94  }
95 
96  // Create the fluxes
97  for (auto ivar = 0; ivar < LsmFlux_NOAHMP::NumVars; ++ivar) {
98  // NOTE: Fluxes are CC with ghost cells for averaging
99  lsm_fab_flux[ivar] = std::make_shared<MultiFab>(ba_lsm, dm, 1, IntVect(1,1,0));
100  lsm_fab_flux[ivar]->setVal(0.);
101  }
102 
103  Print() << "Noah-MP initialization started" << std::endl;
104 
105  // Set noahmpio_vect to the size of local blocks (boxes)
106  noahmpio_vect.resize(cons_in.local_size(), lev);
107 
108  // Iterate over multifab and noahmpio object together. Multifabs is
109  // used to extract size of blocks and set bounds for noahmpio objects.
110  int idb = 0;
111  for (MFIter mfi(cons_in, false); mfi.isValid(); ++mfi, ++idb) {
112 
113  // Get bounds for the tile
114  const Box& bx = mfi.tilebox();
115 
116  // Check if tile is at the lower boundary in lower z direction
117  if (bx.smallEnd(2) == domain.smallEnd(2)) {
118 
119  // Get reference to the noahmpio object
120  NoahmpIO_type* noahmpio = &noahmpio_vect[idb];
121 
122  // Pass idb context to noahmpio
123  noahmpio->blkid = idb;
124 
125  // Pass level context to noahmpio
126  noahmpio->level = lev;
127 
128  // Initialize scalar values
129  noahmpio->ScalarInitDefault();
130 
131  // Store the rank of process for noahmp
132  noahmpio->rank = ParallelDescriptor::MyProc();
133 
134  // Store parallel communicator for noahmp
135  noahmpio->comm = MPI_Comm_c2f(ParallelDescriptor::Communicator());
136 
137  // Read namelist.erf file. This file contains
138  // noahmpio specific parameters and is read by
139  // the Fortran side of the implementation.
140  noahmpio->ReadNamelist();
141 
142  // Read the headers from the NetCDF land file. This is also
143  // implemented on the Fortran side of things currently.
144  noahmpio->ReadLandHeader();
145 
146  // Extract tile bounds and set them to their corresponding
147  // noahmpio variables. At present we will set all the variables
148  // corresponding to domain, memory, and tile to the same bounds.
149  // This will be changed later if we want to do special memory
150  // management for expensive use cases.
151  noahmpio->xstart = bx.smallEnd(0);
152  noahmpio->xend = bx.bigEnd(0);
153  noahmpio->ystart = bx.smallEnd(1);
154  noahmpio->yend = bx.bigEnd(1);
155 
156  // Domain bounds
157  noahmpio->ids = noahmpio->xstart;
158  noahmpio->ide = noahmpio->xend;
159  noahmpio->jds = noahmpio->ystart;
160  noahmpio->jde = noahmpio->yend;
161  noahmpio->kds = 1;
162  noahmpio->kde = 2;
163 
164  // Tile bounds
165  noahmpio->its = noahmpio->xstart;
166  noahmpio->ite = noahmpio->xend;
167  noahmpio->jts = noahmpio->ystart;
168  noahmpio->jte = noahmpio->yend;
169  noahmpio->kts = 1;
170  noahmpio->kte = 2;
171 
172  // Memory bounds
173  noahmpio->ims = noahmpio->xstart;
174  noahmpio->ime = noahmpio->xend;
175  noahmpio->jms = noahmpio->ystart;
176  noahmpio->jme = noahmpio->yend;
177  noahmpio->kms = 1;
178  noahmpio->kme = 2;
179 
180  // This procedure allocates memory in Fortran for IO variables
181  // using bounds that are set above and read from namelist.erf
182  // and headers from the NetCDF land file
183  noahmpio->VarInitDefault();
184 
185  // This reads NoahmpTable.TBL file which is another input file
186  // we need to set some IO variables.
187  noahmpio->ReadTable();
188 
189  // Read and initialize data from the NetCDF land file.
190  noahmpio->ReadLandMain();
191 
192  // Compute additional initial values that were not supplied
193  // by the NetCDF land file.
194  noahmpio->InitMain();
195 
196  // Write initial plotfile for land with the tag 0
197  Print() << "Noah-MP writing lnd.nc file at lev: " << lev << std::endl;
198  noahmpio->WriteLand(0);
199  }
200  }
201 
202  Print() << "Noah-MP initialization completed" << std::endl;
203 
204 };
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real pp(amrex::Real y)
Definition: ERF_MicrophysicsUtils.H:230
amrex::Real Real
Definition: ERF_ShocInterface.H:19
int khi_lsm
Definition: ERF_NOAHMP.H:190
amrex::Vector< std::string > LsmDataName
Definition: ERF_NOAHMP.H:175
amrex::Vector< int > LsmDataMap
Definition: ERF_NOAHMP.H:169
int m_lsm_data_size
Definition: ERF_NOAHMP.H:163
amrex::Geometry m_lsm_geom
Definition: ERF_NOAHMP.H:184
int m_nz_lsm
Definition: ERF_NOAHMP.H:193
int m_lsm_flux_size
Definition: ERF_NOAHMP.H:166
amrex::Vector< int > LsmFluxMap
Definition: ERF_NOAHMP.H:172
amrex::Vector< std::string > LsmFluxName
Definition: ERF_NOAHMP.H:178
amrex::Real m_dz_lsm
Definition: ERF_NOAHMP.H:196
amrex::Real m_dt
Definition: ERF_NOAHMP.H:187
@ NumVars
Definition: ERF_NOAHMP.H:34
@ tau13
Definition: ERF_NOAHMP.H:43
@ NumVars
Definition: ERF_NOAHMP.H:45
@ tau23
Definition: ERF_NOAHMP.H:44
@ ng
Definition: ERF_Morrison.H:48
Here is the call graph for this function:

◆ Lsm_Data_Ptr()

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

Reimplemented from NullSurf.

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

◆ Lsm_Data_Size()

int NOAHMP::Lsm_Data_Size ( )
inlineoverridevirtual

Reimplemented from NullSurf.

109 { return NOAHMP::m_lsm_data_size; }

◆ Lsm_DataIndex()

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

Reimplemented from NullSurf.

127  {
128  int varIdx = -1;
129  std::string lc_varname = amrex::toLower(varname);
130  for (int idx(0); idx<LsmData_NOAHMP::NumVars; ++idx) {
131  if (lc_varname == amrex::toLower(LsmDataName[idx])) {
132  varIdx = idx;
133  }
134  }
135  return varIdx;
136  }

◆ Lsm_DataName()

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

Reimplemented from NullSurf.

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

◆ Lsm_Flux_Ptr()

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

Reimplemented from NullSurf.

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

◆ Lsm_Flux_Size()

int NOAHMP::Lsm_Flux_Size ( )
inlineoverridevirtual

Reimplemented from NullSurf.

113 { return NOAHMP::m_lsm_flux_size; }

◆ Lsm_FluxIndex()

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

Reimplemented from NullSurf.

150  {
151  int varIdx = -1;
152  std::string lc_varname = amrex::toLower(varname);
153  for (int idx(0); idx<LsmFlux_NOAHMP::NumVars; ++idx) {
154  if (lc_varname == amrex::toLower(LsmFluxName[idx])) {
155  varIdx = idx;
156  }
157  }
158  return varIdx;
159  }

◆ Lsm_FluxName()

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

Reimplemented from NullSurf.

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

◆ Lsm_Geom()

amrex::Geometry NOAHMP::Lsm_Geom ( )
inlineoverridevirtual

Reimplemented from NullSurf.

105 { return m_lsm_geom; }

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 = 1.0
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

◆ noahmpio_vect

NoahmpIO_vector NOAHMP::noahmpio_vect
private

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