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

Functions

void AdvectionSrcForRho (const Box &bx, const Array4< Real > &advectionSrc, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Array4< const Real > &Omega, const Array4< Real > &avg_xmom, const Array4< Real > &avg_ymom, const Array4< Real > &avg_zmom, const Array4< const Real > &ax_arr, const Array4< const Real > &ay_arr, const Array4< const Real > &az_arr, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const Array4< const Real > &mf_mx, const Array4< const Real > &mf_my, const Array4< const Real > &mf_uy, const Array4< const Real > &mf_vx, const GpuArray< const Array4< Real >, AMREX_SPACEDIM > &flx_arr, const bool fixed_rho)
 
void AdvectionSrcForScalars (const Real &dt, const Box &bx, const int icomp, const int ncomp, const Array4< const Real > &avg_xmom, const Array4< const Real > &avg_ymom, const Array4< const Real > &avg_zmom, const Array4< const Real > &cur_cons, const Array4< const Real > &cell_prim, const Array4< Real > &advectionSrc, const bool &use_mono_adv, Real *max_s_ptr, Real *min_s_ptr, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const Array4< const Real > &mf_mx, const Array4< const Real > &mf_my, const AdvType horiz_adv_type, const AdvType vert_adv_type, const Real horiz_upw_frac, const Real vert_upw_frac, const GpuArray< const Array4< Real >, AMREX_SPACEDIM > &flx_arr, const GpuArray< Array4< Real >, AMREX_SPACEDIM > &flx_tmp_arr, const Box &domain, const BCRec *bc_ptr_h)
 

Function Documentation

◆ AdvectionSrcForRho()

void AdvectionSrcForRho ( const Box &  bx,
const Array4< Real > &  advectionSrc,
const Array4< const Real > &  rho_u,
const Array4< const Real > &  rho_v,
const Array4< const Real > &  Omega,
const Array4< Real > &  avg_xmom,
const Array4< Real > &  avg_ymom,
const Array4< Real > &  avg_zmom,
const Array4< const Real > &  ax_arr,
const Array4< const Real > &  ay_arr,
const Array4< const Real > &  az_arr,
const Array4< const Real > &  detJ,
const GpuArray< Real, AMREX_SPACEDIM > &  cellSizeInv,
const Array4< const Real > &  mf_mx,
const Array4< const Real > &  mf_my,
const Array4< const Real > &  mf_uy,
const Array4< const Real > &  mf_vx,
const GpuArray< const Array4< Real >, AMREX_SPACEDIM > &  flx_arr,
const bool  fixed_rho 
)

Function for computing the advective tendency for the update equations for rho and (rho theta) This routine has explicit expressions for all cases (terrain or not) when the horizontal and vertical spatial orders are <= 2, and calls more specialized functions when either (or both) spatial order(s) is greater than 2.

Parameters
[in]bxbox over which the scalars are updated
[out]advectionSrctendency for the scalar update equation
[in]rho_ux-component of momentum
[in]rho_vy-component of momentum
[in]Omegacomponent of momentum normal to the z-coordinate surface
[out]avg_xmomx-component of time-averaged momentum defined in this routine
[out]avg_ymomy-component of time-averaged momentum defined in this routine
[out]avg_zmomz-component of time-averaged momentum defined in this routine
[in]detJJacobian of the metric transformation (= 1 if use_terrain is false)
[in]cellSizeInvinverse of the mesh spacing
[in]mf_mmap factor at cell centers
[in]mf_umap factor at x-faces
[in]mf_vmap factor at y-faces
49 {
50  BL_PROFILE_VAR("AdvectionSrcForRho", AdvectionSrcForRho);
51  auto dxInv = cellSizeInv[0], dyInv = cellSizeInv[1], dzInv = cellSizeInv[2];
52 
53  const Box xbx = surroundingNodes(bx,0);
54  const Box ybx = surroundingNodes(bx,1);
55  const Box zbx = surroundingNodes(bx,2);
56 
57  ParallelFor(xbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
58  {
59  (flx_arr[0])(i,j,k,0) = ax_arr(i,j,k) * rho_u(i,j,k) / mf_uy(i,j,0);
60  avg_xmom(i,j,k) = (flx_arr[0])(i,j,k,0);
61  });
62  ParallelFor(ybx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
63  {
64  (flx_arr[1])(i,j,k,0) = ay_arr(i,j,k) * rho_v(i,j,k) / mf_vx(i,j,0);
65  avg_ymom(i,j,k) = (flx_arr[1])(i,j,k,0);
66  });
67  ParallelFor(zbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
68  {
69  Real mfsq = mf_mx(i,j,0) * mf_my(i,j,0);
70  (flx_arr[2])(i,j,k,0) = az_arr(i,j,k) * Omega(i,j,k) / mfsq;
71  avg_zmom(i,j,k) = (flx_arr[2])(i,j,k,0);
72  });
73 
74  if (fixed_rho) {
75  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
76  {
77  advectionSrc(i,j,k,0) = 0.0;
78  });
79  } else
80  {
81  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
82  {
83  if (detJ(i,j,k) > 0.) {
84  Real mfsq = mf_mx(i,j,0) * mf_my(i,j,0);
85  advectionSrc(i,j,k,0) = - mfsq / detJ(i,j,k) * (
86  ( (flx_arr[0])(i+1,j,k,0) - (flx_arr[0])(i ,j,k,0) ) * dxInv +
87  ( (flx_arr[1])(i,j+1,k,0) - (flx_arr[1])(i,j ,k,0) ) * dyInv +
88  ( (flx_arr[2])(i,j,k+1,0) - (flx_arr[2])(i,j,k ,0) ) * dzInv );
89  } else {
90  advectionSrc(i,j,k,0) = 0.;
91  }
92  });
93  }
94 }
AdvectionSrcForRho
void AdvectionSrcForRho(const Box &bx, const Array4< Real > &advectionSrc, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Array4< const Real > &Omega, const Array4< Real > &avg_xmom, const Array4< Real > &avg_ymom, const Array4< Real > &avg_zmom, const Array4< const Real > &ax_arr, const Array4< const Real > &ay_arr, const Array4< const Real > &az_arr, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const Array4< const Real > &mf_mx, const Array4< const Real > &mf_my, const Array4< const Real > &mf_uy, const Array4< const Real > &mf_vx, const GpuArray< const Array4< Real >, AMREX_SPACEDIM > &flx_arr, const bool fixed_rho)
Definition: ERF_AdvectionSrcForState.cpp:30
zbx
const Box zbx
Definition: ERF_DiffSetup.H:23
xbx
const Box xbx
Definition: ERF_DiffSetup.H:21
ybx
const Box ybx
Definition: ERF_DiffSetup.H:22

◆ AdvectionSrcForScalars()

void AdvectionSrcForScalars ( const Real &  dt,
const Box &  bx,
const int  icomp,
const int  ncomp,
const Array4< const Real > &  avg_xmom,
const Array4< const Real > &  avg_ymom,
const Array4< const Real > &  avg_zmom,
const Array4< const Real > &  cur_cons,
const Array4< const Real > &  cell_prim,
const Array4< Real > &  advectionSrc,
const bool &  use_mono_adv,
Real *  max_s_ptr,
Real *  min_s_ptr,
const Array4< const Real > &  detJ,
const GpuArray< Real, AMREX_SPACEDIM > &  cellSizeInv,
const Array4< const Real > &  mf_mx,
const Array4< const Real > &  mf_my,
const AdvType  horiz_adv_type,
const AdvType  vert_adv_type,
const Real  horiz_upw_frac,
const Real  vert_upw_frac,
const GpuArray< const Array4< Real >, AMREX_SPACEDIM > &  flx_arr,
const GpuArray< Array4< Real >, AMREX_SPACEDIM > &  flx_tmp_arr,
const Box &  domain,
const BCRec *  bc_ptr_h 
)

Function for computing the advective tendency for the update equations for all scalars other than rho and (rho theta) This routine has explicit expressions for all cases (terrain or not) when the horizontal and vertical spatial orders are <= 2, and calls more specialized functions when either (or both) spatial order(s) is greater than 2.

Parameters
[in]bxbox over which the scalars are updated if no external boundary conditions
[in]icompcomponent of first scalar to be updated
[in]ncompnumber of components to be updated
[in]avg_xmomx-component of time-averaged momentum defined in this routine
[in]avg_ymomy-component of time-averaged momentum defined in this routine
[in]avg_zmomz-component of time-averaged momentum defined in this routine
[in]cell_primprimitive form of scalar variables, here only potential temperature theta
[out]advectionSrctendency for the scalar update equation
[in]detJJacobian of the metric transformation (= 1 if use_terrain is false)
[in]cellSizeInvinverse of the mesh spacing
[in]mf_mmap factor at cell centers
[in]horiz_adv_typeadvection scheme to be used in horiz. directions for dry scalars
[in]vert_adv_typeadvection scheme to be used in vert. directions for dry scalars
[in]horiz_upw_fracupwinding fraction to be used in horiz. directions for dry scalars (for Blended schemes only)
[in]vert_upw_fracupwinding fraction to be used in vert. directions for dry scalars (for Blended schemes only)
145 {
146  BL_PROFILE_VAR("AdvectionSrcForScalars", AdvectionSrcForScalars);
147  auto dxInv = cellSizeInv[0], dyInv = cellSizeInv[1], dzInv = cellSizeInv[2];
148 
149  const Box xbx = surroundingNodes(bx,0);
150  const Box ybx = surroundingNodes(bx,1);
151  const Box zbx = surroundingNodes(bx,2);
152 
153  // Open bc will be imposed upon all vars (we only access cons here for simplicity)
154  const bool xlo_open = (bc_ptr_h[BCVars::cons_bc].lo(0) == ERFBCType::open);
155  const bool xhi_open = (bc_ptr_h[BCVars::cons_bc].hi(0) == ERFBCType::open);
156  const bool ylo_open = (bc_ptr_h[BCVars::cons_bc].lo(1) == ERFBCType::open);
157  const bool yhi_open = (bc_ptr_h[BCVars::cons_bc].hi(1) == ERFBCType::open);
158 
159  // Only advection operations in bndry normal direction with OPEN BC
160  Box bx_xlo, bx_xhi, bx_ylo, bx_yhi;
161  if (xlo_open) {
162  if ( bx.smallEnd(0) == domain.smallEnd(0)) { bx_xlo = makeSlab( bx,0,domain.smallEnd(0));}
163  }
164  if (xhi_open) {
165  if ( bx.bigEnd(0) == domain.bigEnd(0)) { bx_xhi = makeSlab( bx,0,domain.bigEnd(0) );}
166  }
167  if (ylo_open) {
168  if ( bx.smallEnd(1) == domain.smallEnd(1)) { bx_ylo = makeSlab( bx,1,domain.smallEnd(1));}
169  }
170  if (yhi_open) {
171  if ( bx.bigEnd(1) == domain.bigEnd(1)) { bx_yhi = makeSlab( bx,1,domain.bigEnd(1) );}
172  }
173 
174  for (int n(0); n<ncomp; ++n) {
175  const int cons_index = icomp + n;
176 
177  // Inline with 2nd order for efficiency
178  // NOTE: we don't need to weight avg_xmom, avg_ymom, avg_zmom with terrain metrics
179  // (or with EB area fractions)
180  // because that was done when they were constructed in AdvectionSrcForRhoAndTheta
181  if (horiz_adv_type == AdvType::Centered_2nd && vert_adv_type == AdvType::Centered_2nd)
182  {
183  ParallelFor(xbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
184  {
185  const int prim_index = cons_index - 1;
186  const Real prim_on_face = 0.5 * (cell_prim(i,j,k,prim_index) + cell_prim(i-1,j,k,prim_index));
187  (flx_arr[0])(i,j,k) = avg_xmom(i,j,k) * prim_on_face;
188  });
189  ParallelFor(ybx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
190  {
191  const int prim_index = cons_index - 1;
192  const Real prim_on_face = 0.5 * (cell_prim(i,j,k,prim_index) + cell_prim(i,j-1,k,prim_index));
193  (flx_arr[1])(i,j,k) = avg_ymom(i,j,k) * prim_on_face;
194  });
195  ParallelFor(zbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
196  {
197  const int prim_index = cons_index - 1;
198  const Real prim_on_face = 0.5 * (cell_prim(i,j,k,prim_index) + cell_prim(i,j,k-1,prim_index));
199  (flx_arr[2])(i,j,k) = avg_zmom(i,j,k) * prim_on_face;
200  });
201 
202  // Template higher order methods (horizontal first)
203  } else {
204  switch(horiz_adv_type) {
205  case AdvType::Centered_2nd:
206  AdvectionSrcForScalarsVert<CENTERED2>(bx, cons_index, flx_arr, cell_prim,
207  avg_xmom, avg_ymom, avg_zmom,
208  horiz_upw_frac, vert_upw_frac, vert_adv_type);
209  break;
210  case AdvType::Upwind_3rd:
211  AdvectionSrcForScalarsVert<UPWIND3>(bx, cons_index, flx_arr, cell_prim,
212  avg_xmom, avg_ymom, avg_zmom,
213  horiz_upw_frac, vert_upw_frac, vert_adv_type);
214  break;
215  case AdvType::Centered_4th:
216  AdvectionSrcForScalarsVert<CENTERED4>(bx, cons_index, flx_arr, cell_prim,
217  avg_xmom, avg_ymom, avg_zmom,
218  horiz_upw_frac, vert_upw_frac, vert_adv_type);
219  break;
220  case AdvType::Upwind_5th:
221  AdvectionSrcForScalarsVert<UPWIND5>(bx, cons_index, flx_arr, cell_prim,
222  avg_xmom, avg_ymom, avg_zmom,
223  horiz_upw_frac, vert_upw_frac, vert_adv_type);
224  break;
225  case AdvType::Centered_6th:
226  AdvectionSrcForScalarsVert<CENTERED6>(bx, cons_index, flx_arr, cell_prim,
227  avg_xmom, avg_ymom, avg_zmom,
228  horiz_upw_frac, vert_upw_frac, vert_adv_type);
229  break;
230  case AdvType::Weno_3:
231  AdvectionSrcForScalarsWrapper<WENO3,WENO3>(bx, cons_index, flx_arr, cell_prim,
232  avg_xmom, avg_ymom, avg_zmom,
233  horiz_upw_frac, vert_upw_frac);
234  break;
235  case AdvType::Weno_5:
236  AdvectionSrcForScalarsWrapper<WENO5,WENO5>(bx, cons_index, flx_arr, cell_prim,
237  avg_xmom, avg_ymom, avg_zmom,
238  horiz_upw_frac, vert_upw_frac);
239  break;
240  case AdvType::Weno_7:
241  AdvectionSrcForScalarsWrapper<WENO7,WENO7>(bx, cons_index, flx_arr, cell_prim,
242  avg_xmom, avg_ymom, avg_zmom,
243  horiz_upw_frac, vert_upw_frac);
244  break;
245  case AdvType::Weno_3Z:
246  AdvectionSrcForScalarsWrapper<WENO_Z3,WENO_Z3>(bx, cons_index, flx_arr, cell_prim,
247  avg_xmom, avg_ymom, avg_zmom,
248  horiz_upw_frac, vert_upw_frac);
249  break;
250  case AdvType::Weno_3MZQ:
251  AdvectionSrcForScalarsWrapper<WENO_MZQ3,WENO_MZQ3>(bx, cons_index, flx_arr, cell_prim,
252  avg_xmom, avg_ymom, avg_zmom,
253  horiz_upw_frac, vert_upw_frac);
254  break;
255  case AdvType::Weno_5Z:
256  AdvectionSrcForScalarsWrapper<WENO_Z5,WENO_Z5>(bx, cons_index, flx_arr, cell_prim,
257  avg_xmom, avg_ymom, avg_zmom,
258  horiz_upw_frac, vert_upw_frac);
259  break;
260  case AdvType::Weno_7Z:
261  AdvectionSrcForScalarsWrapper<WENO_Z7,WENO_Z7>(bx, cons_index, flx_arr, cell_prim,
262  avg_xmom, avg_ymom, avg_zmom,
263  horiz_upw_frac, vert_upw_frac);
264  break;
265  default:
266  AMREX_ASSERT_WITH_MESSAGE(false, "Unknown advection scheme!");
267  }
268  }
269 
270  /* =======================================================================
271  Monotonicity preserving order reduction for scalars (0-th upwind).
272 
273  NOTE:
274  The following order reduction operations for scalar advection have been
275  adapted from the PINACLES code developed at PPNL by K. Pressel et al.;
276  see https://github.com/pnnl/pinacles.git and This version utilizes global
277  min/max values for simplicity rather than the local average around each
278  cell. Motivation for this modification is the compressible dycore in ERF
279  as opposed to incompressible/analestic in PINACLES.
280  ======================================================================= */
281  if (use_mono_adv) {
282  // Copy flux data to flx_arr to avoid race condition on GPU
283  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
284  {
285  (flx_tmp_arr[0])(i,j,k) = (flx_arr[0])(i,j,k);
286  (flx_tmp_arr[1])(i,j,k) = (flx_arr[1])(i,j,k);
287  (flx_tmp_arr[2])(i,j,k) = (flx_arr[2])(i,j,k);
288  });
289 
290  // Mono limiting
291  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
292  {
293  const int prim_index = cons_index - 1;
294 
295  Real max_val = max_s_ptr[cons_index];
296  Real min_val = min_s_ptr[cons_index];
297 
298  Real invdetJ = (detJ(i,j,k) > 0.) ? 1. / detJ(i,j,k) : 1.;
299  Real mfsq = mf_mx(i,j,0) * mf_my(i,j,0);
300 
301  Real RHS = - invdetJ * mfsq * (
302  ( (flx_arr[0])(i+1,j ,k ) - (flx_arr[0])(i,j,k) ) * dxInv +
303  ( (flx_arr[1])(i ,j+1,k ) - (flx_arr[1])(i,j,k) ) * dyInv +
304  ( (flx_arr[2])(i ,j ,k+1) - (flx_arr[2])(i,j,k) ) * dzInv );
305 
306  // NOTE: This forward prediction uses the `cur_cons` as opposed to `old_cons` since
307  // source terms may cause increase/decrease in a variable each RK stage. We
308  // want to ensure the advection operator does not induce over/under-shoot
309  // from the current state. If the `old_cons` is used and significant forcing is
310  // present, we could trip an order reduction just due to the source terms.
311  Real tmp_upd = cur_cons(i,j,k,cons_index) + RHS*dt;
312  if (tmp_upd<min_val || tmp_upd>max_val) {
313  // HI
314  if (avg_xmom(i+1,j,k)>0.0) {
315  (flx_tmp_arr[0])(i+1,j,k) = avg_xmom(i+1,j,k) * cell_prim(i ,j,k,prim_index);
316  } else {
317  (flx_tmp_arr[0])(i+1,j,k) = avg_xmom(i+1,j,k) * cell_prim(i+1,j,k,prim_index);
318  }
319  if (avg_ymom(i,j+1,k)>0.0) {
320  (flx_tmp_arr[1])(i,j+1,k) = avg_ymom(i,j+1,k) * cell_prim(i,j ,k,prim_index);
321  } else {
322  (flx_tmp_arr[1])(i,j+1,k) = avg_ymom(i,j+1,k) * cell_prim(i,j+1,k,prim_index);
323  }
324  if (avg_zmom(i,j,k+1)>0.0) {
325  (flx_tmp_arr[2])(i,j,k+1) = avg_zmom(i,j,k+1) * cell_prim(i,j,k ,prim_index);
326  } else {
327  (flx_tmp_arr[2])(i,j,k+1) = avg_zmom(i,j,k+1) * cell_prim(i,j,k+1,prim_index);
328  }
329 
330  // LO
331  if (avg_xmom(i,j,k)>0.0) {
332  (flx_tmp_arr[0])(i,j,k) = avg_xmom(i,j,k) * cell_prim(i-1,j,k,prim_index);
333  } else {
334  (flx_tmp_arr[0])(i,j,k) = avg_xmom(i,j,k) * cell_prim(i ,j,k,prim_index);
335  }
336  if (avg_ymom(i,j,k)>0.0) {
337  (flx_tmp_arr[1])(i,j,k) = avg_ymom(i,j,k) * cell_prim(i,j-1,k,prim_index);
338  } else {
339  (flx_tmp_arr[1])(i,j,k) = avg_ymom(i,j,k) * cell_prim(i,j ,k,prim_index);
340  }
341  if (avg_zmom(i,j,k)>0.0) {
342  (flx_tmp_arr[2])(i,j,k) = avg_zmom(i,j,k) * cell_prim(i,j,k-1,prim_index);
343  } else {
344  (flx_tmp_arr[2])(i,j,k) = avg_zmom(i,j,k) * cell_prim(i,j,k ,prim_index);
345  }
346  }
347  });
348 
349  // Copy back to flx_arr to avoid race condition on GPU
350  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
351  {
352  (flx_arr[0])(i,j,k) = (flx_tmp_arr[0])(i,j,k);
353  (flx_arr[1])(i,j,k) = (flx_tmp_arr[1])(i,j,k);
354  (flx_arr[2])(i,j,k) = (flx_tmp_arr[2])(i,j,k);
355  });
356  }
357 
358  ParallelFor(bx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
359  {
360  if (detJ(i,j,k) > 0.)
361  {
362  Real invdetJ = 1.0 / detJ(i,j,k);
363  Real mfsq = mf_mx(i,j,0) * mf_my(i,j,0);
364 
365  advectionSrc(i,j,k,cons_index) = - invdetJ * mfsq * (
366  ( (flx_arr[0])(i+1,j,k) - (flx_arr[0])(i,j,k) ) * dxInv +
367  ( (flx_arr[1])(i,j+1,k) - (flx_arr[1])(i,j,k) ) * dyInv +
368  ( (flx_arr[2])(i,j,k+1) - (flx_arr[2])(i,j,k) ) * dzInv );
369  } else {
370  advectionSrc(i,j,k) = 0.;
371  }
372  });
373 
374  // Special advection operator for open BC (bndry tangent operations)
375  if (xlo_open) {
376  bool do_lo = true;
377  AdvectionSrcForOpenBC_Tangent_Cons(bx_xlo, 0, icomp, ncomp, advectionSrc, cell_prim,
378  avg_xmom, avg_ymom, avg_zmom,
379  detJ, cellSizeInv, do_lo);
380  }
381  if (xhi_open) {
382  AdvectionSrcForOpenBC_Tangent_Cons(bx_xhi, 0, icomp, ncomp, advectionSrc, cell_prim,
383  avg_xmom, avg_ymom, avg_zmom,
384  detJ, cellSizeInv);
385  }
386  if (ylo_open) {
387  bool do_lo = true;
388  AdvectionSrcForOpenBC_Tangent_Cons(bx_ylo, 1, icomp, ncomp, advectionSrc, cell_prim,
389  avg_xmom, avg_ymom, avg_zmom,
390  detJ, cellSizeInv, do_lo);
391  }
392  if (yhi_open) {
393  AdvectionSrcForOpenBC_Tangent_Cons(bx_yhi, 1, icomp, ncomp, advectionSrc, cell_prim,
394  avg_xmom, avg_ymom, avg_zmom,
395  detJ, cellSizeInv);
396  }
397 
398  } // n
399 }
AdvectionSrcForScalars
void AdvectionSrcForScalars(const Real &dt, const Box &bx, const int icomp, const int ncomp, const Array4< const Real > &avg_xmom, const Array4< const Real > &avg_ymom, const Array4< const Real > &avg_zmom, const Array4< const Real > &cur_cons, const Array4< const Real > &cell_prim, const Array4< Real > &advectionSrc, const bool &use_mono_adv, Real *max_s_ptr, Real *min_s_ptr, const Array4< const Real > &detJ, const GpuArray< Real, AMREX_SPACEDIM > &cellSizeInv, const Array4< const Real > &mf_mx, const Array4< const Real > &mf_my, const AdvType horiz_adv_type, const AdvType vert_adv_type, const Real horiz_upw_frac, const Real vert_upw_frac, const GpuArray< const Array4< Real >, AMREX_SPACEDIM > &flx_arr, const GpuArray< Array4< Real >, AMREX_SPACEDIM > &flx_tmp_arr, const Box &domain, const BCRec *bc_ptr_h)
Definition: ERF_AdvectionSrcForState.cpp:120
AdvectionSrcForOpenBC_Tangent_Cons
void AdvectionSrcForOpenBC_Tangent_Cons(const amrex::Box &bx, const int &dir, const int &icomp, const int &ncomp, const amrex::Array4< amrex::Real > &cell_rhs, const amrex::Array4< const amrex::Real > &cell_prim, const amrex::Array4< const amrex::Real > &avg_xmom, const amrex::Array4< const amrex::Real > &avg_ymom, const amrex::Array4< const amrex::Real > &avg_zmom, const amrex::Array4< const amrex::Real > &detJ, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &cellSizeInv, const bool do_lo=false)
AdvType::Weno_7
@ Weno_7
AdvType::Upwind_3rd
@ Upwind_3rd
AdvType::Weno_7Z
@ Weno_7Z
AdvType::Centered_4th
@ Centered_4th
AdvType::Upwind_5th
@ Upwind_5th
AdvType::Centered_6th
@ Centered_6th
AdvType::Weno_3Z
@ Weno_3Z
AdvType::Weno_3
@ Weno_3
AdvType::Centered_2nd
@ Centered_2nd
AdvType::Weno_5Z
@ Weno_5Z
AdvType::Weno_5
@ Weno_5
AdvType::Weno_3MZQ
@ Weno_3MZQ
BCVars::cons_bc
@ cons_bc
Definition: ERF_IndexDefines.H:76
ERFBCType::open
@ open
Definition: ERF_IndexDefines.H:215
Here is the call graph for this function: