ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
SurfaceLayer Class Reference

#include <ERF_SurfaceLayer.H>

Collaboration diagram for SurfaceLayer:

Public Types

enum class  FluxCalcType { MOENG = 0 , DONELAN , CUSTOM , ROTATE }
 
enum class  ThetaCalcType { ADIABATIC = 0 , HEAT_FLUX , SURFACE_TEMPERATURE }
 
enum class  MoistCalcType { ADIABATIC = 0 , MOISTURE_FLUX , SURFACE_MOISTURE }
 
enum class  RoughCalcType {
  CONSTANT = 0 , CHARNOCK , MODIFIED_CHARNOCK , DONELAN ,
  WAVE_COUPLED
}
 
enum class  PBLHeightCalcType { None , MYNN25 , YSU , MRF }
 

Public Member Functions

 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)
 
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)
 
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)
 
template<typename FluxIter >
void compute_fluxes (const int &lev, const int &max_iters, const FluxIter &most_flux, bool is_land)
 
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)
 
template<typename FluxCalc >
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)
 
void fill_tsurf_with_sst_and_tsk (const int &lev, const amrex::Real &time)
 
void fill_qsurf_with_qsat (const int &lev, const amrex::MultiFab &cons_in, const std::unique_ptr< amrex::MultiFab > &z_phys_nd)
 
void get_lsm_tsurf (const int &lev)
 
void update_pblh (const int &lev, amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars, amrex::MultiFab *z_phys_cc, const MoistureComponentIndices &moisture_indices)
 
template<typename PBLHeightEstimator >
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)
 
void read_custom_roughness (const int &lev, const std::string &fname)
 
void update_surf_temp (const amrex::Real &time)
 
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)
 
amrex::MultiFab * get_u_star (const int &lev)
 
amrex::MultiFab * get_w_star (const int &lev)
 
amrex::MultiFab * get_t_star (const int &lev)
 
amrex::MultiFab * get_q_star (const int &lev)
 
amrex::MultiFab * get_olen (const int &lev)
 
amrex::MultiFab * get_pblh (const int &lev)
 
const amrex::MultiFab * get_mac_avg (const int &lev, int comp)
 
amrex::MultiFab * get_t_surf (const int &lev)
 
amrex::MultiFab * get_q_surf (const int &lev)
 
amrex::Real get_zref ()
 
amrex::FArrayBox * get_z0 (const int &lev)
 
bool have_variable_sea_roughness ()
 
amrex::iMultiFab * get_lmask (const int &lev)
 
int lmask_min_reduce (amrex::iMultiFab &lmask, const int &nghost)
 
template<typename FluxCalc >
void compute_SurfaceLayer_bcs (const int &lev, Vector< const MultiFab * > mfs, Vector< std::unique_ptr< MultiFab >> &Tau_lev, MultiFab *xheat_flux, MultiFab *yheat_flux, MultiFab *zheat_flux, MultiFab *xqv_flux, MultiFab *yqv_flux, MultiFab *zqv_flux, const MultiFab *z_phys, const FluxCalc &flux_comp)
 
template<typename PBLHeightEstimator >
void compute_pblh (const int &lev, Vector< Vector< MultiFab >> &vars, MultiFab *z_phys_cc, const PBLHeightEstimator &est, const MoistureComponentIndices &moisture_indices)
 

Public Attributes

FluxCalcType flux_type {FluxCalcType::MOENG}
 
ThetaCalcType theta_type {ThetaCalcType::ADIABATIC}
 
MoistCalcType moist_type {MoistCalcType::ADIABATIC}
 
RoughCalcType rough_type_land {RoughCalcType::CONSTANT}
 
RoughCalcType rough_type_sea {RoughCalcType::CHARNOCK}
 
PBLHeightCalcType pblh_type {PBLHeightCalcType::None}
 

Private Attributes

amrex::Vector< amrex::Geometry > m_geom
 
bool m_rotate = false
 
amrex::Real m_bdy_time_interval
 
bool m_include_wstar = false
 
amrex::Real z0_const {0.1}
 
amrex::Real default_land_surf_temp {300.}
 
amrex::Real surf_temp
 
amrex::Real surf_heating_rate {0}
 
amrex::Real surf_temp_flux {0}
 
amrex::Real default_land_surf_moist {0.}
 
amrex::Real surf_moist
 
amrex::Real surf_moist_flux {0}
 
amrex::Real custom_ustar {0}
 
amrex::Real custom_tstar {0}
 
amrex::Real custom_qstar {0}
 
amrex::Real custom_rhosurf {0}
 
bool specified_rho_surf {false}
 
amrex::Real cnk_a {0.0185}
 
bool cnk_visc {false}
 
amrex::Real depth {30.0}
 
amrex::Vector< amrex::FArrayBox > z_0
 
bool m_var_z0 {false}
 
bool use_moisture
 
MOSTAverage m_ma
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > u_star
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > w_star
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_star
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_star
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > olen
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > pblh
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_surf
 
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_surf
 
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_sst_lev
 
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_tsk_lev
 
amrex::Vector< amrex::Vector< amrex::iMultiFab * > > m_lmask_lev
 
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_data_lev
 
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_flux_lev
 
amrex::Vector< amrex::MultiFab * > m_Hwave_lev
 
amrex::Vector< amrex::MultiFab * > m_Lwave_lev
 
amrex::Vector< amrex::MultiFab * > m_eddyDiffs_lev
 

Detailed Description

Abstraction layer for different surface layer schemes (e.g. MOST, Cd)

van der Laan, P., Kelly, M. C., & Sørensen, N. N. (2017). A new k-epsilon model consistent with Monin-Obukhov similarity theory. Wind Energy, 20(3), 479–489. https://doi.org/10.1002/we.2017

Consistent with Dyer (1974) formulation from page 57, Chapter 2, Modeling the vertical ABL structure in Modelling of Atmospheric Flow Fields, Demetri P Lalas and Corrado F Ratto, January 1996, https://doi.org/10.1142/2975.

Member Enumeration Documentation

◆ FluxCalcType

Enumerator
MOENG 

Moeng functional form.

DONELAN 

Donelan functional form.

CUSTOM 

Custom constant flux functional form.

ROTATE 

Terrain rotation flux functional form.

526  {
527  MOENG = 0, ///< Moeng functional form
528  DONELAN, ///< Donelan functional form
529  CUSTOM, ///< Custom constant flux functional form
530  ROTATE ///< Terrain rotation flux functional form
531  };

◆ MoistCalcType

Enumerator
ADIABATIC 
MOISTURE_FLUX 

Qv-flux specified.

SURFACE_MOISTURE 

Surface Qv specified.

539  {
540  ADIABATIC = 0,
541  MOISTURE_FLUX, ///< Qv-flux specified
542  SURFACE_MOISTURE ///< Surface Qv specified
543  };

◆ PBLHeightCalcType

Enumerator
None 
MYNN25 
YSU 
MRF 
553 { None, MYNN25, YSU, MRF };

◆ RoughCalcType

Enumerator
CONSTANT 

Constant z0.

CHARNOCK 
MODIFIED_CHARNOCK 
DONELAN 
WAVE_COUPLED 
545  {
546  CONSTANT = 0, ///< Constant z0
547  CHARNOCK,
548  MODIFIED_CHARNOCK,
549  DONELAN,
550  WAVE_COUPLED
551  };

◆ ThetaCalcType

Enumerator
ADIABATIC 
HEAT_FLUX 

Heat-flux specified.

SURFACE_TEMPERATURE 

Surface temperature specified.

533  {
534  ADIABATIC = 0,
535  HEAT_FLUX, ///< Heat-flux specified
536  SURFACE_TEMPERATURE ///< Surface temperature specified
537  };

Constructor & Destructor Documentation

◆ SurfaceLayer()

SurfaceLayer::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 
)
inlineexplicit
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
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real pp(amrex::Real y)
Definition: ERF_MicrophysicsUtils.H:230
ThetaCalcType theta_type
Definition: ERF_SurfaceLayer.H:556
bool m_include_wstar
Definition: ERF_SurfaceLayer.H:568
bool m_rotate
Definition: ERF_SurfaceLayer.H:565
PBLHeightCalcType pblh_type
Definition: ERF_SurfaceLayer.H:560
bool use_moisture
Definition: ERF_SurfaceLayer.H:588
RoughCalcType rough_type_land
Definition: ERF_SurfaceLayer.H:558
amrex::Real z0_const
Definition: ERF_SurfaceLayer.H:569
amrex::Real cnk_a
Definition: ERF_SurfaceLayer.H:582
amrex::Real surf_temp
Definition: ERF_SurfaceLayer.H:571
amrex::Real surf_moist_flux
Definition: ERF_SurfaceLayer.H:576
RoughCalcType rough_type_sea
Definition: ERF_SurfaceLayer.H:559
amrex::Real surf_moist
Definition: ERF_SurfaceLayer.H:575
amrex::Real m_bdy_time_interval
Definition: ERF_SurfaceLayer.H:566
amrex::Real custom_qstar
Definition: ERF_SurfaceLayer.H:579
amrex::Real custom_rhosurf
Definition: ERF_SurfaceLayer.H:580
@ MOENG
Moeng functional form.
@ CUSTOM
Custom constant flux functional form.
@ ROTATE
Terrain rotation flux functional form.
@ DONELAN
Donelan functional form.
@ SURFACE_MOISTURE
Surface Qv specified.
@ MOISTURE_FLUX
Qv-flux specified.
amrex::Real depth
Definition: ERF_SurfaceLayer.H:584
amrex::Real default_land_surf_moist
Definition: ERF_SurfaceLayer.H:574
amrex::Real surf_temp_flux
Definition: ERF_SurfaceLayer.H:573
amrex::Vector< amrex::Geometry > m_geom
Definition: ERF_SurfaceLayer.H:564
amrex::Real custom_tstar
Definition: ERF_SurfaceLayer.H:578
bool cnk_visc
Definition: ERF_SurfaceLayer.H:583
amrex::Real surf_heating_rate
Definition: ERF_SurfaceLayer.H:572
FluxCalcType flux_type
Definition: ERF_SurfaceLayer.H:555
MoistCalcType moist_type
Definition: ERF_SurfaceLayer.H:557
amrex::Real custom_ustar
Definition: ERF_SurfaceLayer.H:577
amrex::Real default_land_surf_temp
Definition: ERF_SurfaceLayer.H:570
@ SURFACE_TEMPERATURE
Surface temperature specified.
@ HEAT_FLUX
Heat-flux specified.
MOSTAverage m_ma
Definition: ERF_SurfaceLayer.H:590
real(c_double), parameter epsilon
Definition: ERF_module_model_constants.F90:12
Here is the call graph for this function:

Member Function Documentation

◆ compute_fluxes()

template<typename FluxIter >
void SurfaceLayer::compute_fluxes ( const int &  lev,
const int &  max_iters,
const FluxIter &  most_flux,
bool  is_land 
)

Function to compute the fluxes (u^star and t^star) for Monin Obukhov similarity theory

Parameters
[in]levCurrent level
[in]max_itersmaximum iterations to use
[in]most_fluxstructure to iteratively compute ustar and tstar
194 {
195  // Pointers to the computed averages
196  const auto *const tm_ptr = m_ma.get_average(lev,2); // potential temperature
197  const auto *const qvm_ptr = m_ma.get_average(lev,3); // water vapor mixing ratio
198  const auto *const tvm_ptr = m_ma.get_average(lev,4); // virtual potential temperature
199  const auto *const umm_ptr = m_ma.get_average(lev,5); // horizontal velocity magnitude
200 
201  for (MFIter mfi(*u_star[lev]); mfi.isValid(); ++mfi)
202  {
203  Box gtbx = mfi.growntilebox();
204 
205  auto u_star_arr = u_star[lev]->array(mfi);
206  auto t_star_arr = t_star[lev]->array(mfi);
207  auto q_star_arr = q_star[lev]->array(mfi);
208  auto t_surf_arr = t_surf[lev]->array(mfi);
209  auto q_surf_arr = q_surf[lev]->array(mfi);
210  auto olen_arr = olen[lev]->array(mfi);
211 
212  const auto tm_arr = tm_ptr->array(mfi);
213  const auto tvm_arr = tvm_ptr->array(mfi);
214  const auto qvm_arr = qvm_ptr->array(mfi);
215  const auto umm_arr = umm_ptr->array(mfi);
216  const auto z0_arr = z_0[lev].array();
217 
218  // PBL height if we need to calculate wstar for the Beljaars correction
219  // TODO: can/should we apply this in LES mode?
220  const auto w_star_arr = (m_include_wstar) ? w_star[lev].get()->array(mfi) : Array4<Real> {};
221  const auto pblh_arr = (m_include_wstar) ? pblh[lev].get()->array(mfi) : Array4<Real> {};
222 
223  // Wave properties if they exist
224  const auto Hwave_arr = (m_Hwave_lev[lev]) ? m_Hwave_lev[lev]->array(mfi) : Array4<Real> {};
225  const auto Lwave_arr = (m_Lwave_lev[lev]) ? m_Lwave_lev[lev]->array(mfi) : Array4<Real> {};
226  const auto eta_arr = (m_eddyDiffs_lev[lev]) ? m_eddyDiffs_lev[lev]->array(mfi) : Array4<Real> {};
227 
228  // Land mask array if it exists
229  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
230  Array4<int> {};
231 
232  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
233  {
234  if (( is_land && lmask_arr(i,j,k) == 1) ||
235  (!is_land && lmask_arr(i,j,k) == 0))
236  {
237  most_flux.iterate_flux(i, j, k, max_iters,
238  z0_arr, umm_arr, tm_arr, tvm_arr, qvm_arr,
239  u_star_arr, w_star_arr, // to be updated
240  t_star_arr, q_star_arr, // to be updated
241  t_surf_arr, q_surf_arr, olen_arr, // to be updated
242  pblh_arr, Hwave_arr, Lwave_arr, eta_arr);
243  }
244  });
245  }
246 }
const amrex::MultiFab * get_average(const int &lev, const int &comp) const
Definition: ERF_MOSTAverage.H:101
amrex::Vector< amrex::Vector< amrex::iMultiFab * > > m_lmask_lev
Definition: ERF_SurfaceLayer.H:602
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_surf
Definition: ERF_SurfaceLayer.H:597
amrex::Vector< amrex::FArrayBox > z_0
Definition: ERF_SurfaceLayer.H:585
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_star
Definition: ERF_SurfaceLayer.H:594
amrex::Vector< amrex::MultiFab * > m_Lwave_lev
Definition: ERF_SurfaceLayer.H:606
amrex::Vector< std::unique_ptr< amrex::MultiFab > > w_star
Definition: ERF_SurfaceLayer.H:592
amrex::Vector< std::unique_ptr< amrex::MultiFab > > u_star
Definition: ERF_SurfaceLayer.H:591
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_surf
Definition: ERF_SurfaceLayer.H:598
amrex::Vector< amrex::MultiFab * > m_Hwave_lev
Definition: ERF_SurfaceLayer.H:605
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_star
Definition: ERF_SurfaceLayer.H:593
amrex::Vector< amrex::MultiFab * > m_eddyDiffs_lev
Definition: ERF_SurfaceLayer.H:607
amrex::Vector< std::unique_ptr< amrex::MultiFab > > olen
Definition: ERF_SurfaceLayer.H:595
amrex::Vector< std::unique_ptr< amrex::MultiFab > > pblh
Definition: ERF_SurfaceLayer.H:596

◆ compute_pblh() [1/2]

template<typename PBLHeightEstimator >
void SurfaceLayer::compute_pblh ( const int &  lev,
amrex::Vector< amrex::Vector< amrex::MultiFab >> &  vars,
amrex::MultiFab *  z_phys_cc,
const PBLHeightEstimator &  est,
const MoistureComponentIndices moisture_indice 
)

◆ compute_pblh() [2/2]

template<typename PBLHeightEstimator >
void SurfaceLayer::compute_pblh ( const int &  lev,
Vector< Vector< MultiFab >> &  vars,
MultiFab *  z_phys_cc,
const PBLHeightEstimator &  est,
const MoistureComponentIndices moisture_indices 
)
629 {
630  est.compute_pblh(m_geom[lev],z_phys_cc, pblh[lev].get(),
631  vars[lev][Vars::cons],m_lmask_lev[lev][0],
632  moisture_indices);
633 }
@ cons
Definition: ERF_IndexDefines.H:140

◆ compute_SurfaceLayer_bcs() [1/2]

template<typename FluxCalc >
void SurfaceLayer::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 
)

◆ compute_SurfaceLayer_bcs() [2/2]

template<typename FluxCalc >
void SurfaceLayer::compute_SurfaceLayer_bcs ( const int &  lev,
Vector< const MultiFab * >  mfs,
Vector< std::unique_ptr< MultiFab >> &  Tau_lev,
MultiFab *  xheat_flux,
MultiFab *  yheat_flux,
MultiFab *  zheat_flux,
MultiFab *  xqv_flux,
MultiFab *  yqv_flux,
MultiFab *  zqv_flux,
const MultiFab *  z_phys,
const FluxCalc &  flux_comp 
)

Function to calculate MOST fluxes for populating ghost cells.

Parameters
[in]levCurrent level
[in,out]mfsMultifabs to populate
[in]eddyDiffsDiffusion coefficients from turbulence model
[in]flux_compstructure to compute fluxes
317 {
318  bool rotate = m_rotate;
319  const int klo = m_geom[lev].Domain().smallEnd(2);
320  const auto& dxInv = m_geom[lev].InvCellSizeArray();
321  for (MFIter mfi(*mfs[0]); mfi.isValid(); ++mfi)
322  {
323  // Get field arrays
324  const auto cons_arr = mfs[Vars::cons]->array(mfi);
325  const auto velx_arr = mfs[Vars::xvel]->array(mfi);
326  const auto vely_arr = mfs[Vars::yvel]->array(mfi);
327  const auto velz_arr = mfs[Vars::zvel]->array(mfi);
328 
329  // Diffusive stress vars
330  auto t13_arr = Tau_lev[TauType::tau13]->array(mfi);
331  auto t31_arr = (Tau_lev[TauType::tau31]) ? Tau_lev[TauType::tau31]->array(mfi) : Array4<Real>{};
332 
333  auto t23_arr = Tau_lev[TauType::tau23]->array(mfi);
334  auto t32_arr = (Tau_lev[TauType::tau32]) ? Tau_lev[TauType::tau32]->array(mfi) : Array4<Real>{};
335 
336  auto hfx3_arr = zheat_flux->array(mfi);
337  auto qfx3_arr = (zqv_flux) ? zqv_flux->array(mfi) : Array4<Real>{};
338 
339  // Rotated stress vars
340  auto t11_arr = (m_rotate) ? Tau_lev[TauType::tau11]->array(mfi) : Array4<Real>{};
341  auto t22_arr = (m_rotate) ? Tau_lev[TauType::tau22]->array(mfi) : Array4<Real>{};
342  auto t33_arr = (m_rotate) ? Tau_lev[TauType::tau33]->array(mfi) : Array4<Real>{};
343  auto t12_arr = (m_rotate) ? Tau_lev[TauType::tau12]->array(mfi) : Array4<Real>{};
344  auto t21_arr = (m_rotate) ? Tau_lev[TauType::tau21]->array(mfi) : Array4<Real>{};
345 
346  auto hfx1_arr = (m_rotate) ? xheat_flux->array(mfi) : Array4<Real>{};
347  auto hfx2_arr = (m_rotate) ? yheat_flux->array(mfi) : Array4<Real>{};
348  auto qfx1_arr = (m_rotate && xqv_flux) ? xqv_flux->array(mfi) : Array4<Real>{};
349  auto qfx2_arr = (m_rotate && yqv_flux) ? yqv_flux->array(mfi) : Array4<Real>{};
350 
351  // Terrain
352  const auto zphys_arr = (z_phys) ? z_phys->const_array(mfi) : Array4<const Real>{};
353 
354  // Get average arrays
355  const auto *const u_mean = m_ma.get_average(lev,0);
356  const auto *const v_mean = m_ma.get_average(lev,1);
357  const auto *const t_mean = m_ma.get_average(lev,2);
358  const auto *const q_mean = m_ma.get_average(lev,3);
359  const auto *const u_mag_mean = m_ma.get_average(lev,5);
360 
361  const auto um_arr = u_mean->array(mfi);
362  const auto vm_arr = v_mean->array(mfi);
363  const auto tm_arr = t_mean->array(mfi);
364  const auto qm_arr = q_mean->array(mfi);
365  const auto umm_arr = u_mag_mean->array(mfi);
366 
367  // Get derived arrays
368  const auto u_star_arr = u_star[lev]->array(mfi);
369  const auto t_star_arr = t_star[lev]->array(mfi);
370  const auto q_star_arr = q_star[lev]->array(mfi);
371  const auto t_surf_arr = t_surf[lev]->array(mfi);
372  const auto q_surf_arr = q_surf[lev]->array(mfi);
373 
374  // Get LSM fluxes
375  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
376  Array4<int> {};
377  auto lsm_flux_arr = (m_lsm_flux_lev[lev][0]) ? m_lsm_flux_lev[lev][0]->array(mfi) :
378  Array4<Real> {};
379 
380  // Rho*Theta flux
381  //============================================================================
382  Box bx = mfi.tilebox();
383  if (bx.smallEnd(2) != klo) { continue; }
384  bx.makeSlab(2,klo);
385  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
386  {
387  Real Tflux = flux_comp.compute_t_flux(i, j, k,
388  cons_arr, velx_arr, vely_arr,
389  umm_arr, tm_arr, u_star_arr,
390  t_star_arr, t_surf_arr);
391 
392  if (rotate) {
393  rotate_scalar_flux(i, j, k, Tflux, dxInv, zphys_arr,
394  hfx1_arr, hfx2_arr, hfx3_arr);
395  } else {
396  hfx3_arr(i,j,klo) = Tflux;
397  int is_land = (lmask_arr) ? lmask_arr(i,j,klo) : 1;
398  if (is_land && lsm_flux_arr) {
399  lsm_flux_arr(i,j,k) = Tflux;
400  }
401  }
402  });
403 
404  // Rho*Qv flux
405  //============================================================================
406  if (use_moisture) {
407  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
408  {
409  Real Qflux = flux_comp.compute_q_flux(i, j, k,
410  cons_arr, velx_arr, vely_arr,
411  umm_arr, qm_arr, u_star_arr,
412  q_star_arr, q_surf_arr);
413 
414  if (rotate) {
415  rotate_scalar_flux(i, j, k, Qflux, dxInv, zphys_arr,
416  qfx1_arr, qfx2_arr, qfx3_arr);
417  } else {
418  qfx3_arr(i,j,k) = Qflux;
419  }
420  });
421  } // custom
422 
423  // Rho*u flux
424  //============================================================================
425  Box bxx = surroundingNodes(bx,0);
426  ParallelFor(bxx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
427  {
428  Real stressx = flux_comp.compute_u_flux(i, j, k,
429  cons_arr, velx_arr, vely_arr,
430  umm_arr, um_arr, u_star_arr);
431 
432  if (rotate) {
433  rotate_stress_tensor(i, j, k, stressx, dxInv, zphys_arr,
434  velx_arr, vely_arr, velz_arr,
435  t11_arr, t22_arr, t33_arr,
436  t12_arr, t21_arr,
437  t13_arr, t31_arr,
438  t23_arr, t32_arr);
439  } else {
440  t13_arr(i,j,k) = stressx;
441  if (t31_arr) { t31_arr(i,j,k) = stressx; }
442  }
443  });
444 
445  // Rho*v flux
446  //============================================================================
447  Box bxy = surroundingNodes(bx,1);
448  ParallelFor(bxy, [=] AMREX_GPU_DEVICE (int i, int j, int k)
449  {
450  Real stressy = flux_comp.compute_v_flux(i, j, k,
451  cons_arr, velx_arr, vely_arr,
452  umm_arr, vm_arr, u_star_arr);
453 
454  // NOTE: One stress rotation for ALL the stress components
455  if (!rotate) {
456  t23_arr(i,j,k) = stressy;
457  if (t32_arr) { t32_arr(i,j,k) = stressy; }
458  }
459  });
460  } // mfiter
461 }
@ tau12
Definition: ERF_DataStruct.H:30
@ tau23
Definition: ERF_DataStruct.H:30
@ tau33
Definition: ERF_DataStruct.H:30
@ tau22
Definition: ERF_DataStruct.H:30
@ tau11
Definition: ERF_DataStruct.H:30
@ tau32
Definition: ERF_DataStruct.H:30
@ tau31
Definition: ERF_DataStruct.H:30
@ tau21
Definition: ERF_DataStruct.H:30
@ tau13
Definition: ERF_DataStruct.H:30
AMREX_GPU_DEVICE AMREX_FORCE_INLINE void rotate_scalar_flux(const int &i, const int &j, const int &klo, const amrex::Real &flux, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &dxInv, const amrex::Array4< const amrex::Real > &zphys_arr, const amrex::Array4< amrex::Real > &phi1_arr, const amrex::Array4< amrex::Real > &phi2_arr, const amrex::Array4< amrex::Real > &phi3_arr)
Definition: ERF_TerrainMetrics.H:612
AMREX_GPU_DEVICE AMREX_FORCE_INLINE void rotate_stress_tensor(const int &i, const int &j, const int &klo, const amrex::Real &flux, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &dxInv, const amrex::Array4< const amrex::Real > &zphys_arr, const amrex::Array4< const amrex::Real > &u_arr, const amrex::Array4< const amrex::Real > &v_arr, const amrex::Array4< const amrex::Real > &w_arr, const amrex::Array4< amrex::Real > &tau11_arr, const amrex::Array4< amrex::Real > &tau22_arr, const amrex::Array4< amrex::Real > &tau33_arr, const amrex::Array4< amrex::Real > &tau12_arr, const amrex::Array4< amrex::Real > &tau21_arr, const amrex::Array4< amrex::Real > &tau13_arr, const amrex::Array4< amrex::Real > &tau31_arr, const amrex::Array4< amrex::Real > &tau23_arr, const amrex::Array4< amrex::Real > &tau32_arr)
Definition: ERF_TerrainMetrics.H:633
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_flux_lev
Definition: ERF_SurfaceLayer.H:604
@ xvel
Definition: ERF_IndexDefines.H:141
@ zvel
Definition: ERF_IndexDefines.H:143
@ yvel
Definition: ERF_IndexDefines.H:142
Here is the call graph for this function:

◆ fill_qsurf_with_qsat()

void SurfaceLayer::fill_qsurf_with_qsat ( const int &  lev,
const amrex::MultiFab &  cons_in,
const std::unique_ptr< amrex::MultiFab > &  z_phys_nd 
)
539 {
540  // NOTE: We have already tested a moisture model exists
541 
542  // Populate q_surf with qsat over water
543  auto dz = m_geom[lev].CellSize(2);
544  for (MFIter mfi(*q_surf[lev]); mfi.isValid(); ++mfi)
545  {
546  Box gtbx = mfi.growntilebox();
547 
548  auto t_surf_arr = t_surf[lev]->array(mfi);
549  auto q_surf_arr = q_surf[lev]->array(mfi);
550  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
551  Array4<int> {};
552  const auto cons_arr = cons_in.const_array(mfi);
553  const auto z_arr = (z_phys_nd) ? z_phys_nd->const_array(mfi) :
554  Array4<const Real> {};
555 
556  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
557  {
558  int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
559  if (!is_land) {
560  auto deltaZ = (z_arr) ? Compute_Zrel_AtCellCenter(i,j,k,z_arr) :
561  0.5*dz;
562  auto Rho = cons_arr(i,j,k,Rho_comp);
563  auto RTh = cons_arr(i,j,k,RhoTheta_comp);
564  auto Qv = cons_arr(i,j,k,RhoQ1_comp) / Rho;
565  auto P_cc = getPgivenRTh(RTh, Qv);
566  P_cc += Rho*CONST_GRAV*deltaZ;
567  P_cc *= 0.01;
568  erf_qsatw(t_surf_arr(i,j,k), P_cc, q_surf_arr(i,j,k));
569  }
570  });
571  }
572  q_surf[lev]->FillBoundary(m_geom[lev].periodicity());
573 }
constexpr amrex::Real CONST_GRAV
Definition: ERF_Constants.H:21
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real getPgivenRTh(const amrex::Real rhotheta, const amrex::Real qv=0.)
Definition: ERF_EOS.H:81
#define Rho_comp
Definition: ERF_IndexDefines.H:36
#define RhoTheta_comp
Definition: ERF_IndexDefines.H:37
#define RhoQ1_comp
Definition: ERF_IndexDefines.H:42
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void erf_qsatw(amrex::Real t, amrex::Real p, amrex::Real &qsatw)
Definition: ERF_MicrophysicsUtils.H:163
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_Zrel_AtCellCenter(const int &i, const int &j, const int &k, const amrex::Array4< const amrex::Real > &z_nd)
Definition: ERF_TerrainMetrics.H:390
Here is the call graph for this function:

◆ fill_tsurf_with_sst_and_tsk()

void SurfaceLayer::fill_tsurf_with_sst_and_tsk ( const int &  lev,
const amrex::Real &  time 
)
466 {
467  int n_times_in_sst = m_sst_lev[lev].size();
468 
469  int n_time_lo, n_time_hi;
470  Real alpha;
471 
472  if (n_times_in_sst > 1) {
473  // Time interpolation
474  Real dT = m_bdy_time_interval;
475  int n_time = static_cast<int>( time / dT);
476  n_time_lo = n_time;
477  n_time_hi = n_time+1;
478  alpha = (time - n_time * dT) / dT;
479  AMREX_ALWAYS_ASSERT( (n_time >= 0) && (n_time < (m_sst_lev[lev].size()-1)));
480  } else {
481  n_time_lo = 0;
482  n_time_hi = 0;
483  alpha = 1.0;
484  }
485  AMREX_ALWAYS_ASSERT( alpha >= 0. && alpha <= 1.0);
486 
487  Real oma = 1.0 - alpha;
488 
489  // Define a default land surface temperature if we don't read in tsk
490  Real lst = default_land_surf_temp;
491 
492  bool use_tsk = (m_tsk_lev[lev][0]);
493 
494  // Populate t_surf
495  for (MFIter mfi(*t_surf[lev]); mfi.isValid(); ++mfi)
496  {
497  Box gtbx = mfi.growntilebox();
498 
499  auto t_surf_arr = t_surf[lev]->array(mfi);
500 
501  const auto sst_lo_arr = m_sst_lev[lev][n_time_lo]->const_array(mfi);
502  const auto sst_hi_arr = m_sst_lev[lev][n_time_hi]->const_array(mfi);
503 
504  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
505  Array4<int> {};
506 
507  if (use_tsk) {
508  const auto tsk_arr = m_tsk_lev[lev][n_time_lo]->const_array(mfi);
509  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
510  {
511  int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
512  if (!is_land) {
513  t_surf_arr(i,j,k) = oma * sst_lo_arr(i,j,k)
514  + alpha * sst_hi_arr(i,j,k);
515  } else {
516  t_surf_arr(i,j,k) = tsk_arr(i,j,k);
517  }
518  });
519  } else {
520  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
521  {
522  int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
523  if (!is_land) {
524  t_surf_arr(i,j,k) = oma * sst_lo_arr(i,j,k)
525  + alpha * sst_hi_arr(i,j,k);
526  } else {
527  t_surf_arr(i,j,k) = lst;
528  }
529  });
530  }
531  }
532  t_surf[lev]->FillBoundary(m_geom[lev].periodicity());
533 }
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_sst_lev
Definition: ERF_SurfaceLayer.H:600
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_tsk_lev
Definition: ERF_SurfaceLayer.H:601

◆ get_lmask()

amrex::iMultiFab* SurfaceLayer::get_lmask ( const int &  lev)
inline
504 { return m_lmask_lev[lev][0]; }

◆ get_lsm_tsurf()

void SurfaceLayer::get_lsm_tsurf ( const int &  lev)
577 {
578  for (MFIter mfi(*t_surf[lev]); mfi.isValid(); ++mfi)
579  {
580  Box gtbx = mfi.growntilebox();
581 
582  // TODO: LSM does not carry lateral ghost cells.
583  // This copies the valid box into the ghost cells.
584  // Fillboundary is called after this to pick up the
585  // interior ghost and periodic directions. Is there
586  // a better approach?
587  Box vbx = mfi.validbox();
588  int i_lo = vbx.smallEnd(0); int i_hi = vbx.bigEnd(0);
589  int j_lo = vbx.smallEnd(1); int j_hi = vbx.bigEnd(1);
590 
591  auto t_surf_arr = t_surf[lev]->array(mfi);
592  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
593  Array4<int> {};
594  const auto lsm_arr = m_lsm_data_lev[lev][0]->const_array(mfi);
595 
596  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
597  {
598  int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
599  if (is_land) {
600  int li = amrex::min(amrex::max(i, i_lo), i_hi);
601  int lj = amrex::min(amrex::max(j, j_lo), j_hi);
602  t_surf_arr(i,j,k) = lsm_arr(li,lj,k);
603  }
604  });
605  }
606 }
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_data_lev
Definition: ERF_SurfaceLayer.H:603

◆ get_mac_avg()

const amrex::MultiFab* SurfaceLayer::get_mac_avg ( const int &  lev,
int  comp 
)
inline
490  {
491  return m_ma.get_average(lev, comp);
492  }
Here is the call graph for this function:

◆ get_olen()

amrex::MultiFab* SurfaceLayer::get_olen ( const int &  lev)
inline
485 { return olen[lev].get(); }

◆ get_pblh()

amrex::MultiFab* SurfaceLayer::get_pblh ( const int &  lev)
inline
487 { return pblh[lev].get(); }

◆ get_q_star()

amrex::MultiFab* SurfaceLayer::get_q_star ( const int &  lev)
inline
483 { return q_star[lev].get(); }

◆ get_q_surf()

amrex::MultiFab* SurfaceLayer::get_q_surf ( const int &  lev)
inline
496 { return q_surf[lev].get(); }

◆ get_t_star()

amrex::MultiFab* SurfaceLayer::get_t_star ( const int &  lev)
inline
481 { return t_star[lev].get(); }

◆ get_t_surf()

amrex::MultiFab* SurfaceLayer::get_t_surf ( const int &  lev)
inline
494 { return t_surf[lev].get(); }

◆ get_u_star()

amrex::MultiFab* SurfaceLayer::get_u_star ( const int &  lev)
inline
477 { return u_star[lev].get(); }

◆ get_w_star()

amrex::MultiFab* SurfaceLayer::get_w_star ( const int &  lev)
inline
479 { return w_star[lev].get(); }

◆ get_z0()

amrex::FArrayBox* SurfaceLayer::get_z0 ( const int &  lev)
inline
500 { return &z_0[lev]; }

◆ get_zref()

amrex::Real SurfaceLayer::get_zref ( )
inline
498 { return m_ma.get_zref(); }
amrex::Real get_zref() const
Definition: ERF_MOSTAverage.H:104
Here is the call graph for this function:

◆ have_variable_sea_roughness()

bool SurfaceLayer::have_variable_sea_roughness ( )
inline
502 { return m_var_z0; }
bool m_var_z0
Definition: ERF_SurfaceLayer.H:586

◆ impose_SurfaceLayer_bcs()

void SurfaceLayer::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 
)

Wrapper to impose Monin Obukhov similarity theory fluxes by populating ghost cells.

Parameters
[in]levCurrent level
[in,out]mfsMultifabs to populate
[in]eddyDiffsDiffusion coefficients from turbulence model
267 {
269  moeng_flux flux_comp;
270  compute_SurfaceLayer_bcs(lev, mfs, Tau_lev,
271  xheat_flux, yheat_flux, zheat_flux,
272  xqv_flux, yqv_flux, zqv_flux,
273  z_phys, flux_comp);
274  } else if (flux_type == FluxCalcType::DONELAN) {
275  donelan_flux flux_comp;
276  compute_SurfaceLayer_bcs(lev, mfs, Tau_lev,
277  xheat_flux, yheat_flux, zheat_flux,
278  xqv_flux, yqv_flux, zqv_flux,
279  z_phys, flux_comp);
280  } else if (flux_type == FluxCalcType::ROTATE) {
281  rotate_flux flux_comp;
282  compute_SurfaceLayer_bcs(lev, mfs, Tau_lev,
283  xheat_flux, yheat_flux, zheat_flux,
284  xqv_flux, yqv_flux, zqv_flux,
285  z_phys, flux_comp);
286  } else {
287  custom_flux flux_comp(specified_rho_surf);
288  compute_SurfaceLayer_bcs(lev, mfs, Tau_lev,
289  xheat_flux, yheat_flux, zheat_flux,
290  xqv_flux, yqv_flux, zqv_flux,
291  z_phys, flux_comp);
292  }
293 }
bool specified_rho_surf
Definition: ERF_SurfaceLayer.H:581
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)
Definition: ERF_MOSTStress.H:2061
Definition: ERF_MOSTStress.H:1929
Definition: ERF_MOSTStress.H:1766
Definition: ERF_MOSTStress.H:2178

◆ lmask_min_reduce()

int SurfaceLayer::lmask_min_reduce ( amrex::iMultiFab &  lmask,
const int &  nghost 
)
inline
508  {
509  int lmask_min = amrex::ReduceMin(lmask, nghost, [=] AMREX_GPU_HOST_DEVICE(
510  amrex::Box const& bx, amrex::Array4<int const> const& lm_arr) -> int
511  {
512  int locmin = std::numeric_limits<int>::max();
513  const auto lo = lbound(bx);
514  const auto hi = ubound(bx);
515  for (int j = lo.y; j <= hi.y; ++j) {
516  for (int i = lo.x; i <= hi.x; ++i) {
517  locmin = std::min(locmin, lm_arr(i, j, 0));
518  }
519  }
520  return locmin;
521  });
522 
523  return lmask_min;
524  }

Referenced by make_SurfaceLayer_at_level().

Here is the caller graph for this function:

◆ make_SurfaceLayer_at_level()

void SurfaceLayer::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 
)
inline
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 = 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 = 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 = 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  amrex::Arena* Arena_Used = amrex::The_Arena();
344 #ifdef AMREX_USE_GPU
345  Arena_Used = amrex::The_Pinned_Arena();
346 #endif
347  amrex::Box bx = amrex::grow(m_geom[lev].Domain(), ng);
348  bx.setSmall(2, 0);
349  bx.setBig(2, 0);
350  z_0[lev].resize(bx, 1, Arena_Used);
351  z_0[lev].setVal<amrex::RunOn::Device>(z0_const);
352  if (read_z0) {
353  read_custom_roughness(lev, fname);
354  }
355 
356  // 2D MFs for U*, T*, T_surf
357  //--------------------------------------------------------
358  u_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
359  u_star[lev]->setVal(1.E34);
360 
361  w_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
362  w_star[lev]->setVal(1.E34);
363 
364  t_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
365  t_star[lev]->setVal(0.0); // default to neutral
366 
367  q_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
368  q_star[lev]->setVal(0.0); // default to dry
369 
370  olen[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
371  olen[lev]->setVal(1.E34);
372 
373  pblh[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
374  pblh[lev]->setVal(1.E34);
375 
376  t_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
377  t_surf[lev]->setVal(default_land_surf_temp);
378 
379  q_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
380  q_surf[lev]->setVal(default_land_surf_moist);
381 
382  // TODO: Do we want lsm_data to have theta at 0 index always?
383  // Do we want an external enum struct for indexing?
384  if (m_sst_lev[lev][0] || m_tsk_lev[lev][0] || m_lsm_data_lev[lev][0]) {
385  // Valid SST, TSK or LSM data; t_surf set before computing fluxes (avoids
386  // extended lambda capture) Note that land temp will be set from m_tsk_lev
387  // while sea temp will be set from m_sst_lev
389  }
390 
391 
392  }
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
int lmask_min_reduce(amrex::iMultiFab &lmask, const int &nghost)
Definition: ERF_SurfaceLayer.H:506
void read_custom_roughness(const int &lev, const std::string &fname)
Definition: ERF_SurfaceLayer.cpp:636
@ ng
Definition: ERF_Morrison.H:48
Here is the call graph for this function:

◆ read_custom_roughness()

void SurfaceLayer::read_custom_roughness ( const int &  lev,
const std::string &  fname 
)
638 {
639  // Read the file if we are on the coarsest level
640  if (lev==0) {
641  // Only the ioproc reads the file and broadcasts
642  if (ParallelDescriptor::IOProcessor()) {
643  Print()<<"Reading MOST roughness file: "<< fname << std::endl;
644  std::ifstream file(fname);
645  Gpu::HostVector<Real> m_x,m_y,m_z0;
646  Real value1,value2,value3;
647  while(file>>value1>>value2>>value3){
648  m_x.push_back(value1);
649  m_y.push_back(value2);
650  m_z0.push_back(value3);
651  }
652  file.close();
653 
654  // Copy data to the GPU
655  int nnode = m_x.size();
656  Gpu::DeviceVector<Real> d_x(nnode),d_y(nnode),d_z0(nnode);
657  Gpu::copy(Gpu::hostToDevice, m_x.begin(), m_x.end(), d_x.begin());
658  Gpu::copy(Gpu::hostToDevice, m_y.begin(), m_y.end(), d_y.begin());
659  Gpu::copy(Gpu::hostToDevice, m_z0.begin(), m_z0.end(), d_z0.begin());
660  Real* xp = d_x.data();
661  Real* yp = d_y.data();
662  Real* z0p = d_z0.data();
663 
664  // Populate z_phys data
665  Real tol = 1.0e-4;
666  auto dx = m_geom[lev].CellSizeArray();
667  auto ProbLoArr = m_geom[lev].ProbLoArray();
668  int ilo = m_geom[lev].Domain().smallEnd(0);
669  int jlo = m_geom[lev].Domain().smallEnd(1);
670  int klo = 0;
671  int ihi = m_geom[lev].Domain().bigEnd(0);
672  int jhi = m_geom[lev].Domain().bigEnd(1);
673 
674  // Grown box with no z range
675  Box xybx = z_0[lev].box();
676  xybx.setRange(2,0);
677 
678  Array4<Real> const& z0_arr = z_0[lev].array();
679  ParallelFor(xybx, [=] AMREX_GPU_DEVICE (int i, int j, int /*k*/)
680  {
681  // Clip indices for ghost-cells
682  int ii = amrex::min(amrex::max(i,ilo),ihi);
683  int jj = amrex::min(amrex::max(j,jlo),jhi);
684 
685  // Location of nodes
686  Real x = ProbLoArr[0] + ii * dx[0];
687  Real y = ProbLoArr[1] + jj * dx[1];
688  int inode = ii + jj * (ihi-ilo+2); // stride is Nx+1
689  if (std::sqrt(std::pow(x-xp[inode],2)+std::pow(y-yp[inode],2)) < tol) {
690  z0_arr(i,j,klo) = z0p[inode];
691  } else {
692  // Unexpected list order, do brute force search
693  Real z0loc = 0.0;
694  bool found = false;
695  for (int n=0; n<nnode; ++n) {
696  Real delta=std::sqrt(std::pow(x-xp[n],2)+std::pow(y-yp[n],2));
697  if (delta < tol) {
698  found = true;
699  z0loc = z0p[n];
700  break;
701  }
702  }
703  AMREX_ASSERT_WITH_MESSAGE(found, "Location read from terrain file does not match the grid!");
704  amrex::ignore_unused(found);
705  z0_arr(i,j,klo) = z0loc;
706  }
707  });
708  } // Is ioproc
709 
710  int ioproc = ParallelDescriptor::IOProcessorNumber();
711  ParallelDescriptor::Barrier();
712  ParallelDescriptor::Bcast(z_0[lev].dataPtr(),z_0[lev].box().numPts(),ioproc);
713  } else {
714  // Create a BC mapper that uses FOEXTRAP at domain bndry
715  Vector<int> bc_lo(3,ERFBCType::foextrap);
716  Vector<int> bc_hi(3,ERFBCType::foextrap);
717  Vector<BCRec> bcr; bcr.push_back(BCRec(bc_lo.data(),bc_hi.data()));
718 
719  // Create ref ratio
720  IntVect ratio;
721  for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
722  ratio[idim] = m_geom[lev].Domain().length(idim) / m_geom[0].Domain().length(idim);
723  }
724 
725  // Create interp object and interpolate from the coarsest grid
726  Interpolater* interp = &cell_cons_interp;
727  interp->interp(z_0[0] , 0,
728  z_0[lev], 0,
729  1, z_0[lev].box(),
730  ratio, m_geom[0], m_geom[lev],
731  bcr, 0, 0, RunOn::Gpu);
732  }
733 }
@ m_y
Definition: ERF_DataStruct.H:23
@ m_x
Definition: ERF_DataStruct.H:22
@ foextrap
Definition: ERF_IndexDefines.H:208

Referenced by make_SurfaceLayer_at_level().

Here is the caller graph for this function:

◆ update_fluxes()

void SurfaceLayer::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 
)

Wrapper to update ustar and tstar for Monin Obukhov similarity theory.

Parameters
[in]levCurrent level
[in]max_itersmaximum iterations to use
17 {
18  // Update with SST/TSK data if we have a valid pointer
19  if (m_sst_lev[lev][0]) {
20  fill_tsurf_with_sst_and_tsk(lev, time);
21  }
22 
23  // Apply heating rate if needed
25  update_surf_temp(time);
26  }
27 
28  // Update qsurf with qsat over sea
30  fill_qsurf_with_qsat(lev, cons_in, z_phys_nd);
31  }
32 
33  // TODO: we want 0 index to always be theta?
34  // Update land surface temp if we have a valid pointer
35  if (m_lsm_data_lev[lev][0]) { get_lsm_tsurf(lev); }
36 
37  // Fill interior ghost cells
38  t_surf[lev]->FillBoundary(m_geom[lev].periodicity());
39 
40  // Compute plane averages for all vars (regardless of flux type)
42 
43  // Do we have a constant flux for moisture?
44  bool cons_qflux = ( (moist_type == MoistCalcType::MOISTURE_FLUX) ||
46 
47  // ***************************************************************
48  // Iterate the fluxes if moeng type
49  // First iterate over land -- the only model for surface roughness
50  // over land is RoughCalcType::CONSTANT
51  // ***************************************************************
54  bool is_land = true;
57  surface_flux most_flux(m_ma.get_zref(), surf_temp_flux, surf_moist_flux, cons_qflux);
58  compute_fluxes(lev, max_iters, most_flux, is_land);
59  } else {
60  amrex::Abort("Unknown value for rough_type_land");
61  }
64  surface_temp most_flux(m_ma.get_zref(), surf_temp_flux, surf_moist_flux, cons_qflux);
65  compute_fluxes(lev, max_iters, most_flux, is_land);
66  } else {
67  amrex::Abort("Unknown value for rough_type_land");
68  }
69  } else if ((theta_type == ThetaCalcType::ADIABATIC) &&
73  compute_fluxes(lev, max_iters, most_flux, is_land);
74  } else {
75  amrex::Abort("Unknown value for rough_type_land");
76  }
77  } else {
78  amrex::Abort("Unknown value for theta_type");
79  }
80  } // MOENG -- LAND
81 
82  // ***************************************************************
83  // Iterate the fluxes if moeng type
84  // Next iterate over sea -- the models for surface roughness
85  // over sea are CHARNOCK, DONELAN, MODIFIED_CHARNOCK or WAVE_COUPLED
86  // ***************************************************************
89  bool is_land = false;
94  cnk_a, cnk_visc, cons_qflux);
95  compute_fluxes(lev, max_iters, most_flux, is_land);
99  depth, cons_qflux);
100  compute_fluxes(lev, max_iters, most_flux, is_land);
101  } else if (rough_type_sea == RoughCalcType::DONELAN) {
102  surface_flux_donelan most_flux(m_ma.get_zref(),
104  cons_qflux);
105  compute_fluxes(lev, max_iters, most_flux, is_land);
109  cons_qflux);
110  compute_fluxes(lev, max_iters, most_flux, is_land);
111  } else {
112  amrex::Abort("Unknown value for rough_type_sea");
113  }
114 
117  surface_temp_charnock most_flux(m_ma.get_zref(),
119  cnk_a, cnk_visc, cons_qflux);
120  compute_fluxes(lev, max_iters, most_flux, is_land);
124  depth, cons_qflux);
125  compute_fluxes(lev, max_iters, most_flux, is_land);
126  } else if (rough_type_sea == RoughCalcType::DONELAN) {
127  surface_temp_donelan most_flux(m_ma.get_zref(),
129  cons_qflux);
130  compute_fluxes(lev, max_iters, most_flux, is_land);
134  cons_qflux);
135  compute_fluxes(lev, max_iters, most_flux, is_land);
136  } else {
137  amrex::Abort("Unknown value for rough_type_sea");
138  }
139 
140  } else if ((theta_type == ThetaCalcType::ADIABATIC) &&
143  adiabatic_charnock most_flux(m_ma.get_zref(),
145  cnk_a, cnk_visc);
146  compute_fluxes(lev, max_iters, most_flux, is_land);
150  depth);
151  compute_fluxes(lev, max_iters, most_flux, is_land);
152  } else if (rough_type_sea == RoughCalcType::DONELAN) {
154  compute_fluxes(lev, max_iters, most_flux, is_land);
157  compute_fluxes(lev, max_iters, most_flux, is_land);
158  } else {
159  amrex::Abort("Unknown value for rough_type_sea");
160  }
161  } else {
162  amrex::Abort("Unknown value for theta_type");
163  }
164 
165  } // MOENG -- SEA
166 
168  if (custom_rhosurf > 0) {
169  specified_rho_surf = true;
170  u_star[lev]->setVal(std::sqrt(custom_rhosurf) * custom_ustar);
171  t_star[lev]->setVal(custom_rhosurf * custom_tstar);
172  q_star[lev]->setVal(custom_rhosurf * custom_qstar);
173  } else {
174  u_star[lev]->setVal(custom_ustar);
175  t_star[lev]->setVal(custom_tstar);
176  q_star[lev]->setVal(custom_qstar);
177  }
178  }
179 }
void compute_averages(const int &lev)
Definition: ERF_MOSTAverage.cpp:679
void update_surf_temp(const amrex::Real &time)
Definition: ERF_SurfaceLayer.H:456
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
void compute_fluxes(const int &lev, const int &max_iters, const FluxIter &most_flux, bool is_land)
Definition: ERF_SurfaceLayer.cpp:190
void fill_tsurf_with_sst_and_tsk(const int &lev, const amrex::Real &time)
Definition: ERF_SurfaceLayer.cpp:464
Definition: ERF_MOSTStress.H:187
Definition: ERF_MOSTStress.H:357
Definition: ERF_MOSTStress.H:276
Definition: ERF_MOSTStress.H:427
Definition: ERF_MOSTStress.H:137
Definition: ERF_MOSTStress.H:608
Definition: ERF_MOSTStress.H:838
Definition: ERF_MOSTStress.H:727
Definition: ERF_MOSTStress.H:946
Definition: ERF_MOSTStress.H:503
Definition: ERF_MOSTStress.H:1197
Definition: ERF_MOSTStress.H:1521
Definition: ERF_MOSTStress.H:1363
Definition: ERF_MOSTStress.H:1639
Definition: ERF_MOSTStress.H:1063

◆ update_mac_ptrs()

void SurfaceLayer::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 
)
inline
473  {
474  m_ma.update_field_ptrs(lev, vars_old, Theta_prim, Qv_prim, Qr_prim);
475  }
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
Here is the call graph for this function:

◆ update_pblh()

void SurfaceLayer::update_pblh ( const int &  lev,
amrex::Vector< amrex::Vector< amrex::MultiFab >> &  vars,
amrex::MultiFab *  z_phys_cc,
const MoistureComponentIndices moisture_indices 
)
613 {
615  MYNNPBLH estimator;
616  compute_pblh(lev, vars, z_phys_cc, estimator, moisture_indices);
618  amrex::Error("YSU/MRF PBLH calc not implemented yet");
619  }
620 }
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)
Definition: ERF_PBLHeight.H:8

◆ update_surf_temp()

void SurfaceLayer::update_surf_temp ( const amrex::Real &  time)
inline
457  {
458  if (surf_heating_rate != 0) {
459  int nlevs = m_geom.size();
460  for (int lev = 0; lev < nlevs; lev++) {
461  t_surf[lev]->setVal(surf_temp + surf_heating_rate * time);
462  amrex::Print() << "Surface temp at t=" << time << ": "
463  << surf_temp + surf_heating_rate * time << std::endl;
464  }
465  }
466  }

Member Data Documentation

◆ cnk_a

amrex::Real SurfaceLayer::cnk_a {0.0185}
private

Referenced by SurfaceLayer().

◆ cnk_visc

bool SurfaceLayer::cnk_visc {false}
private

Referenced by SurfaceLayer().

◆ custom_qstar

amrex::Real SurfaceLayer::custom_qstar {0}
private

Referenced by SurfaceLayer().

◆ custom_rhosurf

amrex::Real SurfaceLayer::custom_rhosurf {0}
private

Referenced by SurfaceLayer().

◆ custom_tstar

amrex::Real SurfaceLayer::custom_tstar {0}
private

Referenced by SurfaceLayer().

◆ custom_ustar

amrex::Real SurfaceLayer::custom_ustar {0}
private

Referenced by SurfaceLayer().

◆ default_land_surf_moist

amrex::Real SurfaceLayer::default_land_surf_moist {0.}
private

◆ default_land_surf_temp

amrex::Real SurfaceLayer::default_land_surf_temp {300.}
private

◆ depth

amrex::Real SurfaceLayer::depth {30.0}
private

Referenced by SurfaceLayer().

◆ flux_type

FluxCalcType SurfaceLayer::flux_type {FluxCalcType::MOENG}

◆ m_bdy_time_interval

amrex::Real SurfaceLayer::m_bdy_time_interval
private

◆ m_eddyDiffs_lev

amrex::Vector<amrex::MultiFab*> SurfaceLayer::m_eddyDiffs_lev
private

◆ m_geom

amrex::Vector<amrex::Geometry> SurfaceLayer::m_geom
private

◆ m_Hwave_lev

amrex::Vector<amrex::MultiFab*> SurfaceLayer::m_Hwave_lev
private

◆ m_include_wstar

bool SurfaceLayer::m_include_wstar = false
private

Referenced by SurfaceLayer().

◆ m_lmask_lev

amrex::Vector<amrex::Vector<amrex::iMultiFab*> > SurfaceLayer::m_lmask_lev
private

◆ m_lsm_data_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > SurfaceLayer::m_lsm_data_lev
private

◆ m_lsm_flux_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > SurfaceLayer::m_lsm_flux_lev
private

◆ m_Lwave_lev

amrex::Vector<amrex::MultiFab*> SurfaceLayer::m_Lwave_lev
private

◆ m_ma

MOSTAverage SurfaceLayer::m_ma
private

◆ m_rotate

bool SurfaceLayer::m_rotate = false
private

◆ m_sst_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > SurfaceLayer::m_sst_lev
private

◆ m_tsk_lev

amrex::Vector<amrex::Vector<amrex::MultiFab*> > SurfaceLayer::m_tsk_lev
private

◆ m_var_z0

bool SurfaceLayer::m_var_z0 {false}
private

◆ moist_type

MoistCalcType SurfaceLayer::moist_type {MoistCalcType::ADIABATIC}

Referenced by SurfaceLayer().

◆ olen

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::olen
private

◆ pblh

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::pblh
private

◆ pblh_type

PBLHeightCalcType SurfaceLayer::pblh_type {PBLHeightCalcType::None}

Referenced by SurfaceLayer().

◆ q_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::q_star
private

◆ q_surf

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::q_surf
private

◆ rough_type_land

RoughCalcType SurfaceLayer::rough_type_land {RoughCalcType::CONSTANT}

Referenced by SurfaceLayer().

◆ rough_type_sea

RoughCalcType SurfaceLayer::rough_type_sea {RoughCalcType::CHARNOCK}

◆ specified_rho_surf

bool SurfaceLayer::specified_rho_surf {false}
private

◆ surf_heating_rate

amrex::Real SurfaceLayer::surf_heating_rate {0}
private

Referenced by SurfaceLayer(), and update_surf_temp().

◆ surf_moist

amrex::Real SurfaceLayer::surf_moist
private

Referenced by SurfaceLayer().

◆ surf_moist_flux

amrex::Real SurfaceLayer::surf_moist_flux {0}
private

Referenced by SurfaceLayer().

◆ surf_temp

amrex::Real SurfaceLayer::surf_temp
private

Referenced by SurfaceLayer(), and update_surf_temp().

◆ surf_temp_flux

amrex::Real SurfaceLayer::surf_temp_flux {0}
private

Referenced by SurfaceLayer().

◆ t_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::t_star
private

◆ t_surf

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::t_surf
private

◆ theta_type

◆ u_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::u_star
private

◆ use_moisture

bool SurfaceLayer::use_moisture
private

Referenced by SurfaceLayer().

◆ w_star

amrex::Vector<std::unique_ptr<amrex::MultiFab> > SurfaceLayer::w_star
private

◆ z0_const

amrex::Real SurfaceLayer::z0_const {0.1}
private

◆ z_0

amrex::Vector<amrex::FArrayBox> SurfaceLayer::z_0
private

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