ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Functions
ERF_MakeSources.cpp File Reference
#include <AMReX_MultiFab.H>
#include <AMReX_ArrayLim.H>
#include <AMReX_BCRec.H>
#include <AMReX_TableData.H>
#include <AMReX_GpuContainers.H>
#include <ERF_NumericalDiffusion.H>
#include <ERF_SrcHeaders.H>
#include <ERF_TI_slow_headers.H>
Include dependency graph for ERF_MakeSources.cpp:

Functions

void make_sources (int level, int, Real dt, Real time, Vector< MultiFab > &S_data, const MultiFab &S_prim, MultiFab &source, std::unique_ptr< MultiFab > &z_phys_cc, MultiFab *terrain_blank, const Geometry geom, const SolverChoice &solverChoice, std::unique_ptr< MultiFab > &, std::unique_ptr< MultiFab > &, std::unique_ptr< MultiFab > &mapfac_m, const Real *dptr_rhotheta_src, const Real *dptr_rhoqt_src, const Real *dptr_wbar_sub, const Vector< Real * > d_rayleigh_ptrs_at_lev, InputSoundingData &input_sounding_data, TurbulentPerturbation &turbPert)
 

Function Documentation

◆ make_sources()

void make_sources ( int  level,
int  ,
Real  dt,
Real  time,
Vector< MultiFab > &  S_data,
const MultiFab &  S_prim,
MultiFab &  source,
std::unique_ptr< MultiFab > &  z_phys_cc,
MultiFab *  terrain_blank,
const Geometry  geom,
const SolverChoice &  solverChoice,
std::unique_ptr< MultiFab > &  ,
std::unique_ptr< MultiFab > &  ,
std::unique_ptr< MultiFab > &  mapfac_m,
const Real *  dptr_rhotheta_src,
const Real *  dptr_rhoqt_src,
const Real *  dptr_wbar_sub,
const Vector< Real * >  d_rayleigh_ptrs_at_lev,
InputSoundingData &  input_sounding_data,
TurbulentPerturbation &  turbPert 
)

Function for computing the slow RHS for the evolution equations for the density, potential temperature and momentum.

Parameters
[in]levellevel of resolution
[in]nrkwhich RK stage
[in]dtslow time step
[in]S_datacurrent solution
[in]S_primprimitive variables (i.e. conserved variables divided by density)
[in]sourcesource terms for conserved variables
[in]geomContainer for geometric information
[in]solverChoiceContainer for solver parameters
[in]mapfac_umap factor at x-faces
[in]mapfac_vmap factor at y-faces
[in]dptr_rhotheta_srccustom temperature source term
[in]dptr_rhoqt_srccustom moisture source term
[in]dptr_wbar_subsubsidence source term
[in]d_rayleigh_ptrs_at_levVector of {strength of Rayleigh damping, reference value of theta} used to define Rayleigh damping
53 {
54  BL_PROFILE_REGION("erf_make_sources()");
55 
56  // *****************************************************************************
57  // Initialize source to zero since we re-compute it every RK stage
58  // *****************************************************************************
59  source.setVal(0.0);
60 
61  const bool l_use_ndiff = solverChoice.use_num_diff;
62 
63  TurbChoice tc = solverChoice.turbChoice[level];
64  const bool l_use_KE = ( (tc.les_type == LESType::Deardorff) ||
65  (tc.rans_type == RANSType::kEqn) ||
66  (tc.pbl_type == PBLType::MYNN25) );
67  const bool l_diff_KE = tc.diffuse_KE_3D;
68 
69  const Box& domain = geom.Domain();
70 
71  const GpuArray<Real, AMREX_SPACEDIM> dxInv = geom.InvCellSizeArray();
72 
73  Real* thetabar = d_rayleigh_ptrs_at_lev[Rayleigh::thetabar];
74 
75  // *****************************************************************************
76  // Planar averages for subsidence terms
77  // *****************************************************************************
78  Table1D<Real> dptr_r_plane, dptr_t_plane, dptr_qv_plane, dptr_qc_plane;
79  TableData<Real, 1> r_plane_tab, t_plane_tab, qv_plane_tab, qc_plane_tab;
80  if (dptr_wbar_sub || solverChoice.nudging_from_input_sounding || solverChoice.terrain_type == TerrainType::ImmersedForcing)
81  {
82  // Rho
83  PlaneAverage r_ave(&(S_data[IntVars::cons]), geom, solverChoice.ave_plane, true);
84  r_ave.compute_averages(ZDir(), r_ave.field());
85 
86  int ncell = r_ave.ncell_line();
87  Gpu::HostVector< Real> r_plane_h(ncell);
88  Gpu::DeviceVector< Real> r_plane_d(ncell);
89 
90  r_ave.line_average(Rho_comp, r_plane_h);
91 
92  Gpu::copyAsync(Gpu::hostToDevice, r_plane_h.begin(), r_plane_h.end(), r_plane_d.begin());
93 
94  Real* dptr_r = r_plane_d.data();
95 
96  IntVect ng_c = S_data[IntVars::cons].nGrowVect();
97  Box tdomain = domain; tdomain.grow(2,ng_c[2]);
98  r_plane_tab.resize({tdomain.smallEnd(2)}, {tdomain.bigEnd(2)});
99 
100  int offset = ng_c[2];
101  dptr_r_plane = r_plane_tab.table();
102  ParallelFor(ncell, [=] AMREX_GPU_DEVICE (int k) noexcept
103  {
104  dptr_r_plane(k-offset) = dptr_r[k];
105  });
106 
107  // Rho * Theta
108  PlaneAverage t_ave(&(S_data[IntVars::cons]), geom, solverChoice.ave_plane, true);
109  t_ave.compute_averages(ZDir(), t_ave.field());
110 
111  Gpu::HostVector< Real> t_plane_h(ncell);
112  Gpu::DeviceVector< Real> t_plane_d(ncell);
113 
114  t_ave.line_average(RhoTheta_comp, t_plane_h);
115 
116  Gpu::copyAsync(Gpu::hostToDevice, t_plane_h.begin(), t_plane_h.end(), t_plane_d.begin());
117 
118  Real* dptr_t = t_plane_d.data();
119 
120  t_plane_tab.resize({tdomain.smallEnd(2)}, {tdomain.bigEnd(2)});
121 
122  dptr_t_plane = t_plane_tab.table();
123  ParallelFor(ncell, [=] AMREX_GPU_DEVICE (int k) noexcept
124  {
125  dptr_t_plane(k-offset) = dptr_t[k];
126  });
127 
128  if (solverChoice.moisture_type != MoistureType::None)
129  {
130  Gpu::HostVector< Real> qv_plane_h(ncell), qc_plane_h(ncell);
131  Gpu::DeviceVector<Real> qv_plane_d(ncell), qc_plane_d(ncell);
132 
133  // Water vapor
134  PlaneAverage qv_ave(&(S_data[IntVars::cons]), geom, solverChoice.ave_plane, true);
135  qv_ave.compute_averages(ZDir(), qv_ave.field());
136  qv_ave.line_average(RhoQ1_comp, qv_plane_h);
137  Gpu::copyAsync(Gpu::hostToDevice, qv_plane_h.begin(), qv_plane_h.end(), qv_plane_d.begin());
138 
139  // Cloud water
140  PlaneAverage qc_ave(&(S_data[IntVars::cons]), geom, solverChoice.ave_plane, true);
141  qc_ave.compute_averages(ZDir(), qc_ave.field());
142  qc_ave.line_average(RhoQ2_comp, qc_plane_h);
143  Gpu::copyAsync(Gpu::hostToDevice, qc_plane_h.begin(), qc_plane_h.end(), qc_plane_d.begin());
144 
145  Real* dptr_qv = qv_plane_d.data();
146  Real* dptr_qc = qc_plane_d.data();
147 
148  qv_plane_tab.resize({tdomain.smallEnd(2)}, {tdomain.bigEnd(2)});
149  qc_plane_tab.resize({tdomain.smallEnd(2)}, {tdomain.bigEnd(2)});
150 
151  dptr_qv_plane = qv_plane_tab.table();
152  dptr_qc_plane = qc_plane_tab.table();
153  ParallelFor(ncell, [=] AMREX_GPU_DEVICE (int k) noexcept
154  {
155  dptr_qv_plane(k-offset) = dptr_qv[k];
156  dptr_qc_plane(k-offset) = dptr_qc[k];
157  });
158  }
159  }
160 
161  // *****************************************************************************
162  // Define source term for cell-centered conserved variables, from
163  // 1. user-defined source terms for (rho theta) and (rho q_t)
164  // 2. radiation for (rho theta)
165  // 3. Rayleigh damping for (rho theta)
166  // 4. custom forcing for (rho theta) and (rho Q1)
167  // 5. custom subsidence for (rho theta) and (rho Q1)
168  // 6. numerical diffusion for (rho theta)
169  // 7. sponging
170  // 8. turbulent perturbation
171  // 9. nudging towards input sounding values (only for theta)
172  // 10. Immersed forcing
173  // *****************************************************************************
174 
175  // ***********************************************************************************************
176  // Add remaining source terms
177  // ***********************************************************************************************
178 #ifdef _OPENMP
179 #pragma omp parallel if (Gpu::notInLaunchRegion())
180 #endif
181  {
182  for ( MFIter mfi(S_data[IntVars::cons],TileNoZ()); mfi.isValid(); ++mfi)
183  {
184  Box bx = mfi.tilebox();
185 
186  const Array4<const Real> & cell_data = S_data[IntVars::cons].array(mfi);
187  const Array4<const Real> & cell_prim = S_prim.array(mfi);
188  const Array4<Real> & cell_src = source.array(mfi);
189 
190  const Array4<const Real>& z_cc_arr = (z_phys_cc) ? z_phys_cc->const_array(mfi) : Array4<Real>{};
191 
192  const Array4<const Real>& t_blank_arr = (terrain_blank) ? terrain_blank->const_array(mfi) :
193  Array4<const Real>{};
194 
195 #ifdef ERF_USE_RRTMGP
196  // *************************************************************************************
197  // 2. Add radiation source terms to (rho theta)
198  // *************************************************************************************
199  {
200  auto const& qheating_arr = qheating_rates->const_array(mfi);
201  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
202  {
203  // Short-wavelength and long-wavelength radiation source terms
204  cell_src(i,j,k,RhoTheta_comp) += qheating_arr(i,j,k,0) + qheating_arr(i,j,k,1);
205  });
206  }
207 
208 #endif
209 
210  // *************************************************************************************
211  // 3. Add Rayleigh damping for (rho theta)
212  // *************************************************************************************
213  Real zlo = geom.ProbLo(2);
214  Real dz = geom.CellSize(2);
215  Real ztop = solverChoice.rayleigh_ztop;
216  Real zdamp = solverChoice.rayleigh_zdamp;
217  Real dampcoef = solverChoice.rayleigh_dampcoef;
218 
219  if (solverChoice.rayleigh_damp_T) {
220  int n = RhoTheta_comp;
221  int nr = Rho_comp;
222  int np = PrimTheta_comp;
223  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
224  {
225  Real zcc = (z_cc_arr) ? z_cc_arr(i,j,k) : zlo + (k+0.5)*dz;
226  Real zfrac = 1 - (ztop - zcc) / zdamp;
227  if (zfrac > 0) {
228  Real theta = cell_prim(i,j,k,np);
229  Real sinefac = std::sin(PIoTwo*zfrac);
230  cell_src(i, j, k, n) -= dampcoef*sinefac*sinefac * (theta - thetabar[k]) * cell_data(i,j,k,nr);
231  }
232  });
233  }
234 
235  // *************************************************************************************
236  // 4. Add custom forcing for (rho theta)
237  // *************************************************************************************
238  if (solverChoice.custom_rhotheta_forcing) {
239  const int n = RhoTheta_comp;
240  if (solverChoice.custom_forcing_prim_vars) {
241  const int nr = Rho_comp;
242  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
243  {
244  cell_src(i, j, k, n) += cell_data(i,j,k,nr) * dptr_rhotheta_src[k];
245  });
246  } else {
247  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
248  {
249  cell_src(i, j, k, n) += dptr_rhotheta_src[k];
250  });
251  }
252  }
253 
254  // *************************************************************************************
255  // 4. Add custom forcing for RhoQ1
256  // *************************************************************************************
257  if (solverChoice.custom_moisture_forcing) {
258  const int n = RhoQ1_comp;
259  if (solverChoice.custom_forcing_prim_vars) {
260  const int nr = Rho_comp;
261  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
262  {
263  cell_src(i, j, k, n) += cell_data(i,j,k,nr) * dptr_rhoqt_src[k];
264  });
265  } else {
266  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
267  {
268  cell_src(i, j, k, n) += dptr_rhoqt_src[k];
269  });
270  }
271  }
272 
273  // *************************************************************************************
274  // 5. Add custom subsidence for (rho theta)
275  // *************************************************************************************
276  if (solverChoice.custom_w_subsidence) {
277  const int n = RhoTheta_comp;
278  if (solverChoice.custom_forcing_prim_vars) {
279  const int nr = Rho_comp;
280  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
281  {
282  Real dzInv = (z_cc_arr) ? 1.0/ (z_cc_arr(i,j,k+1) - z_cc_arr(i,j,k-1)) : 0.5*dxInv[2];
283  Real T_hi = dptr_t_plane(k+1) / dptr_r_plane(k+1);
284  Real T_lo = dptr_t_plane(k-1) / dptr_r_plane(k-1);
285  Real wbar_cc = 0.5 * (dptr_wbar_sub[k] + dptr_wbar_sub[k+1]);
286  cell_src(i, j, k, n) -= cell_data(i,j,k,nr) * wbar_cc * (T_hi - T_lo) * dzInv;
287  });
288  } else {
289  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
290  {
291  Real dzInv = (z_cc_arr) ? 1.0/ (z_cc_arr(i,j,k+1) - z_cc_arr(i,j,k-1)) : 0.5*dxInv[2];
292  Real T_hi = dptr_t_plane(k+1) / dptr_r_plane(k+1);
293  Real T_lo = dptr_t_plane(k-1) / dptr_r_plane(k-1);
294  Real wbar_cc = 0.5 * (dptr_wbar_sub[k] + dptr_wbar_sub[k+1]);
295  cell_src(i, j, k, n) -= wbar_cc * (T_hi - T_lo) * dzInv;
296  });
297  }
298  }
299 
300  // *************************************************************************************
301  // 5. Add custom subsidence for RhoQ1 and RhoQ2
302  // *************************************************************************************
303  if (solverChoice.custom_w_subsidence && (solverChoice.moisture_type != MoistureType::None)) {
304  const int nv = RhoQ1_comp;
305  if (solverChoice.custom_forcing_prim_vars) {
306  const int nr = Rho_comp;
307  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
308  {
309  Real dzInv = (z_cc_arr) ? 1.0/ (z_cc_arr(i,j,k+1) - z_cc_arr(i,j,k-1)) : 0.5*dxInv[2];
310  Real Qv_hi = dptr_qv_plane(k+1) / dptr_r_plane(k+1);
311  Real Qv_lo = dptr_qv_plane(k-1) / dptr_r_plane(k-1);
312  Real Qc_hi = dptr_qc_plane(k+1) / dptr_r_plane(k+1);
313  Real Qc_lo = dptr_qc_plane(k-1) / dptr_r_plane(k-1);
314  Real wbar_cc = 0.5 * (dptr_wbar_sub[k] + dptr_wbar_sub[k+1]);
315  cell_src(i, j, k, nv ) -= cell_data(i,j,k,nr) * wbar_cc * (Qv_hi - Qv_lo) * dzInv;
316  cell_src(i, j, k, nv+1) -= cell_data(i,j,k,nr) * wbar_cc * (Qc_hi - Qc_lo) * dzInv;
317  });
318  } else {
319  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
320  {
321  Real dzInv = (z_cc_arr) ? 1.0/ (z_cc_arr(i,j,k+1) - z_cc_arr(i,j,k-1)) : 0.5*dxInv[2];
322  Real Qv_hi = dptr_qv_plane(k+1) / dptr_r_plane(k+1);
323  Real Qv_lo = dptr_qv_plane(k-1) / dptr_r_plane(k-1);
324  Real Qc_hi = dptr_qc_plane(k+1) / dptr_r_plane(k+1);
325  Real Qc_lo = dptr_qc_plane(k-1) / dptr_r_plane(k-1);
326  Real wbar_cc = 0.5 * (dptr_wbar_sub[k] + dptr_wbar_sub[k+1]);
327  cell_src(i, j, k, nv ) -= wbar_cc * (Qv_hi - Qv_lo) * dzInv;
328  cell_src(i, j, k, nv+1) -= wbar_cc * (Qc_hi - Qc_lo) * dzInv;
329  });
330  }
331  }
332 
333  // *************************************************************************************
334  // 6. Add numerical diffuion for rho and (rho theta)
335  // *************************************************************************************
336  if (l_use_ndiff) {
337  int sc;
338  int nc;
339 
340  const Array4<const Real>& mf_m = mapfac_m->const_array(mfi);
341 
342  // Rho is a special case
343  NumericalDiffusion_Scal(bx, sc=0, nc=1, dt, solverChoice.num_diff_coeff,
344  cell_data, cell_data, cell_src, mf_m);
345 
346  // Other scalars proceed as normal
347  NumericalDiffusion_Scal(bx, sc=1, nc=1, dt, solverChoice.num_diff_coeff,
348  cell_prim, cell_data, cell_src, mf_m);
349 
350 
351  if (l_use_KE && l_diff_KE) {
352  NumericalDiffusion_Scal(bx, sc=RhoKE_comp, nc=1, dt, solverChoice.num_diff_coeff,
353  cell_prim, cell_data, cell_src, mf_m);
354  }
355 
356  NumericalDiffusion_Scal(bx, sc=RhoScalar_comp, nc=NSCALARS, dt, solverChoice.num_diff_coeff,
357  cell_prim, cell_data, cell_src, mf_m);
358  }
359 
360  // *************************************************************************************
361  // 7. Add sponging
362  // *************************************************************************************
363  if(!(solverChoice.spongeChoice.sponge_type == "input_sponge")){
364  ApplySpongeZoneBCsForCC(solverChoice.spongeChoice, geom, bx, cell_src, cell_data);
365  }
366 
367  // *************************************************************************************
368  // 8. Add perturbation
369  // *************************************************************************************
370  if (solverChoice.pert_type == PerturbationType::Source) {
371  auto m_ixtype = S_data[IntVars::cons].boxArray().ixType(); // Conserved term
372  const amrex::Array4<const amrex::Real>& pert_cell = turbPert.pb_cell.const_array(mfi);
373  turbPert.apply_tpi(level, bx, RhoTheta_comp, m_ixtype, cell_src, pert_cell); // Applied as source term
374  }
375 
376  // *************************************************************************************
377  // 9. Add nudging towards value specified in input sounding
378  // *************************************************************************************
379  if (solverChoice.nudging_from_input_sounding)
380  {
381  int itime_n = 0;
382  int itime_np1 = 0;
383  Real coeff_n = Real(1.0);
384  Real coeff_np1 = Real(0.0);
385 
386  Real tau_inv = Real(1.0) / input_sounding_data.tau_nudging;
387 
388  int n_sounding_times = input_sounding_data.input_sounding_time.size();
389 
390  for (int nt = 1; nt < n_sounding_times; nt++) {
391  if (time > input_sounding_data.input_sounding_time[nt]) itime_n = nt;
392  }
393  if (itime_n == n_sounding_times-1) {
394  itime_np1 = itime_n;
395  } else {
396  itime_np1 = itime_n+1;
397  coeff_np1 = (time - input_sounding_data.input_sounding_time[itime_n]) /
398  (input_sounding_data.input_sounding_time[itime_np1] - input_sounding_data.input_sounding_time[itime_n]);
399  coeff_n = Real(1.0) - coeff_np1;
400  }
401 
402  const Real* theta_inp_sound_n = input_sounding_data.theta_inp_sound_d[itime_n].dataPtr();
403  const Real* theta_inp_sound_np1 = input_sounding_data.theta_inp_sound_d[itime_np1].dataPtr();
404 
405  const int n = RhoTheta_comp;
406  const int nr = Rho_comp;
407 
408  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
409  {
410  Real nudge = (coeff_n*theta_inp_sound_n[k] + coeff_np1*theta_inp_sound_np1[k]) - (dptr_t_plane(k)/dptr_r_plane(k));
411  nudge *= tau_inv;
412  cell_src(i, j, k, n) += cell_data(i, j, k, nr) * nudge;
413  });
414  }
415 
416  // *************************************************************************************
417  // 10. Add Immersed source terms
418  // *************************************************************************************
419  if (solverChoice.terrain_type == TerrainType::ImmersedForcing) {
420  const Real drag_coefficient = 10.0/dz;
421  const Real CdT = drag_coefficient;
422  const Real U_s = 1.0;
423  ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
424  {
425  const Real t_blank = t_blank_arr(i, j, k);
426  cell_src(i, j, k, RhoTheta_comp) -= t_blank * CdT * U_s * (cell_data(i,j,k,RhoTheta_comp) - dptr_t_plane(k));
427  cell_src(i, j, k, Rho_comp) -= t_blank * CdT * U_s * (cell_data(i,j,k,Rho_comp) - dptr_r_plane(k));
428  });
429  }
430 
431 
432  } // mfi
433  } // OMP
434 }
ApplySpongeZoneBCsForCC
void ApplySpongeZoneBCsForCC(const SpongeChoice &spongeChoice, const Geometry geom, const Box &bx, const Array4< Real > &cell_rhs, const Array4< const Real > &cell_data)
Definition: ERF_ApplySpongeZoneBCs.cpp:7
PIoTwo
constexpr amrex::Real PIoTwo
Definition: ERF_Constants.H:7
thetabar
@ thetabar
Definition: ERF_DataStruct.H:70
ZDir
DirectionSelector< 2 > ZDir
Definition: ERF_DirectionSelector.H:38
RhoScalar_comp
#define RhoScalar_comp
Definition: ERF_IndexDefines.H:40
Rho_comp
#define Rho_comp
Definition: ERF_IndexDefines.H:36
RhoTheta_comp
#define RhoTheta_comp
Definition: ERF_IndexDefines.H:37
RhoQ2_comp
#define RhoQ2_comp
Definition: ERF_IndexDefines.H:43
NSCALARS
#define NSCALARS
Definition: ERF_IndexDefines.H:16
PrimTheta_comp
#define PrimTheta_comp
Definition: ERF_IndexDefines.H:50
RhoQ1_comp
#define RhoQ1_comp
Definition: ERF_IndexDefines.H:42
RhoKE_comp
#define RhoKE_comp
Definition: ERF_IndexDefines.H:38
NumericalDiffusion_Scal
void NumericalDiffusion_Scal(const Box &bx, const int start_comp, const int num_comp, const Real dt, const Real num_diff_coeff, const Array4< const Real > &prim_data, const Array4< const Real > &cell_data, const Array4< Real > &rhs, const Array4< const Real > &mf_arr)
Definition: ERF_NumericalDiffusion.cpp:18
offset
AMREX_FORCE_INLINE IntVect offset(const int face_dir, const int normal)
Definition: ERF_ReadBndryPlanes.cpp:28
TileNoZ
AMREX_FORCE_INLINE amrex::IntVect TileNoZ()
Definition: ERF_TileNoZ.H:11
PlaneAverage
Definition: ERF_PlaneAverage.H:14
IntVars::cons
@ cons
Definition: ERF_IndexDefines.H:139
LsmVar_MM5::theta
@ theta
Definition: ERF_MM5.H:20
InputSoundingData::theta_inp_sound_d
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > theta_inp_sound_d
Definition: ERF_InputSoundingData.H:326
InputSoundingData::input_sounding_time
amrex::Vector< amrex::Real > input_sounding_time
Definition: ERF_InputSoundingData.H:315
InputSoundingData::tau_nudging
amrex::Real tau_nudging
Definition: ERF_InputSoundingData.H:312
SolverChoice::rayleigh_damp_T
bool rayleigh_damp_T
Definition: ERF_DataStruct.H:621
SolverChoice::rayleigh_zdamp
amrex::Real rayleigh_zdamp
Definition: ERF_DataStruct.H:623
SolverChoice::custom_rhotheta_forcing
bool custom_rhotheta_forcing
Definition: ERF_DataStruct.H:647
SolverChoice::custom_w_subsidence
bool custom_w_subsidence
Definition: ERF_DataStruct.H:649
SolverChoice::nudging_from_input_sounding
bool nudging_from_input_sounding
Definition: ERF_DataStruct.H:655
SolverChoice::rayleigh_ztop
amrex::Real rayleigh_ztop
Definition: ERF_DataStruct.H:624
SolverChoice::use_num_diff
bool use_num_diff
Definition: ERF_DataStruct.H:670
SolverChoice::custom_moisture_forcing
bool custom_moisture_forcing
Definition: ERF_DataStruct.H:648
SolverChoice::num_diff_coeff
amrex::Real num_diff_coeff
Definition: ERF_DataStruct.H:671
SolverChoice::turbChoice
amrex::Vector< TurbChoice > turbChoice
Definition: ERF_DataStruct.H:594
SolverChoice::moisture_type
MoistureType moisture_type
Definition: ERF_DataStruct.H:677
SolverChoice::custom_forcing_prim_vars
bool custom_forcing_prim_vars
Definition: ERF_DataStruct.H:651
SolverChoice::terrain_type
static TerrainType terrain_type
Definition: ERF_DataStruct.H:580
SolverChoice::pert_type
PerturbationType pert_type
Definition: ERF_DataStruct.H:667
SolverChoice::spongeChoice
SpongeChoice spongeChoice
Definition: ERF_DataStruct.H:593
SolverChoice::rayleigh_dampcoef
amrex::Real rayleigh_dampcoef
Definition: ERF_DataStruct.H:622
SolverChoice::ave_plane
int ave_plane
Definition: ERF_DataStruct.H:688
SpongeChoice::sponge_type
std::string sponge_type
Definition: ERF_SpongeStruct.H:61
TurbChoice
Definition: ERF_TurbStruct.H:31
TurbChoice::pbl_type
PBLType pbl_type
Definition: ERF_TurbStruct.H:241
TurbChoice::rans_type
RANSType rans_type
Definition: ERF_TurbStruct.H:238
TurbChoice::diffuse_KE_3D
bool diffuse_KE_3D
Definition: ERF_TurbStruct.H:256
TurbChoice::les_type
LESType les_type
Definition: ERF_TurbStruct.H:205
TurbulentPerturbation::pb_cell
amrex::MultiFab pb_cell
Definition: ERF_TurbPertStruct.H:536
TurbulentPerturbation::apply_tpi
void apply_tpi(const int &lev, const amrex::Box &vbx, const int &comp, const amrex::IndexType &m_ixtype, const amrex::Array4< amrex::Real > &src_arr, const amrex::Array4< amrex::Real const > &pert_cell)
Definition: ERF_TurbPertStruct.H:245
Here is the call graph for this function: