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 start_bdy_time=0.0, 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, int max_iters=500)
 
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 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_start_bdy_time
 
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.

521  {
522  MOENG = 0, ///< Moeng functional form
523  DONELAN, ///< Donelan functional form
524  CUSTOM, ///< Custom constant flux functional form
525  ROTATE ///< Terrain rotation flux functional form
526  };

◆ MoistCalcType

Enumerator
ADIABATIC 
MOISTURE_FLUX 

Qv-flux specified.

SURFACE_MOISTURE 

Surface Qv specified.

534  {
535  ADIABATIC = 0,
536  MOISTURE_FLUX, ///< Qv-flux specified
537  SURFACE_MOISTURE ///< Surface Qv specified
538  };

◆ PBLHeightCalcType

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

◆ RoughCalcType

Enumerator
CONSTANT 

Constant z0.

CHARNOCK 
MODIFIED_CHARNOCK 
DONELAN 
WAVE_COUPLED 
540  {
541  CONSTANT = 0, ///< Constant z0
542  CHARNOCK,
543  MODIFIED_CHARNOCK,
544  DONELAN,
545  WAVE_COUPLED
546  };

◆ ThetaCalcType

Enumerator
ADIABATIC 
HEAT_FLUX 

Heat-flux specified.

SURFACE_TEMPERATURE 

Surface temperature specified.

528  {
529  ADIABATIC = 0,
530  HEAT_FLUX, ///< Heat-flux specified
531  SURFACE_TEMPERATURE ///< Surface temperature specified
532  };

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  start_bdy_time = 0.0,
amrex::Real  bdy_time_interval = 0.0 
)
inlineexplicit
42  : m_geom(geom),
43  m_rotate(use_rot_surface_flux),
44  m_start_bdy_time(start_bdy_time),
45  m_bdy_time_interval(bdy_time_interval),
46  m_ma(geom, (z_phys_nd[0] != nullptr), a_pp_prefix, a_terrain_type)
47  {
48  // We have a moisture model if Qv_prim is a valid pointer
49  use_moisture = (Qv_prim[0].get());
50 
51  // Get roughness
52  amrex::ParmParse pp("erf");
53  pp.query("most.z0", z0_const);
54 
55  // Specify how to compute the flux
56  if (use_rot_surface_flux) {
58  } else {
59  std::string flux_string_in;
60  std::string flux_string{"moeng"};
61  auto read_flux = pp.query("surface_layer.flux_type", flux_string_in);
62  if (read_flux) {
63  flux_string = amrex::toLower(flux_string_in);
64  }
65  if (flux_string == "donelan") {
67  } else if (flux_string == "moeng") {
69  } else if (flux_string == "custom") {
71  } else {
72  amrex::Abort("Undefined MOST flux type!");
73  }
74  }
75 
76  // Include w* to handle free convection (Beljaars 1995, QJRMS)
77  pp.query("most.include_wstar", m_include_wstar);
78 
79  std::string pblh_string_in;
80  std::string pblh_string{"none"};
81  auto read_pblh = pp.query("most.pblh_calc", pblh_string_in);
82  if (read_pblh) {
83  pblh_string = amrex::toLower(pblh_string_in);
84  }
85  if (pblh_string == "none") {
87  } else if (pblh_string == "mynn25") {
89  } else if (pblh_string == "mynnedmf") {
91  } else if (pblh_string == "ysu") {
93  } else if (pblh_string == "mrf") {
95  } else {
96  amrex::Abort("Undefined PBLH calc type!");
97  }
98 
99  // Get surface temperature
100  auto erf_st = pp.query("most.surf_temp", surf_temp);
101  if (erf_st) { default_land_surf_temp = surf_temp; }
102 
103  // Get surface moisture
104  bool erf_sq = false;
105  if (use_moisture) { erf_sq = pp.query("most.surf_moist", surf_moist); }
106  if (erf_sq) { default_land_surf_moist = surf_moist; }
107 
108  // Custom type user must specify the fluxes
112  pp.query("most.ustar", custom_ustar);
113  pp.query("most.tstar", custom_tstar);
114  pp.query("most.qstar", custom_qstar);
115  pp.query("most.rhosurf", custom_rhosurf);
116  if (custom_qstar != 0) {
117  AMREX_ASSERT_WITH_MESSAGE(use_moisture,
118  "Specified custom MOST qv flux without moisture model!");
119  }
120  amrex::Print() << "Using specified ustar, tstar, qstar for MOST = "
121  << custom_ustar << " " << custom_tstar << " "
122  << custom_qstar << std::endl;
123 
124  // Specify surface temperature/moisture or surface flux
125  } else {
126  if (erf_st) {
128  pp.query("most.surf_heating_rate", surf_heating_rate); // [K/h]
129  surf_heating_rate = surf_heating_rate / 3600.0; // [K/s]
130  if (pp.query("most.surf_temp_flux", surf_temp_flux)) {
131  amrex::Abort("Can only specify one of surf_temp_flux or surf_heating_rate");
132  }
133  } else {
134  pp.query("most.surf_temp_flux", surf_temp_flux);
135 
136  if (pp.query("most.surf_heating_rate", surf_heating_rate)) {
137  amrex::Abort("Can only specify one of surf_temp_flux or surf_heating_rate");
138  }
139  if (std::abs(surf_temp_flux) >
142  } else {
144  }
145 
146  }
147 
148  if (erf_sq) {
150  } else {
151  pp.query("most.surf_moist_flux", surf_moist_flux);
152  if (std::abs(surf_moist_flux) >
155  } else {
157  }
158  }
159  }
160 
161  // Make sure the inputs file doesn't try to use most.roughness_type
162  std::string bogus_input;
163  if (pp.query("most.roughness_type", bogus_input) > 0) {
164  amrex::Abort("most.roughness_type is deprecated; use "
165  "most.roughness_type_land and/or most.roughness_type_sea");
166  }
167 
168  // Specify how to compute the surface flux over land (if there is any)
169  std::string rough_land_string_in;
170  std::string rough_land_string{"constant"};
171  auto read_rough_land =
172  pp.query("most.roughness_type_land", rough_land_string_in);
173  if (read_rough_land) {
174  rough_land_string = amrex::toLower(rough_land_string_in);
175  }
176  if (rough_land_string == "constant") {
178  } else {
179  amrex::Abort("Undefined MOST roughness type for land!");
180  }
181 
182  // Specify how to compute the surface flux over sea (if there is any)
183  std::string rough_sea_string_in;
184  std::string rough_sea_string{"charnock"};
185  auto read_rough_sea = pp.query("most.roughness_type_sea", rough_sea_string_in);
186  if (read_rough_sea) {
187  rough_sea_string = amrex::toLower(rough_sea_string_in);
188  }
189  if (rough_sea_string == "charnock") {
191  pp.query("most.charnock_constant", cnk_a);
192  pp.query("most.charnock_viscosity", cnk_visc);
193  if (cnk_a > 0) {
194  amrex::Print() << "If there is water, Charnock relation with C_a="
195  << cnk_a << (cnk_visc ? " and viscosity" : "")
196  << " will be used" << std::endl;
197  } else {
198  amrex::Print() << "If there is water, Charnock relation with variable "
199  "Charnock parameter (COARE3.0)"
200  << (cnk_visc ? " and viscosity" : "") << " will be used"
201  << std::endl;
202  }
203  } else if (rough_sea_string == "coare3.0") {
205  amrex::Print() << "If there is water, Charnock relation with variable "
206  "Charnock parameter (COARE3.0)"
207  << (cnk_visc ? " and viscosity" : "") << " will be used"
208  << std::endl;
209  cnk_a = -1;
210  } else if (rough_sea_string == "donelan") {
212  } else if (rough_sea_string == "modified_charnock") {
214  pp.query("most.modified_charnock_depth", depth);
215  } else if (rough_sea_string == "wave_coupled") {
217  } else if (rough_sea_string == "constant") {
219  } else {
220  amrex::Abort("Undefined MOST roughness type for sea!");
221  }
222  } // 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:551
bool m_include_wstar
Definition: ERF_SurfaceLayer.H:564
bool m_rotate
Definition: ERF_SurfaceLayer.H:560
PBLHeightCalcType pblh_type
Definition: ERF_SurfaceLayer.H:555
bool use_moisture
Definition: ERF_SurfaceLayer.H:584
RoughCalcType rough_type_land
Definition: ERF_SurfaceLayer.H:553
amrex::Real z0_const
Definition: ERF_SurfaceLayer.H:565
amrex::Real cnk_a
Definition: ERF_SurfaceLayer.H:578
amrex::Real surf_temp
Definition: ERF_SurfaceLayer.H:567
amrex::Real m_start_bdy_time
Definition: ERF_SurfaceLayer.H:561
amrex::Real surf_moist_flux
Definition: ERF_SurfaceLayer.H:572
RoughCalcType rough_type_sea
Definition: ERF_SurfaceLayer.H:554
amrex::Real surf_moist
Definition: ERF_SurfaceLayer.H:571
amrex::Real m_bdy_time_interval
Definition: ERF_SurfaceLayer.H:562
amrex::Real custom_qstar
Definition: ERF_SurfaceLayer.H:575
amrex::Real custom_rhosurf
Definition: ERF_SurfaceLayer.H:576
@ 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:580
amrex::Real default_land_surf_moist
Definition: ERF_SurfaceLayer.H:570
amrex::Real surf_temp_flux
Definition: ERF_SurfaceLayer.H:569
amrex::Vector< amrex::Geometry > m_geom
Definition: ERF_SurfaceLayer.H:559
amrex::Real custom_tstar
Definition: ERF_SurfaceLayer.H:574
bool cnk_visc
Definition: ERF_SurfaceLayer.H:579
amrex::Real surf_heating_rate
Definition: ERF_SurfaceLayer.H:568
FluxCalcType flux_type
Definition: ERF_SurfaceLayer.H:550
MoistCalcType moist_type
Definition: ERF_SurfaceLayer.H:552
amrex::Real custom_ustar
Definition: ERF_SurfaceLayer.H:573
amrex::Real default_land_surf_temp
Definition: ERF_SurfaceLayer.H:566
@ SURFACE_TEMPERATURE
Surface temperature specified.
@ HEAT_FLUX
Heat-flux specified.
MOSTAverage m_ma
Definition: ERF_SurfaceLayer.H:586
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
182 {
183  // Pointers to the computed averages
184  const auto *const tm_ptr = m_ma.get_average(lev,2); // potential temperature
185  const auto *const qvm_ptr = m_ma.get_average(lev,3); // water vapor mixing ratio
186  const auto *const tvm_ptr = m_ma.get_average(lev,4); // virtual potential temperature
187  const auto *const umm_ptr = m_ma.get_average(lev,5); // horizontal velocity magnitude
188 
189  for (MFIter mfi(*u_star[lev]); mfi.isValid(); ++mfi)
190  {
191  Box gtbx = mfi.growntilebox();
192 
193  auto u_star_arr = u_star[lev]->array(mfi);
194  auto t_star_arr = t_star[lev]->array(mfi);
195  auto q_star_arr = q_star[lev]->array(mfi);
196  auto t_surf_arr = t_surf[lev]->array(mfi);
197  auto q_surf_arr = q_surf[lev]->array(mfi);
198  auto olen_arr = olen[lev]->array(mfi);
199 
200  const auto tm_arr = tm_ptr->array(mfi);
201  const auto tvm_arr = tvm_ptr->array(mfi);
202  const auto qvm_arr = qvm_ptr->array(mfi);
203  const auto umm_arr = umm_ptr->array(mfi);
204  const auto z0_arr = z_0[lev].array();
205 
206  // PBL height if we need to calculate wstar for the Beljaars correction
207  // TODO: can/should we apply this in LES mode?
208  const auto w_star_arr = (m_include_wstar) ? w_star[lev].get()->array(mfi) : Array4<Real> {};
209  const auto pblh_arr = (m_include_wstar) ? pblh[lev].get()->array(mfi) : Array4<Real> {};
210 
211  // Wave properties if they exist
212  const auto Hwave_arr = (m_Hwave_lev[lev]) ? m_Hwave_lev[lev]->array(mfi) : Array4<Real> {};
213  const auto Lwave_arr = (m_Lwave_lev[lev]) ? m_Lwave_lev[lev]->array(mfi) : Array4<Real> {};
214  const auto eta_arr = (m_eddyDiffs_lev[lev]) ? m_eddyDiffs_lev[lev]->array(mfi) : Array4<Real> {};
215 
216  // Land mask array if it exists
217  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
218  Array4<int> {};
219 
220  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
221  {
222  if (( is_land && lmask_arr(i,j,k) == 1) ||
223  (!is_land && lmask_arr(i,j,k) == 0))
224  {
225  most_flux.iterate_flux(i, j, k, max_iters,
226  z0_arr, umm_arr, tm_arr, tvm_arr, qvm_arr,
227  u_star_arr, w_star_arr, // to be updated
228  t_star_arr, q_star_arr, // to be updated
229  t_surf_arr, q_surf_arr, olen_arr, // to be updated
230  pblh_arr, Hwave_arr, Lwave_arr, eta_arr);
231  }
232  });
233  }
234 }
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:598
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_surf
Definition: ERF_SurfaceLayer.H:593
amrex::Vector< amrex::FArrayBox > z_0
Definition: ERF_SurfaceLayer.H:581
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_star
Definition: ERF_SurfaceLayer.H:590
amrex::Vector< amrex::MultiFab * > m_Lwave_lev
Definition: ERF_SurfaceLayer.H:602
amrex::Vector< std::unique_ptr< amrex::MultiFab > > w_star
Definition: ERF_SurfaceLayer.H:588
amrex::Vector< std::unique_ptr< amrex::MultiFab > > u_star
Definition: ERF_SurfaceLayer.H:587
amrex::Vector< std::unique_ptr< amrex::MultiFab > > q_surf
Definition: ERF_SurfaceLayer.H:594
amrex::Vector< amrex::MultiFab * > m_Hwave_lev
Definition: ERF_SurfaceLayer.H:601
amrex::Vector< std::unique_ptr< amrex::MultiFab > > t_star
Definition: ERF_SurfaceLayer.H:589
amrex::Vector< amrex::MultiFab * > m_eddyDiffs_lev
Definition: ERF_SurfaceLayer.H:603
amrex::Vector< std::unique_ptr< amrex::MultiFab > > olen
Definition: ERF_SurfaceLayer.H:591
amrex::Vector< std::unique_ptr< amrex::MultiFab > > pblh
Definition: ERF_SurfaceLayer.H:592

◆ 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 
)
578 {
579  est.compute_pblh(m_geom[lev],z_phys_cc, pblh[lev].get(),
580  vars[lev][Vars::cons],m_lmask_lev[lev][0],
581  moisture_indices);
582 }
@ 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
305 {
306  bool rotate = m_rotate;
307  const int klo = m_geom[lev].Domain().smallEnd(2);
308  const auto& dxInv = m_geom[lev].InvCellSizeArray();
309  for (MFIter mfi(*mfs[0]); mfi.isValid(); ++mfi)
310  {
311  // Get field arrays
312  const auto cons_arr = mfs[Vars::cons]->array(mfi);
313  const auto velx_arr = mfs[Vars::xvel]->array(mfi);
314  const auto vely_arr = mfs[Vars::yvel]->array(mfi);
315  const auto velz_arr = mfs[Vars::zvel]->array(mfi);
316 
317  // Diffusive stress vars
318  auto t13_arr = Tau_lev[TauType::tau13]->array(mfi);
319  auto t31_arr = (Tau_lev[TauType::tau31]) ? Tau_lev[TauType::tau31]->array(mfi) : Array4<Real>{};
320 
321  auto t23_arr = Tau_lev[TauType::tau23]->array(mfi);
322  auto t32_arr = (Tau_lev[TauType::tau32]) ? Tau_lev[TauType::tau32]->array(mfi) : Array4<Real>{};
323 
324  auto hfx3_arr = zheat_flux->array(mfi);
325  auto qfx3_arr = (zqv_flux) ? zqv_flux->array(mfi) : Array4<Real>{};
326 
327  // Rotated stress vars
328  auto t11_arr = (m_rotate) ? Tau_lev[TauType::tau11]->array(mfi) : Array4<Real>{};
329  auto t22_arr = (m_rotate) ? Tau_lev[TauType::tau22]->array(mfi) : Array4<Real>{};
330  auto t33_arr = (m_rotate) ? Tau_lev[TauType::tau33]->array(mfi) : Array4<Real>{};
331  auto t12_arr = (m_rotate) ? Tau_lev[TauType::tau12]->array(mfi) : Array4<Real>{};
332  auto t21_arr = (m_rotate) ? Tau_lev[TauType::tau21]->array(mfi) : Array4<Real>{};
333 
334  auto hfx1_arr = (m_rotate) ? xheat_flux->array(mfi) : Array4<Real>{};
335  auto hfx2_arr = (m_rotate) ? yheat_flux->array(mfi) : Array4<Real>{};
336  auto qfx1_arr = (m_rotate && xqv_flux) ? xqv_flux->array(mfi) : Array4<Real>{};
337  auto qfx2_arr = (m_rotate && yqv_flux) ? yqv_flux->array(mfi) : Array4<Real>{};
338 
339  // Terrain
340  const auto zphys_arr = (z_phys) ? z_phys->const_array(mfi) : Array4<const Real>{};
341 
342  // Get average arrays
343  const auto *const u_mean = m_ma.get_average(lev,0);
344  const auto *const v_mean = m_ma.get_average(lev,1);
345  const auto *const t_mean = m_ma.get_average(lev,2);
346  const auto *const q_mean = m_ma.get_average(lev,3);
347  const auto *const u_mag_mean = m_ma.get_average(lev,5);
348 
349  const auto um_arr = u_mean->array(mfi);
350  const auto vm_arr = v_mean->array(mfi);
351  const auto tm_arr = t_mean->array(mfi);
352  const auto qm_arr = q_mean->array(mfi);
353  const auto umm_arr = u_mag_mean->array(mfi);
354 
355  // Get derived arrays
356  const auto u_star_arr = u_star[lev]->array(mfi);
357  const auto t_star_arr = t_star[lev]->array(mfi);
358  const auto q_star_arr = q_star[lev]->array(mfi);
359  const auto t_surf_arr = t_surf[lev]->array(mfi);
360  const auto q_surf_arr = q_surf[lev]->array(mfi);
361 
362  // Get LSM fluxes
363  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
364  Array4<int> {};
365  auto lsm_flux_arr = (m_lsm_flux_lev[lev][0]) ? m_lsm_flux_lev[lev][0]->array(mfi) :
366  Array4<Real> {};
367 
368  // Rho*Theta flux
369  //============================================================================
370  Box bx = mfi.tilebox();
371  if (bx.smallEnd(2) != klo) { continue; }
372  bx.makeSlab(2,klo);
373  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
374  {
375  Real Tflux = flux_comp.compute_t_flux(i, j, k,
376  cons_arr, velx_arr, vely_arr,
377  umm_arr, tm_arr, u_star_arr,
378  t_star_arr, t_surf_arr);
379 
380  if (rotate) {
381  rotate_scalar_flux(i, j, k, Tflux, dxInv, zphys_arr,
382  hfx1_arr, hfx2_arr, hfx3_arr);
383  } else {
384  hfx3_arr(i,j,klo) = Tflux;
385  int is_land = (lmask_arr) ? lmask_arr(i,j,klo) : 1;
386  if (is_land && lsm_flux_arr) {
387  lsm_flux_arr(i,j,k) = Tflux;
388  }
389  }
390  });
391 
392  // Rho*Qv flux
393  //============================================================================
394  if (use_moisture) {
395  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
396  {
397  Real Qflux = flux_comp.compute_q_flux(i, j, k,
398  cons_arr, velx_arr, vely_arr,
399  umm_arr, qm_arr, u_star_arr,
400  q_star_arr, q_surf_arr);
401 
402  if (rotate) {
403  rotate_scalar_flux(i, j, k, Qflux, dxInv, zphys_arr,
404  qfx1_arr, qfx2_arr, qfx3_arr);
405  } else {
406  qfx3_arr(i,j,k) = Qflux;
407  }
408  });
409  } // custom
410 
411  // Rho*u flux
412  //============================================================================
413  Box bxx = surroundingNodes(bx,0);
414  ParallelFor(bxx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
415  {
416  Real stressx = flux_comp.compute_u_flux(i, j, k,
417  cons_arr, velx_arr, vely_arr,
418  umm_arr, um_arr, u_star_arr);
419 
420  if (rotate) {
421  rotate_stress_tensor(i, j, k, stressx, dxInv, zphys_arr,
422  velx_arr, vely_arr, velz_arr,
423  t11_arr, t22_arr, t33_arr,
424  t12_arr, t21_arr,
425  t13_arr, t31_arr,
426  t23_arr, t32_arr);
427  } else {
428  t13_arr(i,j,k) = stressx;
429  if (t31_arr) { t31_arr(i,j,k) = stressx; }
430  }
431  });
432 
433  // Rho*v flux
434  //============================================================================
435  Box bxy = surroundingNodes(bx,1);
436  ParallelFor(bxy, [=] AMREX_GPU_DEVICE (int i, int j, int k)
437  {
438  Real stressy = flux_comp.compute_v_flux(i, j, k,
439  cons_arr, velx_arr, vely_arr,
440  umm_arr, vm_arr, u_star_arr);
441 
442  // NOTE: One stress rotation for ALL the stress components
443  if (!rotate) {
444  t23_arr(i,j,k) = stressy;
445  if (t32_arr) { t32_arr(i,j,k) = stressy; }
446  }
447  });
448  } // mfiter
449 }
@ 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:600
@ 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_tsurf_with_sst_and_tsk()

void SurfaceLayer::fill_tsurf_with_sst_and_tsk ( const int &  lev,
const amrex::Real &  time 
)
454 {
455  int n_times_in_sst = m_sst_lev[lev].size();
456 
457  int n_time_lo, n_time_hi;
458  Real alpha;
459 
460  if (n_times_in_sst > 1) {
461  // Time interpolation
462  Real dT = m_bdy_time_interval;
463  Real time_since_start = time - m_start_bdy_time;
464  int n_time = static_cast<int>( time_since_start / dT);
465  n_time_lo = n_time;
466  n_time_hi = n_time+1;
467  alpha = (time_since_start - n_time * dT) / dT;
468  AMREX_ALWAYS_ASSERT( (n_time >= 0) && (n_time < (m_sst_lev[lev].size()-1)));
469  } else {
470  n_time_lo = 0;
471  n_time_hi = 0;
472  alpha = 1.0;
473  }
474  AMREX_ALWAYS_ASSERT( alpha >= 0. && alpha <= 1.0);
475 
476  Real oma = 1.0 - alpha;
477 
478  // Define a default land surface temperature if we don't read in tsk
479  Real lst = default_land_surf_temp;
480 
481  bool use_tsk = (m_tsk_lev[lev][0]);
482 
483  // Populate t_surf
484  for (MFIter mfi(*t_surf[lev]); mfi.isValid(); ++mfi)
485  {
486  Box gtbx = mfi.growntilebox();
487 
488  auto t_surf_arr = t_surf[lev]->array(mfi);
489 
490  const auto sst_lo_arr = m_sst_lev[lev][n_time_lo]->const_array(mfi);
491  const auto sst_hi_arr = m_sst_lev[lev][n_time_hi]->const_array(mfi);
492 
493  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
494  Array4<int> {};
495 
496  if (use_tsk) {
497  const auto tsk_arr = m_tsk_lev[lev][n_time_lo]->const_array(mfi);
498  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
499  {
500  int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
501  if (!is_land) {
502  t_surf_arr(i,j,k) = oma * sst_lo_arr(i,j,k)
503  + alpha * sst_hi_arr(i,j,k);
504  } else {
505  t_surf_arr(i,j,k) = tsk_arr(i,j,k);
506  }
507  });
508  } else {
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) = lst;
517  }
518  });
519  }
520  }
521  t_surf[lev]->FillBoundary(m_geom[lev].periodicity());
522 }
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_sst_lev
Definition: ERF_SurfaceLayer.H:596
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_tsk_lev
Definition: ERF_SurfaceLayer.H:597

◆ get_lmask()

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

◆ get_lsm_tsurf()

void SurfaceLayer::get_lsm_tsurf ( const int &  lev)
526 {
527  for (MFIter mfi(*t_surf[lev]); mfi.isValid(); ++mfi)
528  {
529  Box gtbx = mfi.growntilebox();
530 
531  // TODO: LSM does not carry lateral ghost cells.
532  // This copies the valid box into the ghost cells.
533  // Fillboundary is called after this to pick up the
534  // interior ghost and periodic directions. Is there
535  // a better approach?
536  Box vbx = mfi.validbox();
537  int i_lo = vbx.smallEnd(0); int i_hi = vbx.bigEnd(0);
538  int j_lo = vbx.smallEnd(1); int j_hi = vbx.bigEnd(1);
539 
540  auto t_surf_arr = t_surf[lev]->array(mfi);
541  auto lmask_arr = (m_lmask_lev[lev][0]) ? m_lmask_lev[lev][0]->array(mfi) :
542  Array4<int> {};
543  const auto lsm_arr = m_lsm_data_lev[lev][0]->const_array(mfi);
544 
545  ParallelFor(gtbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
546  {
547  int is_land = (lmask_arr) ? lmask_arr(i,j,k) : 1;
548  if (is_land) {
549  int li = amrex::min(amrex::max(i, i_lo), i_hi);
550  int lj = amrex::min(amrex::max(j, j_lo), j_hi);
551  t_surf_arr(i,j,k) = lsm_arr(li,lj,k);
552  }
553  });
554  }
555 }
amrex::Vector< amrex::Vector< amrex::MultiFab * > > m_lsm_data_lev
Definition: ERF_SurfaceLayer.H:599

◆ get_mac_avg()

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

◆ get_olen()

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

◆ get_pblh()

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

◆ get_q_star()

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

◆ get_q_surf()

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

◆ get_t_star()

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

◆ get_t_surf()

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

◆ get_u_star()

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

◆ get_w_star()

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

◆ get_z0()

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

◆ get_zref()

amrex::Real SurfaceLayer::get_zref ( )
inline
493 { 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
497 { return m_var_z0; }
bool m_var_z0
Definition: ERF_SurfaceLayer.H:582

◆ 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
255 {
257  moeng_flux flux_comp;
258  compute_SurfaceLayer_bcs(lev, mfs, Tau_lev,
259  xheat_flux, yheat_flux, zheat_flux,
260  xqv_flux, yqv_flux, zqv_flux,
261  z_phys, flux_comp);
262  } else if (flux_type == FluxCalcType::DONELAN) {
263  donelan_flux flux_comp;
264  compute_SurfaceLayer_bcs(lev, mfs, Tau_lev,
265  xheat_flux, yheat_flux, zheat_flux,
266  xqv_flux, yqv_flux, zqv_flux,
267  z_phys, flux_comp);
268  } else if (flux_type == FluxCalcType::ROTATE) {
269  rotate_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 {
275  custom_flux flux_comp(specified_rho_surf);
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  }
281 }
bool specified_rho_surf
Definition: ERF_SurfaceLayer.H:577
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:1869
Definition: ERF_MOSTStress.H:1737
Definition: ERF_MOSTStress.H:1574
Definition: ERF_MOSTStress.H:1986

◆ lmask_min_reduce()

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

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
239  {
240  // Update MOST Average
242  Theta_prim, Qv_prim, Qr_prim,
243  z_phys_nd);
244 
245  // Get CC vars
246  amrex::MultiFab& mf = *(mfv[0]);
247 
248  amrex::ParmParse pp("erf");
249 
250  // Do we have a time-varying surface roughness that needs to be saved?
251  if (lev == 0) {
252  const int nghost = 0; // ghost cells not included
253  int lmask_min = lmask_min_reduce(*lmask_lev[0].get(), nghost);
254  amrex::ParallelDescriptor::ReduceIntMin(lmask_min);
255 
256  m_var_z0 = (lmask_min < 1) & (rough_type_sea != RoughCalcType::CONSTANT);
257  if (m_var_z0) {
258  std::string rough_sea_string{"charnock"};
259  pp.query("most.roughness_type_sea", rough_sea_string);
260  amrex::Print() << "Variable sea roughness (type " << rough_sea_string
261  << ")" << std::endl;
262  }
263  }
264 
265  if ((lev == 0) || (lev > nlevs - 1)) {
266  m_Hwave_lev.resize(nlevs);
267  m_Lwave_lev.resize(nlevs);
268  m_eddyDiffs_lev.resize(nlevs);
269 
270  m_lsm_data_lev.resize(nlevs);
271  m_lsm_flux_lev.resize(nlevs);
272 
273  m_sst_lev.resize(nlevs);
274  m_tsk_lev.resize(nlevs);
275  m_lmask_lev.resize(nlevs);
276 
277  // Size the MOST params for all levels
278  z_0.resize(nlevs);
279  u_star.resize(nlevs);
280  w_star.resize(nlevs);
281  t_star.resize(nlevs);
282  q_star.resize(nlevs);
283  t_surf.resize(nlevs);
284  q_surf.resize(nlevs);
285  olen.resize(nlevs);
286  pblh.resize(nlevs);
287  }
288 
289  // Get pointers to SST,TSK and LANDMASK data
290  int nt_tot_sst = sst_lev.size();
291  m_sst_lev[lev].resize(nt_tot_sst);
292  for (int nt(0); nt < nt_tot_sst; ++nt) {
293  m_sst_lev[lev][nt] = sst_lev[nt].get();
294  }
295  int nt_tot_tsk = tsk_lev.size();
296  m_tsk_lev[lev].resize(nt_tot_tsk);
297  for (int nt(0); nt < nt_tot_tsk; ++nt) {
298  m_tsk_lev[lev][nt] = tsk_lev[nt].get();
299  }
300  int nt_tot_lmask = lmask_lev.size();
301  m_lmask_lev[lev].resize(nt_tot_lmask);
302  for (int nt(0); nt < nt_tot_lmask; ++nt) {
303  m_lmask_lev[lev][nt] = lmask_lev[nt].get();
304  }
305 
306  // Get pointers to wave data
307  m_Hwave_lev[lev] = Hwave;
308  m_Lwave_lev[lev] = Lwave;
309  m_eddyDiffs_lev[lev] = eddyDiffs;
310 
311  // Get pointers to LSM data and Fluxes
312  int nvar = lsm_data.size();
313  m_lsm_data_lev[lev].resize(nvar);
314  m_lsm_flux_lev[lev].resize(nvar);
315  for (int n(0); n < nvar; ++n) {
316  m_lsm_data_lev[lev][n] = lsm_data[n];
317  m_lsm_flux_lev[lev][n] = lsm_flux[n];
318  }
319 
320  // Check if there is a user-specified roughness file to be read
321  std::string fname;
322  bool read_z0 = false;
323  if ( (flux_type == FluxCalcType::MOENG) ||
325  read_z0 = pp.query("most.roughness_file_name", fname);
326  }
327 
328  // Attributes for MFs and FABs
329  //--------------------------------------------------------
330  // Create a 2D ba, dm, & ghost cells
331  amrex::BoxArray ba = mf.boxArray();
332  amrex::BoxList bl2d = ba.boxList();
333  for (auto& b : bl2d) {
334  b.setRange(2, 0);
335  }
336  amrex::BoxArray ba2d(std::move(bl2d));
337  const amrex::DistributionMapping& dm = mf.DistributionMap();
338  const int ncomp = 1;
339  amrex::IntVect ng = mf.nGrowVect();
340  ng[2] = 0;
341 
342  // Z0 heights FAB
343  //--------------------------------------------------------
344  amrex::Arena* Arena_Used = amrex::The_Arena();
345 #ifdef AMREX_USE_GPU
346  Arena_Used = amrex::The_Pinned_Arena();
347 #endif
348  amrex::Box bx = amrex::grow(m_geom[lev].Domain(), ng);
349  bx.setSmall(2, 0);
350  bx.setBig(2, 0);
351  z_0[lev].resize(bx, 1, Arena_Used);
352  z_0[lev].setVal<amrex::RunOn::Device>(z0_const);
353  if (read_z0) {
354  read_custom_roughness(lev, fname);
355  }
356 
357  // 2D MFs for U*, T*, T_surf
358  //--------------------------------------------------------
359  u_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
360  u_star[lev]->setVal(1.E34);
361 
362  w_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
363  w_star[lev]->setVal(1.E34);
364 
365  t_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
366  t_star[lev]->setVal(0.0); // default to neutral
367 
368  q_star[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
369  q_star[lev]->setVal(0.0); // default to dry
370 
371  olen[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
372  olen[lev]->setVal(1.E34);
373 
374  pblh[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
375  pblh[lev]->setVal(1.E34);
376 
377  t_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
378  t_surf[lev]->setVal(default_land_surf_temp);
379 
380  q_surf[lev] = std::make_unique<amrex::MultiFab>(ba2d, dm, ncomp, ng);
381  q_surf[lev]->setVal(default_land_surf_moist);
382 
383  // TODO: Do we want lsm_data to have theta at 0 index always?
384  // Do we want an external enum struct for indexing?
385  if (m_sst_lev[lev][0] || m_tsk_lev[lev][0] || m_lsm_data_lev[lev][0]) {
386  // Valid SST, TSK or LSM data; t_surf set before computing fluxes (avoids
387  // extended lambda capture) Note that land temp will be set from m_tsk_lev
388  // while sea temp will be set from m_sst_lev
390  }
391 
392 
393  }
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:501
void read_custom_roughness(const int &lev, const std::string &fname)
Definition: ERF_SurfaceLayer.cpp:585
@ 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 
)
587 {
588  // Read the file if we are on the coarsest level
589  if (lev==0) {
590  // Only the ioproc reads the file and broadcasts
591  if (ParallelDescriptor::IOProcessor()) {
592  Print()<<"Reading MOST roughness file: "<< fname << std::endl;
593  std::ifstream file(fname);
594  Gpu::HostVector<Real> m_x,m_y,m_z0;
595  Real value1,value2,value3;
596  while(file>>value1>>value2>>value3){
597  m_x.push_back(value1);
598  m_y.push_back(value2);
599  m_z0.push_back(value3);
600  }
601  file.close();
602 
603  // Copy data to the GPU
604  int nnode = m_x.size();
605  Gpu::DeviceVector<Real> d_x(nnode),d_y(nnode),d_z0(nnode);
606  Gpu::copy(Gpu::hostToDevice, m_x.begin(), m_x.end(), d_x.begin());
607  Gpu::copy(Gpu::hostToDevice, m_y.begin(), m_y.end(), d_y.begin());
608  Gpu::copy(Gpu::hostToDevice, m_z0.begin(), m_z0.end(), d_z0.begin());
609  Real* xp = d_x.data();
610  Real* yp = d_y.data();
611  Real* z0p = d_z0.data();
612 
613  // Populate z_phys data
614  Real tol = 1.0e-4;
615  auto dx = m_geom[lev].CellSizeArray();
616  auto ProbLoArr = m_geom[lev].ProbLoArray();
617  int ilo = m_geom[lev].Domain().smallEnd(0);
618  int jlo = m_geom[lev].Domain().smallEnd(1);
619  int klo = 0;
620  int ihi = m_geom[lev].Domain().bigEnd(0);
621  int jhi = m_geom[lev].Domain().bigEnd(1);
622 
623  // Grown box with no z range
624  Box xybx = z_0[lev].box();
625  xybx.setRange(2,0);
626 
627  Array4<Real> const& z0_arr = z_0[lev].array();
628  ParallelFor(xybx, [=] AMREX_GPU_DEVICE (int i, int j, int /*k*/)
629  {
630  // Clip indices for ghost-cells
631  int ii = amrex::min(amrex::max(i,ilo),ihi);
632  int jj = amrex::min(amrex::max(j,jlo),jhi);
633 
634  // Location of nodes
635  Real x = ProbLoArr[0] + ii * dx[0];
636  Real y = ProbLoArr[1] + jj * dx[1];
637  int inode = ii + jj * (ihi-ilo+2); // stride is Nx+1
638  if (std::sqrt(std::pow(x-xp[inode],2)+std::pow(y-yp[inode],2)) < tol) {
639  z0_arr(i,j,klo) = z0p[inode];
640  } else {
641  // Unexpected list order, do brute force search
642  Real z0loc = 0.0;
643  bool found = false;
644  for (int n=0; n<nnode; ++n) {
645  Real delta=std::sqrt(std::pow(x-xp[n],2)+std::pow(y-yp[n],2));
646  if (delta < tol) {
647  found = true;
648  z0loc = z0p[n];
649  break;
650  }
651  }
652  AMREX_ASSERT_WITH_MESSAGE(found, "Location read from terrain file does not match the grid!");
653  amrex::ignore_unused(found);
654  z0_arr(i,j,klo) = z0loc;
655  }
656  });
657  } // Is ioproc
658 
659  int ioproc = ParallelDescriptor::IOProcessorNumber();
660  ParallelDescriptor::Barrier();
661  ParallelDescriptor::Bcast(z_0[lev].dataPtr(),z_0[lev].box().numPts(),ioproc);
662  } else {
663  // Create a BC mapper that uses FOEXTRAP at domain bndry
664  Vector<int> bc_lo(3,ERFBCType::foextrap);
665  Vector<int> bc_hi(3,ERFBCType::foextrap);
666  Vector<BCRec> bcr; bcr.push_back(BCRec(bc_lo.data(),bc_hi.data()));
667 
668  // Create ref ratio
669  IntVect ratio;
670  for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
671  ratio[idim] = m_geom[lev].Domain().length(idim) / m_geom[0].Domain().length(idim);
672  }
673 
674  // Create interp object and interpolate from the coarsest grid
675  Interpolater* interp = &cell_cons_interp;
676  interp->interp(z_0[0] , 0,
677  z_0[lev], 0,
678  1, z_0[lev].box(),
679  ratio, m_geom[0], m_geom[lev],
680  bcr, 0, 0, RunOn::Gpu);
681  }
682 }
@ 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,
int  max_iters = 500 
)

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

Parameters
[in]levCurrent level
[in]max_itersmaximum iterations to use
15 {
16  // Update SST data if we have a valid pointer
17  if (m_sst_lev[lev][0]) fill_tsurf_with_sst_and_tsk(lev, time);
18 
19  // TODO: we want 0 index to always be theta?
20  // Update land surface temp if we have a valid pointer
21  if (m_lsm_data_lev[lev][0]) get_lsm_tsurf(lev);
22 
23  // Fill interior ghost cells
24  t_surf[lev]->FillBoundary(m_geom[lev].periodicity());
25 
26  // Compute plane averages for all vars (regardless of flux type)
28 
29  // Do we have a constant flux for moisture?
30  bool cons_qflux = ( (moist_type == MoistCalcType::MOISTURE_FLUX) ||
32 
33  // ***************************************************************
34  // Iterate the fluxes if moeng type
35  // First iterate over land -- the only model for surface roughness
36  // over land is RoughCalcType::CONSTANT
37  // ***************************************************************
40  bool is_land = true;
43  surface_flux most_flux(m_ma.get_zref(), surf_temp_flux, surf_moist_flux, cons_qflux);
44  compute_fluxes(lev, max_iters, most_flux, is_land);
45  } else {
46  amrex::Abort("Unknown value for rough_type_land");
47  }
49  update_surf_temp(time);
51  surface_temp most_flux(m_ma.get_zref(), surf_temp_flux, surf_moist_flux, cons_qflux);
52  compute_fluxes(lev, max_iters, most_flux, is_land);
53  } else {
54  amrex::Abort("Unknown value for rough_type_land");
55  }
56  } else if ((theta_type == ThetaCalcType::ADIABATIC) &&
60  compute_fluxes(lev, max_iters, most_flux, is_land);
61  } else {
62  amrex::Abort("Unknown value for rough_type_land");
63  }
64  } else {
65  amrex::Abort("Unknown value for theta_type");
66  }
67  } // MOENG -- LAND
68 
69  // ***************************************************************
70  // Iterate the fluxes if moeng type
71  // Next iterate over sea -- the models for surface roughness
72  // over sea are CHARNOCK, DONELAN, MODIFIED_CHARNOCK or WAVE_COUPLED
73  // ***************************************************************
76  bool is_land = false;
81  cnk_a, cnk_visc, cons_qflux);
82  compute_fluxes(lev, max_iters, most_flux, is_land);
86  depth, cons_qflux);
87  compute_fluxes(lev, max_iters, most_flux, is_land);
88  } else if (rough_type_sea == RoughCalcType::DONELAN) {
91  cons_qflux);
92  compute_fluxes(lev, max_iters, most_flux, is_land);
96  cons_qflux);
97  compute_fluxes(lev, max_iters, most_flux, is_land);
98  } else {
99  amrex::Abort("Unknown value for rough_type_sea");
100  }
101 
103  update_surf_temp(time);
105  surface_temp_charnock most_flux(m_ma.get_zref(),
107  cnk_a, cnk_visc, cons_qflux);
108  compute_fluxes(lev, max_iters, most_flux, is_land);
112  depth, cons_qflux);
113  compute_fluxes(lev, max_iters, most_flux, is_land);
114  } else if (rough_type_sea == RoughCalcType::DONELAN) {
115  surface_temp_donelan most_flux(m_ma.get_zref(),
117  cons_qflux);
118  compute_fluxes(lev, max_iters, most_flux, is_land);
122  cons_qflux);
123  compute_fluxes(lev, max_iters, most_flux, is_land);
124  } else {
125  amrex::Abort("Unknown value for rough_type_sea");
126  }
127 
128  } else if ((theta_type == ThetaCalcType::ADIABATIC) &&
131  adiabatic_charnock most_flux(m_ma.get_zref(),
133  cnk_a, cnk_visc);
134  compute_fluxes(lev, max_iters, most_flux, is_land);
138  depth);
139  compute_fluxes(lev, max_iters, most_flux, is_land);
140  } else if (rough_type_sea == RoughCalcType::DONELAN) {
142  compute_fluxes(lev, max_iters, most_flux, is_land);
145  compute_fluxes(lev, max_iters, most_flux, is_land);
146  } else {
147  amrex::Abort("Unknown value for rough_type_sea");
148  }
149  } else {
150  amrex::Abort("Unknown value for theta_type");
151  }
152 
153  } // MOENG -- SEA
154 
156  if (custom_rhosurf > 0) {
157  specified_rho_surf = true;
158  u_star[lev]->setVal(std::sqrt(custom_rhosurf) * custom_ustar);
159  t_star[lev]->setVal(custom_rhosurf * custom_tstar);
160  q_star[lev]->setVal(custom_rhosurf * custom_qstar);
161  } else {
162  u_star[lev]->setVal(custom_ustar);
163  t_star[lev]->setVal(custom_tstar);
164  q_star[lev]->setVal(custom_qstar);
165  }
166  }
167 }
void compute_averages(const int &lev)
Definition: ERF_MOSTAverage.cpp:679
void update_surf_temp(const amrex::Real &time)
Definition: ERF_SurfaceLayer.H:451
void get_lsm_tsurf(const int &lev)
Definition: ERF_SurfaceLayer.cpp:525
void compute_fluxes(const int &lev, const int &max_iters, const FluxIter &most_flux, bool is_land)
Definition: ERF_SurfaceLayer.cpp:178
void fill_tsurf_with_sst_and_tsk(const int &lev, const amrex::Real &time)
Definition: ERF_SurfaceLayer.cpp:452
Definition: ERF_MOSTStress.H:141
Definition: ERF_MOSTStress.H:283
Definition: ERF_MOSTStress.H:216
Definition: ERF_MOSTStress.H:350
Definition: ERF_MOSTStress.H:91
Definition: ERF_MOSTStress.H:526
Definition: ERF_MOSTStress.H:752
Definition: ERF_MOSTStress.H:643
Definition: ERF_MOSTStress.H:858
Definition: ERF_MOSTStress.H:423
Definition: ERF_MOSTStress.H:1087
Definition: ERF_MOSTStress.H:1333
Definition: ERF_MOSTStress.H:1214
Definition: ERF_MOSTStress.H:1449
Definition: ERF_MOSTStress.H:973

◆ 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
468  {
469  m_ma.update_field_ptrs(lev, vars_old, Theta_prim, Qv_prim, Qr_prim);
470  }
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 
)
562 {
564  MYNNPBLH estimator;
565  compute_pblh(lev, vars, z_phys_cc, estimator, moisture_indices);
567  amrex::Error("YSU/MRF PBLH calc not implemented yet");
568  }
569 }
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
452  {
453  if (surf_heating_rate != 0) {
454  int nlevs = m_geom.size();
455  for (int lev = 0; lev < nlevs; lev++) {
456  t_surf[lev]->setVal(surf_temp + surf_heating_rate * time);
457  amrex::Print() << "Surface temp at t=" << time << ": "
458  << surf_temp + surf_heating_rate * time << std::endl;
459  }
460  }
461  }

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_start_bdy_time

amrex::Real SurfaceLayer::m_start_bdy_time
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: