ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Functions
ERF_ComputeStrain_N.cpp File Reference
#include <ERF_Diffusion.H>
#include "ERF_EddyViscosity.H"
Include dependency graph for ERF_ComputeStrain_N.cpp:

Functions

void ComputeStrain_N (Box bx, Box bxcc, Box tbxxy, Box tbxxz, Box tbxyz, Box domain, const Array4< const Real > &u, const Array4< const Real > &v, const Array4< const Real > &w, Array4< Real > &tau11, Array4< Real > &tau22, Array4< Real > &tau33, Array4< Real > &tau12, Array4< Real > &tau13, Array4< Real > &, Array4< Real > &tau23, Array4< Real > &, const GpuArray< Real, AMREX_SPACEDIM > &dxInv, const Array4< const Real > &mf_mx, const Array4< const Real > &mf_ux, const Array4< const Real > &mf_vx, const Array4< const Real > &mf_my, const Array4< const Real > &mf_uy, const Array4< const Real > &mf_vy, const BCRec *bc_ptr, Array4< Real > &SmnSmn_a, const Real)
 

Function Documentation

◆ ComputeStrain_N()

void ComputeStrain_N ( Box  bx,
Box  bxcc,
Box  tbxxy,
Box  tbxxz,
Box  tbxyz,
Box  domain,
const Array4< const Real > &  u,
const Array4< const Real > &  v,
const Array4< const Real > &  w,
Array4< Real > &  tau11,
Array4< Real > &  tau22,
Array4< Real > &  tau33,
Array4< Real > &  tau12,
Array4< Real > &  tau13,
Array4< Real > &  ,
Array4< Real > &  tau23,
Array4< Real > &  ,
const GpuArray< Real, AMREX_SPACEDIM > &  dxInv,
const Array4< const Real > &  mf_mx,
const Array4< const Real > &  mf_ux,
const Array4< const Real > &  mf_vx,
const Array4< const Real > &  mf_my,
const Array4< const Real > &  mf_uy,
const Array4< const Real > &  mf_vy,
const BCRec *  bc_ptr,
Array4< Real > &  SmnSmn_a,
const  Real 
)

Function for computing the strain rates without terrain.

Parameters
[in]bxcccell center box for tau_ii
[in]tbxxynodal xy box for tau_12
[in]tbxxznodal xz box for tau_13
[in]tbxyznodal yz box for tau_23
[in]ux-direction velocity
[in]vy-direction velocity
[in]wz-direction velocity
[out]tau1111 strain
[out]tau2222 strain
[out]tau3333 strain
[out]tau1212 strain
[out]tau1313 strain
[out]tau2323 strain
[out]tau3131 strain
[out]tau3232 strain
[in]bc_ptrcontainer with boundary condition types
[in]dxInvinverse cell size array
[in]mf_mmap factor at cell center
[in]mf_umap factor at x-face
[in]mf_vmap factor at y-face
[in]implicit_fac– factor of implicitness for vertical differences only
52 {
53  // Convert domain to each index type to test if we are on Dirichlet boundary
54  Box domain_xy = convert(domain, tbxxy.ixType());
55  Box domain_xz = convert(domain, tbxxz.ixType());
56  Box domain_yz = convert(domain, tbxyz.ixType());
57 
58  const auto& dom_lo = lbound(domain);
59  const auto& dom_hi = ubound(domain);
60 
61  // Dirichlet on left or right plane
62  bool xl_v_dir = ( (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir) ||
63  (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ||
64  (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir_ingested) );
65  xl_v_dir = ( xl_v_dir && (tbxxy.smallEnd(0) == domain_xy.smallEnd(0)) );
66 
67  bool xh_v_dir = ( (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir) ||
68  (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ||
69  (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir_ingested) );
70  xh_v_dir = ( xh_v_dir && (tbxxy.bigEnd(0) == domain_xy.bigEnd(0)) );
71 
72  bool xl_w_dir = ( (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir) ||
73  (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ||
74  (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir_ingested) );
75  xl_w_dir = ( xl_w_dir && (tbxxz.smallEnd(0) == domain_xz.smallEnd(0)) );
76 
77  bool xh_w_dir = ( (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir) ||
78  (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ||
79  (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir_ingested) );
80  xh_w_dir = ( xh_w_dir && (tbxxz.bigEnd(0) == domain_xz.bigEnd(0)) );
81 
82  // Dirichlet on front or back plane
83  bool yl_u_dir = ( (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir) ||
84  (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ||
85  (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir_ingested) );
86  yl_u_dir = ( yl_u_dir && (tbxxy.smallEnd(1) == domain_xy.smallEnd(1)) );
87 
88  bool yh_u_dir = ( (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir) ||
89  (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ||
90  (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir_ingested) );
91  yh_u_dir = ( yh_u_dir && (tbxxy.bigEnd(1) == domain_xy.bigEnd(1)) );
92 
93  bool yl_w_dir = ( (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir) ||
94  (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ||
95  (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir_ingested) );
96  yl_w_dir = ( yl_w_dir && (tbxyz.smallEnd(1) == domain_yz.smallEnd(1)) );
97 
98  bool yh_w_dir = ( (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir) ||
99  (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ||
100  (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir_ingested) );
101  yh_w_dir = ( yh_w_dir && (tbxyz.bigEnd(1) == domain_yz.bigEnd(1)) );
102 
103  // Dirichlet on top or bottom plane
104  bool zl_u_dir = ( (bc_ptr[BCVars::xvel_bc].lo(2) == ERFBCType::ext_dir) ||
105  (bc_ptr[BCVars::xvel_bc].lo(2) == ERFBCType::ext_dir_ingested) );
106  zl_u_dir = ( zl_u_dir && (tbxxz.smallEnd(2) == domain_xz.smallEnd(2)) );
107 
108  bool zh_u_dir = ( (bc_ptr[BCVars::xvel_bc].hi(2) == ERFBCType::ext_dir) ||
109  (bc_ptr[BCVars::xvel_bc].hi(2) == ERFBCType::ext_dir_ingested) );
110  zh_u_dir = ( zh_u_dir && (tbxxz.bigEnd(2) == domain_xz.bigEnd(2)) );
111 
112  bool zl_v_dir = ( (bc_ptr[BCVars::yvel_bc].lo(2) == ERFBCType::ext_dir) ||
113  (bc_ptr[BCVars::yvel_bc].lo(2) == ERFBCType::ext_dir_ingested) );
114  zl_v_dir = ( zl_v_dir && (tbxyz.smallEnd(2) == domain_yz.smallEnd(2)) );
115 
116  bool zh_v_dir = ( (bc_ptr[BCVars::yvel_bc].hi(2) == ERFBCType::ext_dir) ||
117  (bc_ptr[BCVars::yvel_bc].hi(2) == ERFBCType::ext_dir_ingested) );
118  zh_v_dir = ( zh_v_dir && (tbxyz.bigEnd(2) == domain_yz.bigEnd(2)) );
119 
120  //***********************************************************************************
121  // X-Dirichlet
122  //***********************************************************************************
123  if (xl_v_dir) {
124  Box planexy = tbxxy; planexy.setBig(0, planexy.smallEnd(0) );
125  tbxxy.growLo(0,-1);
126  bool need_to_test = (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ? true : false;
127 
128  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
129  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
130  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
131  if (!need_to_test || u(dom_lo.x,j,k) >= 0.) {
132  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
133  + (-(8./3.) * v(i-1,j,k) + 3. * v(i,j,k) - (1./3.) * v(i+1,j,k))*dxInv[0]*mfx );
134  } else {
135  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy +
136  (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
137  }
138  });
139  }
140  if (xh_v_dir) {
141  // note: tilebox xy should be nodal, so i|i-1|i-2 at the bigEnd is analogous to i-1|i|i+1 at the smallEnd
142  Box planexy = tbxxy; planexy.setSmall(0, planexy.bigEnd(0) );
143  tbxxy.growHi(0,-1);
144  bool need_to_test = (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ? true : false;
145 
146  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
147  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
148  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
149  if (!need_to_test || u(dom_hi.x+1,j,k) <= 0.) {
150  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
151  - (-(8./3.) * v(i,j,k) + 3. * v(i-1,j,k) - (1./3.) * v(i-2,j,k))*dxInv[0]*mfx );
152  } else {
153  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy +
154  (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
155  }
156  });
157  }
158 
159  if (xl_w_dir) {
160  Box planexz = tbxxz; planexz.setBig(0, planexz.smallEnd(0) );
161  tbxxz.growLo(0,-1);
162  bool need_to_test = (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ? true : false;
163 
164  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
165  Real mfx = mf_ux(i,j,0);
166  if (!need_to_test || u(dom_lo.x,j,k) >= 0.) {
167  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
168  + (-(8./3.) * w(i-1,j,k) + 3. * w(i,j,k) - (1./3.) * w(i+1,j,k))*dxInv[0]*mfx );
169  } else {
170  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
171  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
172  }
173  });
174  }
175  if (xh_w_dir) {
176  // note: tilebox xz should be nodal, so i|i-1|i-2 at the bigEnd is analogous to i-1|i|i+1 at the smallEnd
177  Box planexz = tbxxz; planexz.setSmall(0, planexz.bigEnd(0) );
178  tbxxz.growHi(0,-1);
179  bool need_to_test = (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ? true : false;
180 
181  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
182  Real mfx = mf_ux(i,j,0);
183  if (!need_to_test || u(dom_hi.x+1,j,k) <= 0.) {
184  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
185  - (-(8./3.) * w(i,j,k) + 3. * w(i-1,j,k) - (1./3.) * w(i-2,j,k))*dxInv[0]*mfx );
186  } else {
187  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
188  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
189  }
190  });
191  }
192 
193  //***********************************************************************************
194  // Y-Dirichlet
195  //***********************************************************************************
196  if (yl_u_dir) {
197  Box planexy = tbxxy; planexy.setBig(1, planexy.smallEnd(1) );
198  tbxxy.growLo(1,-1);
199  bool need_to_test = (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ? true : false;
200 
201  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
202  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
203  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
204  if (!need_to_test || v(i,dom_lo.y,k) >= 0.) {
205  tau12(i,j,k) = 0.5 * ( (-(8./3.) * u(i,j-1,k) + 3. * u(i,j,k) - (1./3.) * u(i,j+1,k))*dxInv[1]*mfy
206  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
207  } else {
208  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
209  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
210  }
211  });
212  }
213  if (yh_u_dir) {
214  // note: tilebox xy should be nodal, so j|j-1|j-2 at the bigEnd is analogous to j-1|j|j+1 at the smallEnd
215  Box planexy = tbxxy; planexy.setSmall(1, planexy.bigEnd(1) );
216  tbxxy.growHi(1,-1);
217  bool need_to_test = (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ? true : false;
218 
219  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
220  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
221  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
222  if (!need_to_test || v(i,dom_hi.y+1,k) <= 0.) {
223  tau12(i,j,k) = 0.5 * ( -(-(8./3.) * u(i,j,k) + 3. * u(i,j-1,k) - (1./3.) * u(i,j-2,k))*dxInv[1]*mfy
224  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
225  } else {
226  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
227  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
228  }
229  });
230  }
231 
232  if (yl_w_dir) {
233  Box planeyz = tbxyz; planeyz.setBig(1, planeyz.smallEnd(1) );
234  tbxyz.growLo(1,-1);
235  bool need_to_test = (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ? true : false;
236 
237  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
238  Real mfy = mf_vy(i,j,0);
239  if (!need_to_test || v(i,dom_lo.y,k) >= 0.) {
240  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
241  + (-(8./3.) * w(i,j-1,k) + 3. * w(i,j ,k) - (1./3.) * w(i,j+1,k))*dxInv[1]*mfy );
242  } else {
243  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
244  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
245  }
246  });
247  }
248  if (yh_w_dir) {
249  // note: tilebox yz should be nodal, so j|j-1|j-2 at the bigEnd is analogous to j-1|j|j+1 at the smallEnd
250  Box planeyz = tbxyz; planeyz.setSmall(1, planeyz.bigEnd(1) );
251  tbxyz.growHi(1,-1);
252  bool need_to_test = (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ? true : false;
253 
254  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
255  Real mfy = mf_vy(i,j,0);
256  if (!need_to_test || v(i,dom_hi.y+1,k) <= 0.) {
257  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
258  - (-(8./3.) * w(i,j ,k) + 3. * w(i,j-1,k) - (1./3.) * w(i,j-2,k))*dxInv[1]*mfy );
259  } else {
260  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
261  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
262  }
263  });
264  }
265 
266  //***********************************************************************************
267  // Z-Dirichlet
268  //***********************************************************************************
269  if (zl_u_dir) {
270  Box planexz = tbxxz; planexz.setBig(2, planexz.smallEnd(2) );
271  tbxxz.growLo(2,-1);
272 
273  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
274  Real mfx = mf_ux(i,j,0);
275  tau13(i,j,k) = 0.5 * ( (-(8./3.) * u(i,j,k-1) + 3. * u(i,j,k) - (1./3.) * u(i,j,k+1))*dxInv[2]
276  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
277  });
278  }
279  if (zh_u_dir) {
280  // note: tilebox xz should be nodal, so k|k-1|k-2 at the bigEnd is analogous to k-1|k|k+1 at the smallEnd
281  Box planexz = tbxxz; planexz.setSmall(2, planexz.bigEnd(2) );
282  tbxxz.growHi(2,-1);
283 
284  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
285  Real mfx = mf_ux(i,j,0);
286  tau13(i,j,k) = 0.5 * ( -(-(8./3.) * u(i,j,k) + 3. * u(i,j,k-1) - (1./3.) * u(i,j,k-2))*dxInv[2]
287  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
288  });
289  }
290 
291  if (zl_v_dir) {
292  Box planeyz = tbxyz; planeyz.setBig(2, planeyz.smallEnd(2) );
293  tbxyz.growLo(2,-1);
294 
295  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
296  Real mfy = mf_vy(i,j,0);
297  tau23(i,j,k) = 0.5 * ( (-(8./3.) * v(i,j,k-1) + 3. * v(i,j,k ) - (1./3.) * v(i,j,k+1))*dxInv[2]
298  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
299  });
300  }
301  if (zh_v_dir) {
302  // note: tilebox yz should be nodal, so k|k-1|k-2 at the bigEnd is analogous to k-1|k|k+1 at the smallEnd
303  Box planeyz = tbxyz; planeyz.setSmall(2, planeyz.bigEnd(2) );
304  tbxyz.growHi(2,-1);
305 
306  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
307  Real mfy = mf_vy(i,j,0);
308  tau23(i,j,k) = 0.5 * ( -(-(8./3.) * v(i,j,k ) + 3. * v(i,j,k-1) - (1./3.) * v(i,j,k-2))*dxInv[2]
309  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
310  });
311  }
312 
313  // Fill the remaining cells
314  //***********************************************************************************
315  // Cell centered strains
316  ParallelFor(bxcc, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
317  Real mfx = mf_mx(i,j,0);
318  Real mfy = mf_my(i,j,0);
319  tau11(i,j,k) = (u(i+1, j , k ) - u(i, j, k))*dxInv[0]*mfx;
320  tau22(i,j,k) = (v(i , j+1, k ) - v(i, j, k))*dxInv[1]*mfy;
321  tau33(i,j,k) = (w(i , j , k+1) - w(i, j, k))*dxInv[2];
322  });
323 
324  // Off-diagonal strains
325  ParallelFor(tbxxy,tbxxz,tbxyz,
326  [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
327  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
328  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
329  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
330  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
331  },
332  [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
333  Real mfx = mf_ux(i,j,0);
334  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
335  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
336  },
337  [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
338  Real mfy = mf_vy(i,j,0);
339  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
340  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
341  });
342 
343  if (SmnSmn_a) {
344  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
345  {
346  SmnSmn_a(i,j,k) = ComputeSmnSmn(i,j,k,
347  tau11,tau22,tau33,
348  tau12,tau13,tau23);
349  });
350  }
351 }
tau12
@ tau12
Definition: ERF_DataStruct.H:30
tau23
@ tau23
Definition: ERF_DataStruct.H:30
tau33
@ tau33
Definition: ERF_DataStruct.H:30
tau22
@ tau22
Definition: ERF_DataStruct.H:30
tau11
@ tau11
Definition: ERF_DataStruct.H:30
tau13
@ tau13
Definition: ERF_DataStruct.H:30
ComputeSmnSmn
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real ComputeSmnSmn(int &i, int &j, int &k, const amrex::Array4< amrex::Real const > &tau11, const amrex::Array4< amrex::Real const > &tau22, const amrex::Array4< amrex::Real const > &tau33, const amrex::Array4< amrex::Real const > &tau12, const amrex::Array4< amrex::Real const > &tau13, const amrex::Array4< amrex::Real const > &tau23)
Definition: ERF_EddyViscosity.H:63
dom_hi
const auto & dom_hi
Definition: ERF_SetupVertDiff.H:2
dom_lo
const auto & dom_lo
Definition: ERF_SetupVertDiff.H:1
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
BCVars::zvel_bc
@ zvel_bc
Definition: ERF_IndexDefines.H:89
BCVars::yvel_bc
@ yvel_bc
Definition: ERF_IndexDefines.H:88
BCVars::xvel_bc
@ xvel_bc
Definition: ERF_IndexDefines.H:87
ERFBCType::ext_dir_ingested
@ ext_dir_ingested
Definition: ERF_IndexDefines.H:212
ERFBCType::ext_dir
@ ext_dir
Definition: ERF_IndexDefines.H:209
ERFBCType::ext_dir_upwind
@ ext_dir_upwind
Definition: ERF_IndexDefines.H:217

Referenced by ERF::advance_dycore(), and erf_make_tau_terms().

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