ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Functions
ERF_ComputeDiffusivityMYJ.cpp File Reference
#include "ERF_SurfaceLayer.H"
#include "ERF_DirectionSelector.H"
#include "ERF_Diffusion.H"
#include "ERF_Constants.H"
#include "ERF_TurbStruct.H"
#include "ERF_PBLModels.H"
#include <math.h>
Include dependency graph for ERF_ComputeDiffusivityMYJ.cpp:

Functions

void ComputeDiffusivityMYJ (double dt, const MultiFab &xvel, const MultiFab &yvel, MultiFab &cons_in, MultiFab &eddyViscosity, const Geometry &geom, const TurbChoice &, std::unique_ptr< SurfaceLayer > &, bool use_terrain_fitted_coords, bool, int, const BCRec *bc_ptr, bool, const std::unique_ptr< MultiFab > &z_phys_nd, const std::unique_ptr< MultiFab > &z_phys_cc, const MoistureComponentIndices &moisture_indices)
 

Function Documentation

◆ ComputeDiffusivityMYJ()

void ComputeDiffusivityMYJ ( double  dt,
const MultiFab &  xvel,
const MultiFab &  yvel,
MultiFab &  cons_in,
MultiFab &  eddyViscosity,
const Geometry &  geom,
const TurbChoice &  ,
std::unique_ptr< SurfaceLayer > &  ,
bool  use_terrain_fitted_coords,
bool  ,
int  ,
const BCRec *  bc_ptr,
bool  ,
const std::unique_ptr< MultiFab > &  z_phys_nd,
const std::unique_ptr< MultiFab > &  z_phys_cc,
const MoistureComponentIndices &  moisture_indices 
)

Compute turbulent diffusivities using the Mellor-Yamada-Janjic (MYJ) closure model.

Parameters
[in]dtTime step.
[in]xvelX-velocity MultiFab.
[in]yvelY-velocity MultiFab.
[in,out]cons_inConservative variables.
[out]eddyViscosityTurbulent diffusivity MultiFab.
[in]geomGrid geometry.
[in]turbChoiceTurbulence choice parameters.
[in]SurfLayerPointer to surface layer data.
[in]use_terrain_fitted_coordsWhether to use terrain-fitted coordinates.
[in]use_moistureWhether moisture variables are used.
[in]levelLevel index.
[in]bc_ptrBoundary condition pointers.
[in]vert_onlyFlag for vertical-only computation.
[in]z_phys_ndNode-centered physical height field.
[in]z_phys_ccCell-centered physical height field.
[in]moisture_indicesIndices for moisture components.
49 {
50  // Dirichlet flags to switch derivative stencil
51  bool c_ext_dir_on_zlo = ( (bc_ptr[BCVars::cons_bc].lo(2) == ERFBCType::ext_dir) );
52  bool c_ext_dir_on_zhi = ( (bc_ptr[BCVars::cons_bc].hi(2) == ERFBCType::ext_dir) );
53  bool u_ext_dir_on_zlo = ( (bc_ptr[BCVars::xvel_bc].lo(2) == ERFBCType::ext_dir) );
54  bool u_ext_dir_on_zhi = ( (bc_ptr[BCVars::xvel_bc].hi(2) == ERFBCType::ext_dir) );
55  bool v_ext_dir_on_zlo = ( (bc_ptr[BCVars::yvel_bc].lo(2) == ERFBCType::ext_dir) );
56  bool v_ext_dir_on_zhi = ( (bc_ptr[BCVars::yvel_bc].hi(2) == ERFBCType::ext_dir) );
57 
58  // Expose constants
59  Real d_kappa = KAPPA;
60 
61  // Closure coefficients (from Janjic (2002), NCEP Office Note 437)
62  Real EPS1 = Real(1.0e-12);
63  Real EPS2 = zero;
64  Real EPSRS = Real(1.0e-7);
65  Real EPSRU = Real(1.0e-7);
66  Real EPSTRB = Real(1.0e-24);
67  Real EPSL = Real(0.32);
68  Real EPSQ2 = Real(0.2);
69  Real EPSQ1 = std::sqrt(EPSQ2);
70  Real ESQHF = Real(2.5);
71  Real FH = Real(1.01);
72 
73  Real G = CONST_GRAV;
74  Real ALPHA = Real(0.3);
75  Real BETA = one/Real(273.);
76  Real EL0MAX = Real(1000.);
77  Real EL0MIN = one;
78  Real ELFC = Real(0.23)*myhalf;
79 
80  Real A1 = Real(0.659888514560862645);
81  Real A2x = Real(0.6574209922667784586);
82  Real B1 = Real(11.87799326209552761);
83  Real B2 = Real(7.226971804046074028);
84  Real C1 = Real(0.000830955950095854396);
85 
86  Real BTG = BETA*G;
87  Real RB1 = one/B1;
88 
89  Real ADNH = Real(9.)*A1*A2x*A2x*(Real(12.)*A1+three*B2)*BTG*BTG;
90  Real ADNM = Real(18.)*A1*A1*A2x*(B2-three*A2x)*BTG;
91  Real ANMH = -Real(9.)*A1*A2x*A2x*BTG*BTG;
92  Real ANMM = -three*A1*A2x*(three*A2x+three*B2*C1+Real(18.)*A1*C1-B2)*BTG;
93  Real BDNH = three*A2x*(Real(7.)*A1+B2)*BTG;
94  Real BDNM = Real(6.)*A1*A1;
95  Real BEQH = A2x*B1*BTG+three*A2x*(Real(7.)*A1+B2)*BTG;
96  Real BEQM = -A1*B1*(one-three*C1)+Real(6.)*A1*A1;
97  Real BNMH = -A2x*BTG;
98  Real BNMM = A1*(one-three*C1);
99  Real BSHH = Real(9.)*A1*A2x*A2x*BTG;
100  Real BSHM = Real(18.)*A1*A1*A2x*C1;
101  Real BSMH = -three*A1*A2x*(three*A2x+three*B2*C1+Real(12.)*A1*C1-B2)*BTG;
102  Real CESH = A2x;
103  Real CESM = A1*(one-three*C1);
104 
105  Real AEQH = Real(9.)*A1*A2x*A2x*B1*BTG*BTG
106  + Real(9.)*A1*A2x*A2x*(Real(12.)*A1+three*B2)*BTG*BTG;
107  Real AEQM = three*A1*A2x*B1*(three*A2x+three*B2*C1+Real(18.)*A1*C1-B2)*BTG
108  + Real(18.)*A1*A1*A2x*(B2-three*A2x)*BTG;
109 
110  Real REQU = -AEQH/AEQM;
111  Real EPSGH = Real(1.E-9);
112  Real EPSGM = REQU*EPSGH;
113 
114  Real UBRYL = (Real(18.)*REQU*A1*A1*A2x*B2*C1*BTG + Real(9.)*A1*A2x*A2x*B2*BTG*BTG)
115  / (REQU*ADNM+ADNH);
116  Real UBRY = (one+EPSRS)*UBRYL;
117  Real UBRY3 = three*UBRY;
118 
119  Real AUBH = Real(27.)*A1*A2x*A2x*B2*BTG*BTG-ADNH*UBRY3;
120  Real AUBM = Real(54.)*A1*A1*A2x*B2*C1*BTG-ADNM*UBRY3;
121  Real BUBH = (Real(9.)*A1*A2x+three*A2x*B2)*BTG-BDNH*UBRY3;
122  Real BUBM = Real(18.)*A1*A1*C1-BDNM*UBRY3;
123  Real CUBR = one-UBRY3;
124  Real RCUBR = one/CUBR;
125 
126 #ifdef _OPENMP
127 #pragma omp parallel if (Gpu::notInLaunchRegion())
128 #endif
129  for (MFIter mfi(eddyViscosity,false); mfi.isValid(); ++mfi) {
130 
131  const Box& bx = mfi.validbox();
132  const Array4<Real >& cell_data = cons_in.array(mfi);
133  const Array4<Real >& K_turb = eddyViscosity.array(mfi);
134  const Array4<Real const>& uvel = xvel.array(mfi);
135  const Array4<Real const>& vvel = yvel.array(mfi);
136 
137  // Ensure the box spans the vertical domain
138  const Box& dbx = geom.Domain();
139  AMREX_ALWAYS_ASSERT(bx.smallEnd(2) == dbx.smallEnd(2) && bx.bigEnd(2) == dbx.bigEnd(2));
140 
141  // Create a plane box
142  int klo = bx.smallEnd(2);
143  int khi = bx.bigEnd(2);
144  Box planexy = makeSlab(bx,2,klo);
145 
146  // Expose for GPU capture
147  const GeometryData gdata = geom.data();
148 
149  // Allocate space for integrals
150  const Box xybx = PerpendicularBox<ZDir>(bx, IntVect{0,0,0});
151  FArrayBox qturb(bx,1,The_Async_Arena());
152  FArrayBox qintegral(xybx,2,The_Async_Arena());
153  IArrayBox pbl_k(xybx,1,The_Async_Arena());
154  qintegral.setVal<RunOn::Device>(0);
155  pbl_k.setVal<RunOn::Device>(khi);
156  const Array4<Real> qint = qintegral.array();
157  const Array4<Real> qvel = qturb.array();
158  const Array4<int> k_arr = pbl_k.array();
159 
160  // Terrain and gradient calcs
161  const Array4<Real const> &z_nd_arr = z_phys_nd->array(mfi);
162  const PBLDerivativeDzInv_T pbl_derivative_dz_inv{z_phys_cc->const_array(mfi)};
163  const auto& dxInv = geom.InvCellSizeArray();
164  int izmin = geom.Domain().smallEnd(2);
165  int izmax = geom.Domain().bigEnd(2);
166 
167  // Ustar for BC
168  //MultiFab* ustar = SurfLayer->get_u_star(level);
169  //const Array4<Real const>& ustar_arr = ustar->array(mfi);
170 
171  // Vertical integrals to compute l0
172  if (use_terrain_fitted_coords) {
173  ParallelFor(planexy, [=] AMREX_GPU_DEVICE (int i, int j, int /*k*/) noexcept
174  {
175  // Locate PBL k index and set qvel
176  for (int k(klo); k<=khi; ++k) {
177  Real q2 = two * cell_data(i,j,k,RhoKE_comp) / cell_data(i,j,k,Rho_comp);
178  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(q2 > zero, "KE must have a positive value");
179  qvel(i,j,k) = std::sqrt(q2);
180  if (q2<=EPSQ2*FH) {
181  k_arr(i,j,0) = std::min(k,k_arr(i,j,0));
182  }
183  }
184 
185  // Perform integral over PBL height
186  for (int k(klo); k<=k_arr(i,j,0); ++k) {
187  const Real dz = Compute_h_zeta_AtCellCenter(i,j,k,dxInv,z_nd_arr);
188  const Real Zval = Compute_Zrel_AtCellCenter(i,j,k,z_nd_arr);
189  Gpu::Atomic::Add(&qint(i,j,0,0), Zval*qvel(i,j,k)*dz);
190  Gpu::Atomic::Add(&qint(i,j,0,1), qvel(i,j,k)*dz);
191  }
192  });
193  } else {
194  ParallelFor(planexy, [=] AMREX_GPU_DEVICE (int i, int j, int /*k*/) noexcept
195  {
196  // Locate PBL k index and set qvel
197  for (int k(klo); k<=khi; ++k) {
198  Real q2 = two * cell_data(i,j,k,RhoKE_comp) / cell_data(i,j,k,Rho_comp);
199  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(q2 > zero, "KE must have a positive value");
200  qvel(i,j,k) = std::sqrt(q2);
201  if (q2<=EPSQ2*FH) {
202  k_arr(i,j,0) = std::min(k,k_arr(i,j,0));
203  }
204  }
205 
206  // Perform integral over PBL height
207  for (int k(klo); k<=k_arr(i,j,0); ++k) {
208  // Not multiplying by dz: it's constant and would fall out when we divide qint0/qint1 anyway
209  const Real Zval = gdata.ProbLo(2) + (k + myhalf)*gdata.CellSize(2);
210  Gpu::Atomic::Add(&qint(i,j,0,0), Zval*qvel(i,j,k));
211  Gpu::Atomic::Add(&qint(i,j,0,1), qvel(i,j,k));
212  }
213  });
214  }
215 
216  // Main work to fill diffusivities
217  ParallelFor(planexy, [=] AMREX_GPU_DEVICE (int i, int j, int /*k*/) noexcept
218  {
219  // Get the PBL k index
220  int kpbl = k_arr(i,j,0);
221 
222  // Compute the integral length scale
223  Real l0 = std::max(std::min(ALPHA*qint(i,j,0,0)/qint(i,j,0,1),EL0MAX),EL0MIN);
224 
225  // Compute diffusivities in each column
226  for (int k(klo); k<=khi; ++k) {
227  // Gradients for shear and buoy production
228  const Real met_h_zeta = use_terrain_fitted_coords ? Compute_h_zeta_AtCellCenter(i,j,k,dxInv,z_nd_arr) : one;
229  Real dthetavdz, dudz, dvdz;
230  ComputeVerticalDerivativesPBL(i, j, k,
231  uvel, vvel, cell_data, izmin, izmax, pbl_derivative_dz_inv(i,j,k),
232  c_ext_dir_on_zlo, c_ext_dir_on_zhi,
233  u_ext_dir_on_zlo, u_ext_dir_on_zhi,
234  v_ext_dir_on_zlo, v_ext_dir_on_zhi,
235  dthetavdz, dudz, dvdz,
236  moisture_indices);
237 
238  // Calculate dimensional production terms
239  Real GML = std::max(dudz*dudz + dvdz*dvdz, EPSGM);
240  // NOTE: model uses BTG = beta*g in coeffs above
241  // NOTE: sign convention follows code but theory differs
242  Real GHL = dthetavdz;
243  if (std::fabs(GHL)<=EPSGH) { GHL=EPSGH; }
244 
245  // Find the maximum mixing length
246  Real ELM;
247  if (GHL >= EPSGH) {
248  if (GML/GHL <= REQU) {
249  ELM = EPSL;
250  } else {
251  Real AUBR = (AUBM*GML+AUBH*GHL)*GHL;
252  Real BUBR = BUBM*GML+BUBH*GHL;
253  Real QOL2ST = (-myhalf*BUBR+std::sqrt(BUBR*BUBR*fourth-AUBR*CUBR))*RCUBR;
254  Real ELOQ2X = one/QOL2ST;
255  ELM = std::max(std::sqrt(ELOQ2X*qvel(i,j,k)*qvel(i,j,k)),EPSL);
256  }
257  } else {
258  Real ADEN = (ADNM*GML+ADNH*GHL)*GHL;
259  Real BDEN = BDNM*GML+BDNH*GHL;
260  Real QOL2UN = -myhalf*BDEN+std::sqrt(BDEN*BDEN*fourth-ADEN);
261  Real ELOQ2X = one/(QOL2UN+EPSRU);
262  ELM = std::max(std::sqrt(ELOQ2X*qvel(i,j,k)*qvel(i,j,k)),EPSL);
263  }
264 
265  // Compute master length scale
266  Real L;
267  if (k>kpbl) {
268  L = std::min((met_h_zeta/dxInv[2])*ELFC, ELM);
269  } else {
270  const Real zval = use_terrain_fitted_coords ? Compute_Zrel_AtCellCenter(i,j,k,z_nd_arr)
271  : gdata.ProbLo(2) + (k + myhalf)*gdata.CellSize(2);
272  L = std::min(l0*d_kappa*zval / (d_kappa*zval + l0), ELM);
273  }
274 
275  // Update qvel from production and dissipation
276  Real AEQU = (AEQM*GML+AEQH*GHL)*GHL;
277  Real BEQU = BEQM*GML+BEQH*GHL;
278 
279  Real EQOL2 = -myhalf*BEQU+std::sqrt(BEQU*BEQU*fourth-AEQU);
280 
281  if ( ((GML+GHL*GHL)<=EPSTRB) ||
282  ((GHL>=EPSGH) && ((GML/GHL)<=REQU)) ||
283  (EQOL2<=EPS2) ) {
284  L = EPSL;
285  qvel(i,j,k) = EPSQ1;
286  } else {
287  Real ANUM=(ANMM*GML+ANMH*GHL)*GHL;
288  Real BNUM= BNMM*GML+BNMH*GHL;
289 
290  Real ADEN=(ADNM*GML+ADNH*GHL)*GHL;
291  Real BDEN= BDNM*GML+BDNH*GHL;
292  Real CDEN= one;
293 
294  Real ARHS=-(ANUM*BDEN-BNUM*ADEN)*two;
295  Real BRHS=- ANUM*Real(4.);
296  Real CRHS=- BNUM*two;
297 
298  Real DLOQ1=L/qvel(i,j,k);
299 
300  Real ELOQ21=one/EQOL2;
301  Real ELOQ11=std::sqrt(ELOQ21);
302  Real ELOQ31=ELOQ21*ELOQ11;
303  Real ELOQ41=ELOQ21*ELOQ21;
304  Real ELOQ51=ELOQ21*ELOQ31;
305 
306  Real RDEN1=one/(ADEN*ELOQ41+BDEN*ELOQ21+CDEN);
307 
308  Real RHSP1=(ARHS*ELOQ51+BRHS*ELOQ31+CRHS*ELOQ11)*RDEN1*RDEN1;
309 
310  Real DTTURBL = static_cast<Real>(dt);
311  Real ELOQ12=std::max(ELOQ11+(DLOQ1-ELOQ11)*exp(RHSP1*DTTURBL),EPS1);
312 
313  Real ELOQ22=ELOQ12*ELOQ12;
314  Real ELOQ32=ELOQ22*ELOQ12;
315  Real ELOQ42=ELOQ22*ELOQ22;
316  Real ELOQ52=ELOQ22*ELOQ32;
317 
318  Real RDEN2=one/(ADEN*ELOQ42+BDEN*ELOQ22+CDEN);
319  Real RHS2 =-(ANUM*ELOQ42+BNUM*ELOQ22)*RDEN2+RB1;
320  Real RHSP2= (ARHS*ELOQ52+BRHS*ELOQ32+CRHS*ELOQ12)*RDEN2*RDEN2;
321  Real RHST2=RHS2/RHSP2;
322 
323  Real ELOQ13=std::max(ELOQ12-RHST2+(RHST2+DLOQ1-ELOQ12)*exp(RHSP2*DTTURBL),EPS1);
324 
325  Real ELOQN=ELOQ13;
326  if (ELOQN>EPS1) {
327  qvel(i,j,k) = std::max(L/ELOQN,EPSQ1);
328  if (qvel(i,j,k)==EPSQ1) {L = EPSL; }
329  } else {
330  L = EPSL;
331  qvel(i,j,k) = EPSQ1;
332  }
333  }
334  /*
335  // Boundary condition
336  if (k==klo) {
337  Real q2 = std::pow(B1,(two/three))*ustar_arr(i,j,k)*ustar_arr(i,j,k);
338  Real q = std::max(std::sqrt(q2),EPSQ1);
339  qvel(i,j,k) = myhalf * (q + qvel(i,j,k));
340  }
341  */
342  cell_data(i,j,k,RhoKE_comp) = myhalf*cell_data(i,j,k,Rho_comp)*qvel(i,j,k)*qvel(i,j,k);
343 
344  // L^n/Q^n
345  Real ELOQ2 = L*L/(qvel(i,j,k)*qvel(i,j,k));
346  Real ELOQ4 = ELOQ2*ELOQ2;
347 
348  // COEFFICIENTS OF THE TERMS IN THE DENOMINATOR
349  Real ADEN=(ADNM*GML+ADNH*GHL)*GHL;
350  Real BDEN= BDNM*GML+BDNH*GHL;
351  Real CDEN= one;
352 
353  // COEFFICIENTS FOR THE SM DETERMINANT
354  Real BESM=BSMH*GHL;
355 
356  // COEFFICIENTS FOR THE SH DETERMINANT
357  Real BESH=BSHM*GML+BSHH*GHL;
358 
359  // 1/DENOMINATOR
360  Real RDEN=one/(ADEN*ELOQ4+BDEN*ELOQ2+CDEN);
361 
362  // SM, SH, SQ
363  Real SM=(BESM*ELOQ2+CESM)*RDEN;
364  Real SH=(BESH*ELOQ2+CESH)*RDEN;
365  Real SQ=ESQHF*SH;
366 
367  // Finally, compute the eddy viscosity/diffusivities
368  const Real rho = cell_data(i,j,k,Rho_comp);
369  K_turb(i,j,k,EddyDiff::Mom_v ) = rho * L * qvel(i,j,k) * SM;
370  K_turb(i,j,k,EddyDiff::Theta_v) = rho * L * qvel(i,j,k) * SH;
371  K_turb(i,j,k,EddyDiff::KE_v ) = rho * L * qvel(i,j,k) * SQ;
372  K_turb(i,j,k,EddyDiff::Q_v ) = rho * L * qvel(i,j,k) * SH;
373  K_turb(i,j,k,EddyDiff::Turb_lengthscale) = L;
374 
375  // NOTE: Ghost cells are handled at end of ERF_ComputeTurbulentViscosity.cpp
376 
377  } // for k
378  }); // ParFor
379  } // mfi
380 }
three
constexpr amrex::Real three
Definition: ERF_Constants.H:11
KAPPA
constexpr amrex::Real KAPPA
Definition: ERF_Constants.H:63
two
constexpr amrex::Real two
Definition: ERF_Constants.H:10
one
constexpr amrex::Real one
Definition: ERF_Constants.H:9
fourth
constexpr amrex::Real fourth
Definition: ERF_Constants.H:14
zero
constexpr amrex::Real zero
Definition: ERF_Constants.H:8
myhalf
constexpr amrex::Real myhalf
Definition: ERF_Constants.H:13
CONST_GRAV
constexpr amrex::Real CONST_GRAV
Definition: ERF_Constants.H:64
Rho_comp
#define Rho_comp
Definition: ERF_IndexDefines.H:39
RhoKE_comp
#define RhoKE_comp
Definition: ERF_IndexDefines.H:41
dxInv
amrex::GpuArray< Real, AMREX_SPACEDIM > dxInv
Definition: ERF_InitCustomPertVels_ParticleTests.H:17
khi
const int khi
Definition: ERF_InitCustomPert_Bubble.H:21
AMREX_ALWAYS_ASSERT
AMREX_ALWAYS_ASSERT(bx.length()[2]==khi+1)
AMREX_ALWAYS_ASSERT_WITH_MESSAGE
AMREX_ALWAYS_ASSERT_WITH_MESSAGE(m_cloud_chamber_config.active, "Cloud Chamber: initializer reached without a parsed configuration")
ParallelFor
ParallelFor(fab_box, [=] AMREX_GPU_DEVICE(int i, int j, int k) { qrcuten_arr(i, j, k)=Real(0);qscuten_arr(i, j, k)=Real(0);qicuten_arr(i, j, k)=Real(0);})
ComputeVerticalDerivativesPBL
AMREX_GPU_DEVICE AMREX_FORCE_INLINE void ComputeVerticalDerivativesPBL(int i, int j, int k, const amrex::Array4< const amrex::Real > &uvel, const amrex::Array4< const amrex::Real > &vvel, const amrex::Array4< const amrex::Real > &cell_data, const int izmin, const int izmax, const PBLDerivativeDzInv &dz_inv, const bool c_ext_dir_on_zlo, const bool c_ext_dir_on_zhi, const bool u_ext_dir_on_zlo, const bool u_ext_dir_on_zhi, const bool v_ext_dir_on_zlo, const bool v_ext_dir_on_zhi, amrex::Real &dthetadz, amrex::Real &dudz, amrex::Real &dvdz, const MoistureComponentIndices &moisture_indices)
Definition: ERF_PBLModels.H:277
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
Compute_Zrel_AtCellCenter
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_Zrel_AtCellCenter(const int &i, const int &j, const int &k, const amrex::Array4< const amrex::Real > &z_nd)
Definition: ERF_TerrainMetrics.H:740
Compute_h_zeta_AtCellCenter
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_h_zeta_AtCellCenter(const int &i, const int &j, const int &k, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &cellSizeInv, const amrex::Array4< const amrex::Real > &z_nd)
Definition: ERF_TerrainMetrics.H:179
BCVars::yvel_bc
@ yvel_bc
Definition: ERF_IndexDefines.H:106
BCVars::cons_bc
@ cons_bc
Definition: ERF_IndexDefines.H:89
BCVars::xvel_bc
@ xvel_bc
Definition: ERF_IndexDefines.H:105
ERFBCType::ext_dir
@ ext_dir
Definition: ERF_IndexDefines.H:292
EddyDiff::Theta_v
@ Theta_v
Definition: ERF_IndexDefines.H:250
EddyDiff::Turb_lengthscale
@ Turb_lengthscale
Definition: ERF_IndexDefines.H:254
EddyDiff::Q_v
@ Q_v
Definition: ERF_IndexDefines.H:253
EddyDiff::Mom_v
@ Mom_v
Definition: ERF_IndexDefines.H:249
EddyDiff::KE_v
@ KE_v
Definition: ERF_IndexDefines.H:251
MicVar_Kess::rho
@ rho
Definition: ERF_Kessler.H:24
Vars::xvel
@ xvel
Definition: ERF_IndexDefines.H:215
Vars::yvel
@ yvel
Definition: ERF_IndexDefines.H:216
WDM6SedCellScratch::dz
@ dz
Definition: ERF_AdvanceWDM6.cpp:270
PBLDerivativeDzInv_T
Functor for inverse vertical spacings for terrain-following grids using cell-center heights.
Definition: ERF_PBLModels.H:457

Referenced by ComputeTurbulentViscosity().

Here is the call graph for this function:
Here is the caller graph for this function: