ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Functions
ERF_ComputeStrain_N.cpp File Reference
#include <ERF_Diffusion.H>
Include dependency graph for ERF_ComputeStrain_N.cpp:

Functions

void ComputeStrain_N (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 > &tau23, 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)
 

Function Documentation

◆ ComputeStrain_N()

void ComputeStrain_N ( 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 > &  tau23,
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 
)

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
[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
46 {
47  // Convert domain to each index type to test if we are on Dirichlet boundary
48  Box domain_xy = convert(domain, tbxxy.ixType());
49  Box domain_xz = convert(domain, tbxxz.ixType());
50  Box domain_yz = convert(domain, tbxyz.ixType());
51 
52  const auto& dom_lo = lbound(domain);
53  const auto& dom_hi = ubound(domain);
54 
55  // Dirichlet on left or right plane
56  bool xl_v_dir = ( (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir) ||
57  (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ||
58  (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir_ingested) );
59  xl_v_dir = ( xl_v_dir && (tbxxy.smallEnd(0) == domain_xy.smallEnd(0)) );
60 
61  bool xh_v_dir = ( (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir) ||
62  (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ||
63  (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir_ingested) );
64  xh_v_dir = ( xh_v_dir && (tbxxy.bigEnd(0) == domain_xy.bigEnd(0)) );
65 
66  bool xl_w_dir = ( (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir) ||
67  (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ||
68  (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir_ingested) );
69  xl_w_dir = ( xl_w_dir && (tbxxz.smallEnd(0) == domain_xz.smallEnd(0)) );
70 
71  bool xh_w_dir = ( (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir) ||
72  (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ||
73  (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir_ingested) );
74  xh_w_dir = ( xh_w_dir && (tbxxz.bigEnd(0) == domain_xz.bigEnd(0)) );
75 
76  // Dirichlet on front or back plane
77  bool yl_u_dir = ( (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir) ||
78  (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ||
79  (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir_ingested) );
80  yl_u_dir = ( yl_u_dir && (tbxxy.smallEnd(1) == domain_xy.smallEnd(1)) );
81 
82  bool yh_u_dir = ( (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir) ||
83  (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ||
84  (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir_ingested) );
85  yh_u_dir = ( yh_u_dir && (tbxxy.bigEnd(1) == domain_xy.bigEnd(1)) );
86 
87  bool yl_w_dir = ( (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir) ||
88  (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ||
89  (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir_ingested) );
90  yl_w_dir = ( yl_w_dir && (tbxyz.smallEnd(1) == domain_yz.smallEnd(1)) );
91 
92  bool yh_w_dir = ( (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir) ||
93  (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ||
94  (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir_ingested) );
95  yh_w_dir = ( yh_w_dir && (tbxyz.bigEnd(1) == domain_yz.bigEnd(1)) );
96 
97  // Dirichlet on top or bottom plane
98  bool zl_u_dir = ( (bc_ptr[BCVars::xvel_bc].lo(2) == ERFBCType::ext_dir) ||
99  (bc_ptr[BCVars::xvel_bc].lo(2) == ERFBCType::ext_dir_ingested) );
100  zl_u_dir = ( zl_u_dir && (tbxxz.smallEnd(2) == domain_xz.smallEnd(2)) );
101 
102  bool zh_u_dir = ( (bc_ptr[BCVars::xvel_bc].hi(2) == ERFBCType::ext_dir) ||
103  (bc_ptr[BCVars::xvel_bc].hi(2) == ERFBCType::ext_dir_ingested) );
104  zh_u_dir = ( zh_u_dir && (tbxxz.bigEnd(2) == domain_xz.bigEnd(2)) );
105 
106  bool zl_v_dir = ( (bc_ptr[BCVars::yvel_bc].lo(2) == ERFBCType::ext_dir) ||
107  (bc_ptr[BCVars::yvel_bc].lo(2) == ERFBCType::ext_dir_ingested) );
108  zl_v_dir = ( zl_v_dir && (tbxyz.smallEnd(2) == domain_yz.smallEnd(2)) );
109 
110  bool zh_v_dir = ( (bc_ptr[BCVars::yvel_bc].hi(2) == ERFBCType::ext_dir) ||
111  (bc_ptr[BCVars::yvel_bc].hi(2) == ERFBCType::ext_dir_ingested) );
112  zh_v_dir = ( zh_v_dir && (tbxyz.bigEnd(2) == domain_yz.bigEnd(2)) );
113 
114  // X-Dirichlet
115  //***********************************************************************************
116  if (xl_v_dir) {
117  Box planexy = tbxxy; planexy.setBig(0, planexy.smallEnd(0) );
118  tbxxy.growLo(0,-1);
119  bool need_to_test = (bc_ptr[BCVars::yvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ? true : false;
120  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
121  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
122  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
123  if (!need_to_test || u(dom_lo.x,j,k) >= 0.) {
124  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
125  + (-(8./3.) * v(i-1,j,k) + 3. * v(i,j,k) - (1./3.) * v(i+1,j,k))*dxInv[0]*mfx );
126  } else {
127  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy +
128  (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
129  }
130  });
131  }
132  if (xh_v_dir) {
133  // 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
134  Box planexy = tbxxy; planexy.setSmall(0, planexy.bigEnd(0) );
135  tbxxy.growHi(0,-1);
136  bool need_to_test = (bc_ptr[BCVars::yvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ? true : false;
137  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
138  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
139  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
140  if (!need_to_test || u(dom_hi.x+1,j,k) <= 0.) {
141  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
142  - (-(8./3.) * v(i,j,k) + 3. * v(i-1,j,k) - (1./3.) * v(i-2,j,k))*dxInv[0]*mfx );
143  } else {
144  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy +
145  (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
146  }
147  });
148  }
149 
150  if (xl_w_dir) {
151  Box planexz = tbxxz; planexz.setBig(0, planexz.smallEnd(0) );
152  tbxxz.growLo(0,-1);
153  bool need_to_test = (bc_ptr[BCVars::zvel_bc].lo(0) == ERFBCType::ext_dir_upwind) ? true : false;
154  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
155  Real mfx = mf_ux(i,j,0);
156  if (!need_to_test || u(dom_lo.x,j,k) >= 0.) {
157  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
158  + (-(8./3.) * w(i-1,j,k) + 3. * w(i,j,k) - (1./3.) * w(i+1,j,k))*dxInv[0]*mfx );
159  } else {
160  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
161  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
162  }
163  });
164  }
165  if (xh_w_dir) {
166  // 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
167  Box planexz = tbxxz; planexz.setSmall(0, planexz.bigEnd(0) );
168  tbxxz.growHi(0,-1);
169  bool need_to_test = (bc_ptr[BCVars::zvel_bc].hi(0) == ERFBCType::ext_dir_upwind) ? true : false;
170  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
171  Real mfx = mf_ux(i,j,0);
172  if (!need_to_test || u(dom_hi.x+1,j,k) <= 0.) {
173  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
174  - (-(8./3.) * w(i,j,k) + 3. * w(i-1,j,k) - (1./3.) * w(i-2,j,k))*dxInv[0]*mfx );
175  } else {
176  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
177  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
178  }
179  });
180  }
181 
182  // Y-Dirichlet
183  //***********************************************************************************
184  if (yl_u_dir) {
185  Box planexy = tbxxy; planexy.setBig(1, planexy.smallEnd(1) );
186  tbxxy.growLo(1,-1);
187  bool need_to_test = (bc_ptr[BCVars::xvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ? true : false;
188  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
189  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
190  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
191  if (!need_to_test || v(i,dom_lo.y,k) >= 0.) {
192  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
193  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
194  } else {
195  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
196  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
197  }
198  });
199  }
200  if (yh_u_dir) {
201  // 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
202  Box planexy = tbxxy; planexy.setSmall(1, planexy.bigEnd(1) );
203  tbxxy.growHi(1,-1);
204  bool need_to_test = (bc_ptr[BCVars::xvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ? true : false;
205  ParallelFor(planexy,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
206  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
207  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
208  if (!need_to_test || v(i,dom_hi.y+1,k) <= 0.) {
209  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
210  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
211  } else {
212  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
213  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
214  }
215  });
216  }
217 
218  if (yl_w_dir) {
219  Box planeyz = tbxyz; planeyz.setBig(1, planeyz.smallEnd(1) );
220  tbxyz.growLo(1,-1);
221  bool need_to_test = (bc_ptr[BCVars::zvel_bc].lo(1) == ERFBCType::ext_dir_upwind) ? true : false;
222  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
223  Real mfy = mf_vy(i,j,0);
224  if (!need_to_test || v(i,dom_lo.y,k) >= 0.) {
225  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
226  + (-(8./3.) * w(i,j-1,k) + 3. * w(i,j ,k) - (1./3.) * w(i,j+1,k))*dxInv[1]*mfy );
227  } else {
228  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
229  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
230  }
231  });
232  }
233  if (yh_w_dir) {
234  // 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
235  Box planeyz = tbxyz; planeyz.setSmall(1, planeyz.bigEnd(1) );
236  tbxyz.growHi(1,-1);
237  bool need_to_test = (bc_ptr[BCVars::zvel_bc].hi(1) == ERFBCType::ext_dir_upwind) ? true : false;
238  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
239  Real mfy = mf_vy(i,j,0);
240  if (!need_to_test || v(i,dom_hi.y+1,k) <= 0.) {
241  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
242  - (-(8./3.) * w(i,j ,k) + 3. * w(i,j-1,k) - (1./3.) * w(i,j-2,k))*dxInv[1]*mfy );
243  } else {
244  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
245  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
246  }
247  });
248  }
249 
250  // Z-Dirichlet
251  //***********************************************************************************
252  if (zl_u_dir) {
253  Box planexz = tbxxz; planexz.setBig(2, planexz.smallEnd(2) );
254  tbxxz.growLo(2,-1);
255  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
256  Real mfx = mf_ux(i,j,0);
257  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]
258  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
259  });
260  }
261  if (zh_u_dir) {
262  // 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
263  Box planexz = tbxxz; planexz.setSmall(2, planexz.bigEnd(2) );
264  tbxxz.growHi(2,-1);
265  ParallelFor(planexz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
266  Real mfx = mf_ux(i,j,0);
267  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]
268  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
269  });
270  }
271 
272  if (zl_v_dir) {
273  Box planeyz = tbxyz; planeyz.setBig(2, planeyz.smallEnd(2) );
274  tbxyz.growLo(2,-1);
275  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
276  Real mfy = mf_vy(i,j,0);
277  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]
278  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
279  });
280  }
281  if (zh_v_dir) {
282  // 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
283  Box planeyz = tbxyz; planeyz.setSmall(2, planeyz.bigEnd(2) );
284  tbxyz.growHi(2,-1);
285  ParallelFor(planeyz,[=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
286  Real mfy = mf_vy(i,j,0);
287  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]
288  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
289  });
290  }
291 
292  // Fill the remaining cells
293  //***********************************************************************************
294  // Cell centered strains
295  ParallelFor(bxcc, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
296  Real mfx = mf_mx(i,j,0);
297  Real mfy = mf_my(i,j,0);
298  tau11(i,j,k) = (u(i+1, j , k ) - u(i, j, k))*dxInv[0]*mfx;
299  tau22(i,j,k) = (v(i , j+1, k ) - v(i, j, k))*dxInv[1]*mfy;
300  tau33(i,j,k) = (w(i , j , k+1) - w(i, j, k))*dxInv[2];
301  });
302 
303  // Off-diagonal strains
304  ParallelFor(tbxxy,tbxxz,tbxyz,
305  [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
306  Real mfy = 0.5 * (mf_uy(i,j,0) + mf_uy(i ,j-1,0));
307  Real mfx = 0.5 * (mf_vx(i,j,0) + mf_vx(i-1,j ,0));
308  tau12(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j-1, k))*dxInv[1]*mfy
309  + (v(i, j, k) - v(i-1, j, k))*dxInv[0]*mfx );
310  },
311  [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
312  Real mfx = mf_ux(i,j,0);
313  tau13(i,j,k) = 0.5 * ( (u(i, j, k) - u(i, j, k-1))*dxInv[2]
314  + (w(i, j, k) - w(i-1, j, k))*dxInv[0]*mfx );
315  },
316  [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
317  Real mfy = mf_vy(i,j,0);
318  tau23(i,j,k) = 0.5 * ( (v(i, j, k) - v(i, j, k-1))*dxInv[2]
319  + (w(i, j, k) - w(i, j-1, k))*dxInv[1]*mfy );
320  });
321 
322 }
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
dom_hi
const auto & dom_hi
Definition: ERF_DiffSetup.H:10
dom_lo
const auto & dom_lo
Definition: ERF_DiffSetup.H:9
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 caller graph for this function: