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