ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
ERF_SurfaceLayer.H
Go to the documentation of this file.
1 #ifndef ERF_SURFACELAYER_H
2 #define ERF_SURFACELAYER_H
3 
4 #include "AMReX_Geometry.H"
5 #include "AMReX_ParmParse.H"
6 #include "AMReX_FArrayBox.H"
7 #include "AMReX_MultiFab.H"
8 #include "AMReX_iMultiFab.H"
9 #include "AMReX_MFInterpolater.H"
10 
11 #include "ERF_IndexDefines.H"
12 #include "ERF_Constants.H"
13 #include "ERF_MOSTAverage.H"
14 #include "ERF_MOSTStress.H"
15 #include "ERF_TerrainMetrics.H"
16 #include "ERF_PBLHeight.H"
17 #include "ERF_MicrophysicsUtils.H"
18 
19 /** Abstraction layer for different surface layer schemes (e.g. MOST, Cd)
20  *
21  * van der Laan, P., Kelly, M. C., & Sørensen, N. N. (2017). A new k-epsilon
22  * model consistent with Monin-Obukhov similarity theory. Wind Energy,
23  * 20(3), 479–489. https://doi.org/10.1002/we.2017
24  *
25  * Consistent with Dyer (1974) formulation from page 57, Chapter 2, Modeling
26  * the vertical ABL structure in Modelling of Atmospheric Flow Fields,
27  * Demetri P Lalas and Corrado F Ratto, January 1996,
28  * https://doi.org/10.1142/2975.
29  */
31 {
32 
33 public:
34  // Constructor
35  explicit SurfaceLayer (const amrex::Vector<amrex::Geometry>& geom,
36  bool& use_rot_surface_flux,
37  std::string a_pp_prefix,
38  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& Qv_prim,
39  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& z_phys_nd,
40  const TerrainType& a_terrain_type,
41  amrex::Real bdy_time_interval = 0.0)
42  : m_geom(geom),
43  m_rotate(use_rot_surface_flux),
44  m_bdy_time_interval(bdy_time_interval),
45  m_ma(geom, (z_phys_nd[0] != nullptr), a_pp_prefix, a_terrain_type)
46  {
47  // We have a moisture model if Qv_prim is a valid pointer
48  use_moisture = (Qv_prim[0].get());
49 
50  // Get roughness
51  amrex::ParmParse pp("erf");
52  pp.query("most.z0", z0_const);
53 
54  // Specify how to compute the flux
55  if (use_rot_surface_flux) {
57  } else {
58  std::string flux_string_in;
59  std::string flux_string{"moeng"};
60  auto read_flux = pp.query("surface_layer.flux_type", flux_string_in);
61  if (read_flux) {
62  flux_string = amrex::toLower(flux_string_in);
63  }
64  if (flux_string == "donelan") {
66  } else if (flux_string == "moeng") {
68  } else if (flux_string == "custom") {
70  } else {
71  amrex::Abort("Undefined MOST flux type!");
72  }
73  }
74 
75  // Include w* to handle free convection (Beljaars 1995, QJRMS)
76  pp.query("most.include_wstar", m_include_wstar);
77 
78  std::string pblh_string_in;
79  std::string pblh_string{"none"};
80  auto read_pblh = pp.query("most.pblh_calc", pblh_string_in);
81  if (read_pblh) {
82  pblh_string = amrex::toLower(pblh_string_in);
83  }
84  if (pblh_string == "none") {
86  } else if (pblh_string == "mynn25") {
88  } else if (pblh_string == "mynnedmf") {
90  } else if (pblh_string == "ysu") {
92  } else if (pblh_string == "mrf") {
94  } else {
95  amrex::Abort("Undefined PBLH calc type!");
96  }
97 
98  // Get surface temperature
99  auto erf_st = pp.query("most.surf_temp", surf_temp);
100  if (erf_st) { default_land_surf_temp = surf_temp; }
101 
102  // Get surface moisture
103  bool erf_sq = false;
104  if (use_moisture) { erf_sq = pp.query("most.surf_moist", surf_moist); }
105  if (erf_sq) { default_land_surf_moist = surf_moist; }
106 
107  // Custom type user must specify the fluxes
111  pp.query("most.ustar", custom_ustar);
112  pp.query("most.tstar", custom_tstar);
113  pp.query("most.qstar", custom_qstar);
114  pp.query("most.rhosurf", custom_rhosurf);
115  if (custom_qstar != 0) {
116  AMREX_ASSERT_WITH_MESSAGE(use_moisture,
117  "Specified custom MOST qv flux without moisture model!");
118  }
119  amrex::Print() << "Using specified ustar, tstar, qstar for MOST = "
120  << custom_ustar << " " << custom_tstar << " "
121  << custom_qstar << std::endl;
122 
123  // Specify surface temperature/moisture or surface flux
124  } else {
125  if (erf_st) {
127  pp.query("most.surf_heating_rate", surf_heating_rate); // [K/h]
128  surf_heating_rate = surf_heating_rate / 3600.0; // [K/s]
129  if (pp.query("most.surf_temp_flux", surf_temp_flux)) {
130  amrex::Abort("Can only specify one of surf_temp_flux or surf_heating_rate");
131  }
132  } else {
133  pp.query("most.surf_temp_flux", surf_temp_flux);
134 
135  if (pp.query("most.surf_heating_rate", surf_heating_rate)) {
136  amrex::Abort("Can only specify one of surf_temp_flux or surf_heating_rate");
137  }
138  if (std::abs(surf_temp_flux) >
141  } else {
143  }
144 
145  }
146 
147  if (erf_sq) {
149  } else {
150  pp.query("most.surf_moist_flux", surf_moist_flux);
151  if (std::abs(surf_moist_flux) >
154  } else {
156  }
157  }
158  }
159 
160  // Make sure the inputs file doesn't try to use most.roughness_type
161  std::string bogus_input;
162  if (pp.query("most.roughness_type", bogus_input) > 0) {
163  amrex::Abort("most.roughness_type is deprecated; use "
164  "most.roughness_type_land and/or most.roughness_type_sea");
165  }
166 
167  // Specify how to compute the surface flux over land (if there is any)
168  std::string rough_land_string_in;
169  std::string rough_land_string{"constant"};
170  auto read_rough_land =
171  pp.query("most.roughness_type_land", rough_land_string_in);
172  if (read_rough_land) {
173  rough_land_string = amrex::toLower(rough_land_string_in);
174  }
175  if (rough_land_string == "constant") {
177  } else {
178  amrex::Abort("Undefined MOST roughness type for land!");
179  }
180 
181  // Specify how to compute the surface flux over sea (if there is any)
182  std::string rough_sea_string_in;
183  std::string rough_sea_string{"charnock"};
184  auto read_rough_sea = pp.query("most.roughness_type_sea", rough_sea_string_in);
185  if (read_rough_sea) {
186  rough_sea_string = amrex::toLower(rough_sea_string_in);
187  }
188  if (rough_sea_string == "charnock") {
190  pp.query("most.charnock_constant", cnk_a);
191  pp.query("most.charnock_viscosity", cnk_visc);
192  if (cnk_a > 0) {
193  amrex::Print() << "If there is water, Charnock relation with C_a="
194  << cnk_a << (cnk_visc ? " and viscosity" : "")
195  << " will be used" << std::endl;
196  } else {
197  amrex::Print() << "If there is water, Charnock relation with variable "
198  "Charnock parameter (COARE3.0)"
199  << (cnk_visc ? " and viscosity" : "") << " will be used"
200  << std::endl;
201  }
202  } else if (rough_sea_string == "coare3.0") {
204  amrex::Print() << "If there is water, Charnock relation with variable "
205  "Charnock parameter (COARE3.0)"
206  << (cnk_visc ? " and viscosity" : "") << " will be used"
207  << std::endl;
208  cnk_a = -1;
209  } else if (rough_sea_string == "donelan") {
211  } else if (rough_sea_string == "modified_charnock") {
213  pp.query("most.modified_charnock_depth", depth);
214  } else if (rough_sea_string == "wave_coupled") {
216  } else if (rough_sea_string == "constant") {
218  } else {
219  amrex::Abort("Undefined MOST roughness type for sea!");
220  }
221  } // constructor
222 
223  void make_SurfaceLayer_at_level (const int& lev,
224  int nlevs,
225  const amrex::Vector<amrex::MultiFab*>& mfv,
226  std::unique_ptr<amrex::MultiFab>& Theta_prim,
227  std::unique_ptr<amrex::MultiFab>& Qv_prim,
228  std::unique_ptr<amrex::MultiFab>& Qr_prim,
229  std::unique_ptr<amrex::MultiFab>& z_phys_nd,
230  amrex::MultiFab* Hwave,
231  amrex::MultiFab* Lwave,
232  amrex::MultiFab* eddyDiffs,
233  amrex::Vector<amrex::MultiFab*> lsm_data,
234  amrex::Vector<amrex::MultiFab*> lsm_flux,
235  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& sst_lev,
236  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& tsk_lev,
237  amrex::Vector<std::unique_ptr<amrex::iMultiFab>>& lmask_lev)
238  {
239  // Update MOST Average
241  Theta_prim, Qv_prim, Qr_prim,
242  z_phys_nd);
243 
244  // Get CC vars
245  amrex::MultiFab& mf = *(mfv[0]);
246 
247  amrex::ParmParse pp("erf");
248 
249  // Do we have a time-varying surface roughness that needs to be saved?
250  if (lev == 0) {
251  const int nghost = 0; // ghost cells not included
252  int lmask_min = lmask_min_reduce(*lmask_lev[0].get(), nghost);
253  amrex::ParallelDescriptor::ReduceIntMin(lmask_min);
254 
255  m_var_z0 = (lmask_min < 1) & (rough_type_sea != RoughCalcType::CONSTANT);
256  if (m_var_z0) {
257  std::string rough_sea_string{"charnock"};
258  pp.query("most.roughness_type_sea", rough_sea_string);
259  amrex::Print() << "Variable sea roughness (type " << rough_sea_string
260  << ")" << std::endl;
261  }
262  }
263 
264  if ((lev == 0) || (lev > nlevs - 1)) {
265  m_Hwave_lev.resize(nlevs);
266  m_Lwave_lev.resize(nlevs);
267  m_eddyDiffs_lev.resize(nlevs);
268 
269  m_lsm_data_lev.resize(nlevs);
270  m_lsm_flux_lev.resize(nlevs);
271 
272  m_sst_lev.resize(nlevs);
273  m_tsk_lev.resize(nlevs);
274  m_lmask_lev.resize(nlevs);
275 
276  // Size the MOST params for all levels
277  z_0.resize(nlevs);
278  u_star.resize(nlevs);
279  w_star.resize(nlevs);
280  t_star.resize(nlevs);
281  q_star.resize(nlevs);
282  t_surf.resize(nlevs);
283  q_surf.resize(nlevs);
284  olen.resize(nlevs);
285  pblh.resize(nlevs);
286  }
287 
288  // Get pointers to SST,TSK and LANDMASK data
289  int nt_tot_sst = sst_lev.size();
290  m_sst_lev[lev].resize(nt_tot_sst);
291  for (int nt(0); nt < nt_tot_sst; ++nt) {
292  m_sst_lev[lev][nt] = sst_lev[nt].get();
293  }
294  int nt_tot_tsk = static_cast<int>(tsk_lev.size());
295  m_tsk_lev[lev].resize(nt_tot_tsk);
296  for (int nt(0); nt < nt_tot_tsk; ++nt) {
297  m_tsk_lev[lev][nt] = tsk_lev[nt].get();
298  }
299  int nt_tot_lmask = static_cast<int>(lmask_lev.size());
300  m_lmask_lev[lev].resize(nt_tot_lmask);
301  for (int nt(0); nt < nt_tot_lmask; ++nt) {
302  m_lmask_lev[lev][nt] = lmask_lev[nt].get();
303  }
304 
305  // Get pointers to wave data
306  m_Hwave_lev[lev] = Hwave;
307  m_Lwave_lev[lev] = Lwave;
308  m_eddyDiffs_lev[lev] = eddyDiffs;
309 
310  // Get pointers to LSM data and Fluxes
311  int nvar = static_cast<int>(lsm_data.size());
312  m_lsm_data_lev[lev].resize(nvar);
313  m_lsm_flux_lev[lev].resize(nvar);
314  for (int n(0); n < nvar; ++n) {
315  m_lsm_data_lev[lev][n] = lsm_data[n];
316  m_lsm_flux_lev[lev][n] = lsm_flux[n];
317  }
318 
319  // Check if there is a user-specified roughness file to be read
320  std::string fname;
321  bool read_z0 = false;
322  if ( (flux_type == FluxCalcType::MOENG) ||
324  read_z0 = pp.query("most.roughness_file_name", fname);
325  }
326 
327  // Attributes for MFs and FABs
328  //--------------------------------------------------------
329  // Create a 2D ba, dm, & ghost cells
330  amrex::BoxArray ba = mf.boxArray();
331  amrex::BoxList bl2d = ba.boxList();
332  for (auto& b : bl2d) {
333  b.setRange(2, 0);
334  }
335  amrex::BoxArray ba2d(std::move(bl2d));
336  const amrex::DistributionMapping& dm = mf.DistributionMap();
337  const int ncomp = 1;
338  amrex::IntVect ng = mf.nGrowVect();
339  ng[2] = 0;
340 
341  // Z0 heights FAB
342  //--------------------------------------------------------
343  z_0[lev].define(ba2d, dm, ncomp, ng);
344  z_0[lev].setVal(z0_const);
345  if (read_z0) {
346  read_custom_roughness(lev, fname);
347  }
348 
349  // 2D MFs for U*, T*, T_surf
350  //--------------------------------------------------------
351  u_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
352  u_star[lev]->setVal(1.E34);
353 
354  w_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
355  w_star[lev]->setVal(1.E34);
356 
357  t_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
358  t_star[lev]->setVal(0.0); // default to neutral
359 
360  q_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
361  q_star[lev]->setVal(0.0); // default to dry
362 
363  olen[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
364  olen[lev]->setVal(1.E34);
365 
366  pblh[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
367  pblh[lev]->setVal(1.E34);
368 
369  t_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
370  t_surf[lev]->setVal(default_land_surf_temp);
371 
372  q_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
373  q_surf[lev]->setVal(default_land_surf_moist);
374 
375  // TODO: Do we want lsm_data to have theta at 0 index always?
376  // Do we want an external enum struct for indexing?
377  if (m_sst_lev[lev][0] || m_tsk_lev[lev][0] || m_lsm_data_lev[lev][0]) {
378  // Valid SST, TSK or LSM data; t_surf set before computing fluxes (avoids
379  // extended lambda capture) Note that land temp will be set from m_tsk_lev
380  // while sea temp will be set from m_sst_lev
382  }
383 
384 
385  }
386 
387  void
388  update_fluxes (const int& lev,
389  const amrex::Real& time,
390  const amrex::MultiFab& cons_in,
391  const std::unique_ptr<amrex::MultiFab>& z_phys_nd,
392  int max_iters = 100);
393 
394  template <typename FluxIter>
395  void compute_fluxes (const int& lev,
396  const int& max_iters,
397  const FluxIter& most_flux,
398  bool is_land);
399 
400  void impose_SurfaceLayer_bcs (const int& lev,
401  amrex::Vector<const amrex::MultiFab*> mfs,
402  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& Tau_lev,
403  amrex::MultiFab* xheat_flux,
404  amrex::MultiFab* yheat_flux,
405  amrex::MultiFab* zheat_flux,
406  amrex::MultiFab* xqv_flux,
407  amrex::MultiFab* yqv_flux,
408  amrex::MultiFab* zqv_flux,
409  const amrex::MultiFab* z_phys);
410 
411  template <typename FluxCalc>
412  void compute_SurfaceLayer_bcs (const int& lev,
413  amrex::Vector<const amrex::MultiFab*> mfs,
414  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& Tau_lev,
415  amrex::MultiFab* xheat_flux,
416  amrex::MultiFab* yheat_flux,
417  amrex::MultiFab* zheat_flux,
418  amrex::MultiFab* xqv_flux,
419  amrex::MultiFab* yqv_flux,
420  amrex::MultiFab* zqv_flux,
421  const amrex::MultiFab* z_phys,
422  const FluxCalc& flux_comp);
423 
424  void fill_tsurf_with_sst_and_tsk (const int& lev,
425  const amrex::Real& time);
426 
427  void fill_qsurf_with_qsat (const int& lev,
428  const amrex::MultiFab& cons_in,
429  const std::unique_ptr<amrex::MultiFab>& z_phys_nd);
430 
431  void get_lsm_tsurf (const int& lev);
432 
433  /* wrapper around compute_pblh */
434  void update_pblh (const int& lev,
435  amrex::Vector<amrex::Vector<amrex::MultiFab>>& vars,
436  amrex::MultiFab* z_phys_cc,
437  const MoistureComponentIndices& moisture_indices);
438 
439  template <typename PBLHeightEstimator>
440  void compute_pblh (const int& lev,
441  amrex::Vector<amrex::Vector<amrex::MultiFab>>& vars,
442  amrex::MultiFab* z_phys_cc,
443  const PBLHeightEstimator& est,
444  const MoistureComponentIndices& moisture_indice);
445 
446  void read_custom_roughness (const int& lev,
447  const std::string& fname);
448 
449  void update_surf_temp (const amrex::Real& time)
450  {
451  if (surf_heating_rate != 0) {
452  int nlevs = static_cast<int>(m_geom.size());
453  for (int lev = 0; lev < nlevs; lev++) {
454  t_surf[lev]->setVal(surf_temp + surf_heating_rate * time);
455  amrex::Print() << "Surface temp at t=" << time << ": "
456  << surf_temp + surf_heating_rate * time << std::endl;
457  }
458  }
459  }
460 
461  void update_mac_ptrs (const int& lev,
462  amrex::Vector<amrex::Vector<amrex::MultiFab>>& vars_old,
463  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& Theta_prim,
464  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& Qv_prim,
465  amrex::Vector<std::unique_ptr<amrex::MultiFab>>& Qr_prim)
466  {
467  m_ma.update_field_ptrs(lev, vars_old, Theta_prim, Qv_prim, Qr_prim);
468  }
469 
470  amrex::MultiFab* get_u_star (const int& lev) { return u_star[lev].get(); }
471 
472  amrex::MultiFab* get_w_star (const int& lev) { return w_star[lev].get(); }
473 
474  amrex::MultiFab* get_t_star (const int& lev) { return t_star[lev].get(); }
475 
476  amrex::MultiFab* get_q_star (const int& lev) { return q_star[lev].get(); }
477 
478  amrex::MultiFab* get_olen (const int& lev) { return olen[lev].get(); }
479 
480  amrex::MultiFab* get_pblh (const int& lev) { return pblh[lev].get(); }
481 
482  const amrex::MultiFab* get_mac_avg (const int& lev, int comp)
483  {
484  return m_ma.get_average(lev, comp);
485  }
486 
487  amrex::MultiFab* get_t_surf (const int& lev) { return t_surf[lev].get(); }
488 
489  amrex::MultiFab* get_q_surf (const int& lev) { return q_surf[lev].get(); }
490 
492 
493  amrex::MultiFab* get_z0 (const int& lev) { return &z_0[lev]; }
494 
496 
497  amrex::iMultiFab* get_lmask (const int& lev) { return m_lmask_lev[lev][0]; }
498 
499  int lmask_min_reduce (amrex::iMultiFab& lmask,
500  const int& nghost)
501  {
502  int lmask_min = amrex::ReduceMin(lmask, nghost, [=] AMREX_GPU_HOST_DEVICE(
503  amrex::Box const& bx, amrex::Array4<int const> const& lm_arr) -> int
504  {
505  int locmin = std::numeric_limits<int>::max();
506  const auto lo = lbound(bx);
507  const auto hi = ubound(bx);
508  for (int j = lo.y; j <= hi.y; ++j) {
509  for (int i = lo.x; i <= hi.x; ++i) {
510  locmin = std::min(locmin, lm_arr(i, j, 0));
511  }
512  }
513  return locmin;
514  });
515 
516  return lmask_min;
517  }
518 
519  enum struct FluxCalcType {
520  MOENG = 0, ///< Moeng functional form
521  DONELAN, ///< Donelan functional form
522  CUSTOM, ///< Custom constant flux functional form
523  ROTATE ///< Terrain rotation flux functional form
524  };
525 
526  enum struct ThetaCalcType {
527  ADIABATIC = 0,
528  HEAT_FLUX, ///< Heat-flux specified
529  SURFACE_TEMPERATURE ///< Surface temperature specified
530  };
531 
532  enum struct MoistCalcType {
533  ADIABATIC = 0,
534  MOISTURE_FLUX, ///< Qv-flux specified
535  SURFACE_MOISTURE ///< Surface Qv specified
536  };
537 
538  enum struct RoughCalcType {
539  CONSTANT = 0, ///< Constant z0
540  CHARNOCK,
542  DONELAN,
544  };
545 
546  enum struct PBLHeightCalcType { None, MYNN25, YSU, MRF };
547 
554 
555 private:
556  // Set in constructor
557  amrex::Vector<amrex::Geometry> m_geom;
558  bool m_rotate = false;
560 
561  bool m_include_wstar = false;
573  amrex::Real custom_rhosurf{0}; // use specified value instead of rho from first cell
574  bool specified_rho_surf{false};
576  bool cnk_visc{false};
578  amrex::Vector<amrex::MultiFab> z_0;
579  bool m_var_z0{false};
580 
582 
584  amrex::Vector<std::unique_ptr<amrex::MultiFab>> u_star;
585  amrex::Vector<std::unique_ptr<amrex::MultiFab>> w_star;
586  amrex::Vector<std::unique_ptr<amrex::MultiFab>> t_star;
587  amrex::Vector<std::unique_ptr<amrex::MultiFab>> q_star;
588  amrex::Vector<std::unique_ptr<amrex::MultiFab>> olen;
589  amrex::Vector<std::unique_ptr<amrex::MultiFab>> pblh;
590  amrex::Vector<std::unique_ptr<amrex::MultiFab>> t_surf;
591  amrex::Vector<std::unique_ptr<amrex::MultiFab>> q_surf;
592 
593  amrex::Vector<amrex::Vector<amrex::MultiFab*>> m_sst_lev;
594  amrex::Vector<amrex::Vector<amrex::MultiFab*>> m_tsk_lev;
595  amrex::Vector<amrex::Vector<amrex::iMultiFab*>> m_lmask_lev;
596  amrex::Vector<amrex::Vector<amrex::MultiFab*>> m_lsm_data_lev;
597  amrex::Vector<amrex::Vector<amrex::MultiFab*>> m_lsm_flux_lev;
598  amrex::Vector<amrex::MultiFab*> m_Hwave_lev;
599  amrex::Vector<amrex::MultiFab*> m_Lwave_lev;
600  amrex::Vector<amrex::MultiFab*> m_eddyDiffs_lev;
601 };
602 
603 #endif /* SURFACELAYER_H */
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:16
Definition: ERF_MOSTAverage.H:14
amrex::Real get_zref() const
Definition: ERF_MOSTAverage.H:104
const amrex::MultiFab * get_average(const int &lev, const int &comp) const
Definition: ERF_MOSTAverage.H:101
void update_field_ptrs(const int &lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars_old, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Theta_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qv_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qr_prim)
Definition: ERF_MOSTAverage.cpp:246
void make_MOSTAverage_at_level(const int &lev, const amrex::Vector< amrex::MultiFab * > &vars_old, std::unique_ptr< amrex::MultiFab > &Theta_prim, std::unique_ptr< amrex::MultiFab > &Qv_prim, std::unique_ptr< amrex::MultiFab > &Qr_prim, std::unique_ptr< amrex::MultiFab > &z_phys_nd)
Definition: ERF_MOSTAverage.cpp:70
Definition: ERF_SurfaceLayer.H:31
ThetaCalcType theta_type
Definition: ERF_SurfaceLayer.H:549
int lmask_min_reduce(amrex::iMultiFab &lmask, const int &nghost)
Definition: ERF_SurfaceLayer.H:499
bool m_include_wstar
Definition: ERF_SurfaceLayer.H:561
bool specified_rho_surf
Definition: ERF_SurfaceLayer.H:574
bool m_rotate
Definition: ERF_SurfaceLayer.H:558
PBLHeightCalcType pblh_type
Definition: ERF_SurfaceLayer.H:553
amrex::Vector< amrex::Vector< amrex::iMultiFab * > > m_lmask_lev
Definition: ERF_SurfaceLayer.H:595
amrex::iMultiFab * get_lmask(const int &lev)
Definition: ERF_SurfaceLayer.H:497
bool use_moisture
Definition: ERF_SurfaceLayer.H:581
amrex::MultiFab * get_q_surf(const int &lev)
Definition: ERF_SurfaceLayer.H:489
amrex::MultiFab * get_w_star(const int &lev)
Definition: ERF_SurfaceLayer.H:472
void update_surf_temp(const amrex::Real &time)
Definition: ERF_SurfaceLayer.H:449
RoughCalcType rough_type_land
Definition: ERF_SurfaceLayer.H:551
void update_pblh(const int &lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars, amrex::MultiFab *z_phys_cc, const MoistureComponentIndices &moisture_indices)
Definition: ERF_SurfaceLayer.cpp:609
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_surf
Definition: ERF_SurfaceLayer.H:590
amrex::Real z0_const
Definition: ERF_SurfaceLayer.H:562
amrex::Real cnk_a
Definition: ERF_SurfaceLayer.H:575
amrex::Real surf_temp
Definition: ERF_SurfaceLayer.H:564
void update_mac_ptrs(const int &lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars_old, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Theta_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qv_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qr_prim)
Definition: ERF_SurfaceLayer.H:461
void make_SurfaceLayer_at_level(const int &lev, int nlevs, const amrex::Vector< amrex::MultiFab * > &mfv, std::unique_ptr< amrex::MultiFab > &Theta_prim, std::unique_ptr< amrex::MultiFab > &Qv_prim, std::unique_ptr< amrex::MultiFab > &Qr_prim, std::unique_ptr< amrex::MultiFab > &z_phys_nd, amrex::MultiFab *Hwave, amrex::MultiFab *Lwave, amrex::MultiFab *eddyDiffs, amrex::Vector< amrex::MultiFab * > lsm_data, amrex::Vector< amrex::MultiFab * > lsm_flux, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &sst_lev, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &tsk_lev, amrex::Vector< std::unique_ptr< amrex::iMultiFab >> &lmask_lev)
Definition: ERF_SurfaceLayer.H:223
void compute_pblh(const int &lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars, amrex::MultiFab *z_phys_cc, const PBLHeightEstimator &est, const MoistureComponentIndices &moisture_indice)
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_star
Definition: ERF_SurfaceLayer.H:587
amrex::Vector< amrex::MultiFab * > m_Lwave_lev
Definition: ERF_SurfaceLayer.H:599
void get_lsm_tsurf(const int &lev)
Definition: ERF_SurfaceLayer.cpp:576
void fill_qsurf_with_qsat(const int &lev, const amrex::MultiFab &cons_in, const std::unique_ptr< amrex::MultiFab > &z_phys_nd)
Definition: ERF_SurfaceLayer.cpp:536
amrex::MultiFab * get_olen(const int &lev)
Definition: ERF_SurfaceLayer.H:478
amrex::Vector< amrex::MultiFab > z_0
Definition: ERF_SurfaceLayer.H:578
amrex::Real surf_moist_flux
Definition: ERF_SurfaceLayer.H:569
void compute_SurfaceLayer_bcs(const int &lev, amrex::Vector< const amrex::MultiFab * > mfs, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Tau_lev, amrex::MultiFab *xheat_flux, amrex::MultiFab *yheat_flux, amrex::MultiFab *zheat_flux, amrex::MultiFab *xqv_flux, amrex::MultiFab *yqv_flux, amrex::MultiFab *zqv_flux, const amrex::MultiFab *z_phys, const FluxCalc &flux_comp)
RoughCalcType rough_type_sea
Definition: ERF_SurfaceLayer.H:552
amrex::Real surf_moist
Definition: ERF_SurfaceLayer.H:568
amrex::Vector< std::unique_ptr< amrex::MultiFab > > w_star
Definition: ERF_SurfaceLayer.H:585
amrex::MultiFab * get_u_star(const int &lev)
Definition: ERF_SurfaceLayer.H:470
amrex::Real m_bdy_time_interval
Definition: ERF_SurfaceLayer.H:559
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_data_lev
Definition: ERF_SurfaceLayer.H:596
amrex::Real custom_qstar
Definition: ERF_SurfaceLayer.H:572
amrex::Vector< std::unique_ptr< amrex::MultiFab > > u_star
Definition: ERF_SurfaceLayer.H:584
amrex::Real custom_rhosurf
Definition: ERF_SurfaceLayer.H:573
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_surf
Definition: ERF_SurfaceLayer.H:591
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_sst_lev
Definition: ERF_SurfaceLayer.H:593
FluxCalcType
Definition: ERF_SurfaceLayer.H:519
@ MOENG
Moeng functional form.
@ CUSTOM
Custom constant flux functional form.
@ ROTATE
Terrain rotation flux functional form.
@ DONELAN
Donelan functional form.
MoistCalcType
Definition: ERF_SurfaceLayer.H:532
@ SURFACE_MOISTURE
Surface Qv specified.
@ MOISTURE_FLUX
Qv-flux specified.
amrex::Real depth
Definition: ERF_SurfaceLayer.H:577
amrex::Vector< amrex::MultiFab * > m_Hwave_lev
Definition: ERF_SurfaceLayer.H:598
amrex::Real default_land_surf_moist
Definition: ERF_SurfaceLayer.H:567
bool m_var_z0
Definition: ERF_SurfaceLayer.H:579
amrex::MultiFab * get_t_star(const int &lev)
Definition: ERF_SurfaceLayer.H:474
bool have_variable_sea_roughness()
Definition: ERF_SurfaceLayer.H:495
void compute_fluxes(const int &lev, const int &max_iters, const FluxIter &most_flux, bool is_land)
Definition: ERF_SurfaceLayer.cpp:190
amrex::MultiFab * get_q_star(const int &lev)
Definition: ERF_SurfaceLayer.H:476
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_flux_lev
Definition: ERF_SurfaceLayer.H:597
PBLHeightCalcType
Definition: ERF_SurfaceLayer.H:546
amrex::MultiFab * get_pblh(const int &lev)
Definition: ERF_SurfaceLayer.H:480
void fill_tsurf_with_sst_and_tsk(const int &lev, const amrex::Real &time)
Definition: ERF_SurfaceLayer.cpp:464
amrex::Real surf_temp_flux
Definition: ERF_SurfaceLayer.H:566
amrex::Vector< amrex::Geometry > m_geom
Definition: ERF_SurfaceLayer.H:557
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_star
Definition: ERF_SurfaceLayer.H:586
amrex::MultiFab * get_z0(const int &lev)
Definition: ERF_SurfaceLayer.H:493
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_tsk_lev
Definition: ERF_SurfaceLayer.H:594
amrex::Real custom_tstar
Definition: ERF_SurfaceLayer.H:571
bool cnk_visc
Definition: ERF_SurfaceLayer.H:576
amrex::Real surf_heating_rate
Definition: ERF_SurfaceLayer.H:565
RoughCalcType
Definition: ERF_SurfaceLayer.H:538
FluxCalcType flux_type
Definition: ERF_SurfaceLayer.H:548
MoistCalcType moist_type
Definition: ERF_SurfaceLayer.H:550
void impose_SurfaceLayer_bcs(const int &lev, amrex::Vector< const amrex::MultiFab * > mfs, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Tau_lev, amrex::MultiFab *xheat_flux, amrex::MultiFab *yheat_flux, amrex::MultiFab *zheat_flux, amrex::MultiFab *xqv_flux, amrex::MultiFab *yqv_flux, amrex::MultiFab *zqv_flux, const amrex::MultiFab *z_phys)
Definition: ERF_SurfaceLayer.cpp:257
amrex::Vector< amrex::MultiFab * > m_eddyDiffs_lev
Definition: ERF_SurfaceLayer.H:600
const amrex::MultiFab * get_mac_avg(const int &lev, int comp)
Definition: ERF_SurfaceLayer.H:482
amrex::Real custom_ustar
Definition: ERF_SurfaceLayer.H:570
amrex::Vector< std::unique_ptr< amrex::MultiFab > > olen
Definition: ERF_SurfaceLayer.H:588
amrex::MultiFab * get_t_surf(const int &lev)
Definition: ERF_SurfaceLayer.H:487
amrex::Vector< std::unique_ptr< amrex::MultiFab > > pblh
Definition: ERF_SurfaceLayer.H:589
amrex::Real default_land_surf_temp
Definition: ERF_SurfaceLayer.H:563
SurfaceLayer(const amrex::Vector< amrex::Geometry > &geom, bool &use_rot_surface_flux, std::string a_pp_prefix, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &Qv_prim, amrex::Vector< std::unique_ptr< amrex::MultiFab >> &z_phys_nd, const TerrainType &a_terrain_type, amrex::Real bdy_time_interval=0.0)
Definition: ERF_SurfaceLayer.H:35
amrex::Real get_zref()
Definition: ERF_SurfaceLayer.H:491
void update_fluxes(const int &lev, const amrex::Real &time, const amrex::MultiFab &cons_in, const std::unique_ptr< amrex::MultiFab > &z_phys_nd, int max_iters=100)
Definition: ERF_SurfaceLayer.cpp:12
ThetaCalcType
Definition: ERF_SurfaceLayer.H:526
@ SURFACE_TEMPERATURE
Surface temperature specified.
@ HEAT_FLUX
Heat-flux specified.
void read_custom_roughness(const int &lev, const std::string &fname)
Definition: ERF_SurfaceLayer.cpp:636
MOSTAverage m_ma
Definition: ERF_SurfaceLayer.H:583
@ ng
Definition: ERF_Morrison.H:48
real(c_double), parameter epsilon
Definition: ERF_module_model_constants.F90:12
Definition: ERF_DataStruct.H:99