ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Public Member Functions | Private Attributes | List of all members
ERFPhysBCFunct_cons Class Reference

#include <ERF_PhysBCFunct.H>

Collaboration diagram for ERFPhysBCFunct_cons:
Collaboration graph
[legend]

Public Member Functions

 ERFPhysBCFunct_cons (const int lev, const amrex::Geometry &geom, const amrex::Vector< amrex::BCRec > &domain_bcs_type, const amrex::Gpu::DeviceVector< amrex::BCRec > &domain_bcs_type_d, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > bc_extdir_vals, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > bc_neumann_vals, std::unique_ptr< amrex::MultiFab > &z_phys_nd, const bool use_real_bcs, amrex::Real *th_bc_data)
 
 ~ERFPhysBCFunct_cons ()
 
void operator() (amrex::MultiFab &mf, amrex::MultiFab &xvel, amrex::MultiFab &yvel, int icomp, int ncomp, amrex::IntVect const &nghost, const double time, int bccomp_cons, bool do_fb=true, bool do_terrain_adjustment=true)
 
void impose_lateral_cons_bcs (const amrex::Array4< amrex::Real > &dest_arr, const amrex::Array4< amrex::Real const > &xvel_arr, const amrex::Array4< amrex::Real const > &yvel_arr, const amrex::Box &bx, const amrex::Box &domain, int icomp, int ncomp, amrex::IntVect ng, const double time)
 
void impose_vertical_cons_bcs (const amrex::Array4< amrex::Real > &dest_arr, const amrex::Box &bx, const amrex::Box &domain, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int icomp, int ncomp, const double time, bool do_terrain_adjustment=true)
 

Private Attributes

int m_lev
 
amrex::Geometry m_geom
 
amrex::Vector< amrex::BCRec > m_domain_bcs_type
 
amrex::Gpu::DeviceVector< amrex::BCRec > m_domain_bcs_type_d
 
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > m_bc_extdir_vals
 
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > m_bc_neumann_vals
 
amrex::MultiFab * m_z_phys_nd
 
bool m_use_real_bcs
 
amrex::Real * m_th_bc_data
 

Constructor & Destructor Documentation

◆ ERFPhysBCFunct_cons()

ERFPhysBCFunct_cons::ERFPhysBCFunct_cons ( const int  lev,
const amrex::Geometry &  geom,
const amrex::Vector< amrex::BCRec > &  domain_bcs_type,
const amrex::Gpu::DeviceVector< amrex::BCRec > &  domain_bcs_type_d,
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max >  bc_extdir_vals,
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max >  bc_neumann_vals,
std::unique_ptr< amrex::MultiFab > &  z_phys_nd,
const bool  use_real_bcs,
amrex::Real *  th_bc_data 
)
inline

Construct the conserved-variable physical boundary-condition functor.

Parameters
[in]levlevel index
[in]geomgeometry for the level
[in]domain_bcs_typehost boundary-condition records
[in]domain_bcs_type_ddevice boundary-condition records
[in]bc_extdir_valsexternal Dirichlet values for boundary faces
[in]bc_neumann_valsNeumann values for boundary faces
[in]z_phys_ndnodal physical height MultiFab
[in]use_real_bcswhether real-data boundary conditions are active
[in]th_bc_dataoptional theta boundary data
47  : m_lev(lev), m_geom(geom),
48  m_domain_bcs_type(domain_bcs_type),
49  m_domain_bcs_type_d(domain_bcs_type_d),
50  m_bc_extdir_vals(bc_extdir_vals),
51  m_bc_neumann_vals(bc_neumann_vals),
52  m_z_phys_nd(z_phys_nd.get()),
53  m_use_real_bcs(use_real_bcs),
54  m_th_bc_data(th_bc_data)
55  {}
ERFPhysBCFunct_cons::m_use_real_bcs
bool m_use_real_bcs
Definition: ERF_PhysBCFunct.H:128
ERFPhysBCFunct_cons::m_geom
amrex::Geometry m_geom
Definition: ERF_PhysBCFunct.H:122
ERFPhysBCFunct_cons::m_bc_extdir_vals
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > m_bc_extdir_vals
Definition: ERF_PhysBCFunct.H:125
ERFPhysBCFunct_cons::m_bc_neumann_vals
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NBCVAR_max > m_bc_neumann_vals
Definition: ERF_PhysBCFunct.H:126
ERFPhysBCFunct_cons::m_domain_bcs_type_d
amrex::Gpu::DeviceVector< amrex::BCRec > m_domain_bcs_type_d
Definition: ERF_PhysBCFunct.H:124
ERFPhysBCFunct_cons::m_domain_bcs_type
amrex::Vector< amrex::BCRec > m_domain_bcs_type
Definition: ERF_PhysBCFunct.H:123
ERFPhysBCFunct_cons::m_th_bc_data
amrex::Real * m_th_bc_data
Definition: ERF_PhysBCFunct.H:129
ERFPhysBCFunct_cons::m_z_phys_nd
amrex::MultiFab * m_z_phys_nd
Definition: ERF_PhysBCFunct.H:127
ERFPhysBCFunct_cons::m_lev
int m_lev
Definition: ERF_PhysBCFunct.H:121

◆ ~ERFPhysBCFunct_cons()

ERFPhysBCFunct_cons::~ERFPhysBCFunct_cons ( )
inline

Destroy the conserved-variable physical boundary-condition functor.

60 {}

Member Function Documentation

◆ impose_lateral_cons_bcs()

void ERFPhysBCFunct_cons::impose_lateral_cons_bcs ( const amrex::Array4< amrex::Real > &  dest_arr,
const amrex::Array4< amrex::Real const > &  xvel_arr,
const amrex::Array4< amrex::Real const > &  yvel_arr,
const amrex::Box &  bx,
const amrex::Box &  domain,
int  icomp,
int  ncomp,
amrex::IntVect  ng,
const double  time 
)

Impose lateral boundary conditions on conserved variables.

Parameters
[in,out]dest_arrcell-centered data to be filled
[in]xvel_arrx-velocity used to determine upwind inflow
[in]yvel_arry-velocity used to determine upwind inflow
[in]bxbox holding data to be filled
[in]domainsimulation domain
[in]icompstarting component
[in]ncompnumber of components
[in]ngnumber of ghost cells
[in]timetime at which data should be filled

Impose lateral boundary conditions on conserved scalars (at cell centers)

Parameters
[in,out]dest_arrcell-centered data to be filled
[in]xvel_arrx-velocity used to determine upwind Dirichlet inflow
[in]yvel_arry-velocity used to determine upwind Dirichlet inflow
[in]bxbox holding data to be filled
[in]domainsimulation domain
[in]icompindex into the MultiFab – this can be any value from 0 to NVAR-1
[in]ncompthe number of components – this can be any value from 1 to NVAR as long as icomp+ncomp <= NVAR-one
[in]ngnumber of ghost cells in each coordinate direction
[in]timetime at which the data should be filled
28 {
29  BL_PROFILE_VAR("impose_lateral_cons_bcs()",impose_lateral_cons_bcs);
30  const auto& dom_lo = lbound(domain);
31  const auto& dom_hi = ubound(domain);
32 
33  // xlo: ori = 0
34  // ylo: ori = 1
35  // zlo: ori = 2
36  // xhi: ori = 3
37  // yhi: ori = 4
38  // zhi: ori = 5
39 
40  // Based on BCRec for the domain, we need to make BCRec for this Box
41  // 0 is used as starting index for bcrs
42  Vector<BCRec> bcrs(ncomp);
43 
44  GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,NBCVAR_max> l_bc_extdir_vals_d;
45 
46  const int* bxlo = bx.loVect();
47  const int* bxhi = bx.hiVect();
48  const int* dlo = domain.loVect();
49  const int* dhi = domain.hiVect();
50 
51  for (int nc = 0; nc < ncomp; nc++)
52  {
53  int bc_comp = (icomp+nc >= RhoScalar_comp && icomp+nc < RhoScalar_comp+NSCALARS) ?
54  BCVars::RhoScalar_bc_comp : icomp+nc;
55  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
56  for (int dir = 0; dir < AMREX_SPACEDIM; dir++)
57  {
58  bcrs[nc].setLo(dir, ( bxlo[dir]<=dlo[dir]
59  ? m_domain_bcs_type[bc_comp].lo(dir) : BCType::int_dir ));
60  bcrs[nc].setHi(dir, ( bxhi[dir]>=dhi[dir]
61  ? m_domain_bcs_type[bc_comp].hi(dir) : BCType::int_dir ));
62  }
63 
64  for (int ori = 0; ori < 2*AMREX_SPACEDIM; ori++) {
65  l_bc_extdir_vals_d[bc_comp][ori] = m_bc_extdir_vals[bc_comp][ori];
66  }
67  }
68 
69  Gpu::DeviceVector<BCRec> bcrs_d(ncomp);
70  Gpu::copyAsync(Gpu::hostToDevice, bcrs.begin(), bcrs.end(), bcrs_d.begin());
71  const BCRec* bc_ptr = bcrs_d.data();
72 
73  GeometryData const& geomdata = m_geom.data();
74  bool is_periodic_in_x = geomdata.isPeriodic(0);
75  bool is_periodic_in_y = geomdata.isPeriodic(1);
76 
77  // First do all ext_dir bcs
78  if (!is_periodic_in_x)
79  {
80  Real* th_bc_ptr = m_th_bc_data;
81  Box bx_xlo(bx); bx_xlo.setBig (0,dom_lo.x-1);
82  Box bx_xhi(bx); bx_xhi.setSmall(0,dom_hi.x+1);
83  //
84  // If we are setting Dirichlet values, set them in all ghost cells on an inflow face
85  // "bx" is already grown in the x- and y-directions so here we just grow it in z
86  //
87  bx_xlo.grow(2,ng[2]);
88  bx_xhi.grow(2,ng[2]);
89  ParallelFor(
90  bx_xlo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
91  {
92  int dest_comp = icomp+n;
93  int k_profile = amrex::min(amrex::max(k, dom_lo.z), dom_hi.z) - dom_lo.z;
94  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
95  BCVars::RhoScalar_bc_comp : dest_comp;
96  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
97  int l_bc_type = bc_ptr[n].lo(0);
98 
99  if ( (l_bc_type == ERFBCType::ext_dir) ||
100  (l_bc_type == ERFBCType::ext_dir_upwind && xvel_arr(dom_lo.x,j,k) >= zero) )
101  {
102  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
103  dest_arr(i,j,k,dest_comp) = th_bc_ptr[k_profile];
104  } else {
105  dest_arr(i,j,k,dest_comp) = l_bc_extdir_vals_d[bc_comp][0];
106  }
107  } else if (l_bc_type == ERFBCType::ext_dir_prim) {
108  Real rho = dest_arr(dom_lo.x,j,k,Rho_comp);
109  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
110  dest_arr(i,j,k,dest_comp) = rho * th_bc_ptr[k_profile];
111  } else {
112  dest_arr(i,j,k,dest_comp) = rho * l_bc_extdir_vals_d[bc_comp][0];
113  }
114  }
115  },
116  bx_xhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
117  {
118  int dest_comp = icomp+n;
119  int k_profile = amrex::min(amrex::max(k, dom_lo.z), dom_hi.z) - dom_lo.z;
120  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
121  BCVars::RhoScalar_bc_comp : dest_comp;
122  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
123  int h_bc_type = bc_ptr[n].hi(0);
124 
125  if ( (h_bc_type == ERFBCType::ext_dir) ||
126  (h_bc_type == ERFBCType::ext_dir_upwind && xvel_arr(dom_hi.x+1,j,k) <= zero) )
127  {
128  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
129  dest_arr(i,j,k,dest_comp) = th_bc_ptr[k_profile];
130  } else {
131  dest_arr(i,j,k,dest_comp) = l_bc_extdir_vals_d[bc_comp][3];
132  }
133  } else if (h_bc_type == ERFBCType::ext_dir_prim) {
134  Real rho = dest_arr(dom_hi.x,j,k,Rho_comp);
135  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
136  dest_arr(i,j,k,dest_comp) = rho * th_bc_ptr[k_profile];
137  } else {
138  dest_arr(i,j,k,dest_comp) = rho * l_bc_extdir_vals_d[bc_comp][3];
139  }
140  }
141  }
142  );
143  }
144 
145  if (!is_periodic_in_y)
146  {
147  Real* th_bc_ptr = m_th_bc_data;
148  Box bx_ylo(bx); bx_ylo.setBig (1,dom_lo.y-1);
149  Box bx_yhi(bx); bx_yhi.setSmall(1,dom_hi.y+1);
150  //
151  // If we are setting Dirichlet values, set them in all ghost cells on an inflow face
152  // "bx" is already grown in the x- and y-directions so here we just grow it in z
153  //
154  bx_ylo.grow(2,ng[2]);
155  bx_yhi.grow(2,ng[2]);
156 
157  ParallelFor(
158  bx_ylo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
159  {
160  int dest_comp = icomp+n;
161  int k_profile = amrex::min(amrex::max(k, dom_lo.z), dom_hi.z) - dom_lo.z;
162  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
163  BCVars::RhoScalar_bc_comp : dest_comp;
164  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
165  int l_bc_type = bc_ptr[n].lo(1);
166  if ( (l_bc_type == ERFBCType::ext_dir) ||
167  (l_bc_type == ERFBCType::ext_dir_upwind && yvel_arr(i,dom_lo.y,k) >= zero) )
168  {
169  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
170  dest_arr(i,j,k,dest_comp) = th_bc_ptr[k_profile];
171  } else {
172  dest_arr(i,j,k,dest_comp) = l_bc_extdir_vals_d[bc_comp][1];
173  }
174  } else if (l_bc_type == ERFBCType::ext_dir_prim) {
175  Real rho = dest_arr(i,dom_lo.y,k,Rho_comp);
176  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
177  dest_arr(i,j,k,dest_comp) = rho * th_bc_ptr[k_profile];
178  } else {
179  dest_arr(i,j,k,dest_comp) = rho * l_bc_extdir_vals_d[bc_comp][1];
180  }
181  }
182  },
183  bx_yhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
184  {
185  int dest_comp = icomp+n;
186  int k_profile = amrex::min(amrex::max(k, dom_lo.z), dom_hi.z) - dom_lo.z;
187  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
188  BCVars::RhoScalar_bc_comp : dest_comp;
189  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
190  int h_bc_type = bc_ptr[n].hi(1);
191  if ( (h_bc_type == ERFBCType::ext_dir) ||
192  (h_bc_type == ERFBCType::ext_dir_upwind && yvel_arr(i,dom_hi.y+1,k) <= zero) )
193  {
194  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
195  dest_arr(i,j,k,dest_comp) = th_bc_ptr[k_profile];
196  } else {
197  dest_arr(i,j,k,dest_comp) = l_bc_extdir_vals_d[bc_comp][4];
198  }
199  } else if (h_bc_type == ERFBCType::ext_dir_prim) {
200  Real rho = dest_arr(i,dom_hi.y,k,Rho_comp);
201  if ((dest_comp == RhoTheta_comp) && th_bc_ptr) {
202  dest_arr(i,j,k,dest_comp) = rho * th_bc_ptr[k_profile];
203  } else {
204  dest_arr(i,j,k,dest_comp) = rho * l_bc_extdir_vals_d[bc_comp][4];
205  }
206  }
207  }
208  );
209  }
210 
211  // Next do ghost cells in x-direction but not reaching out in y
212  // The corners we miss here will be covered in the y-loop below or by periodicity
213  if (!is_periodic_in_x)
214  {
215  // Populate ghost cells on lo-x and hi-x domain boundaries
216  Box bx_xlo(bx); bx_xlo.setBig (0,dom_lo.x-1);
217  Box bx_xhi(bx); bx_xhi.setSmall(0,dom_hi.x+1);
218  if (bx_xlo.smallEnd(2) != domain.smallEnd(2)) bx_xlo.growLo(2,ng[2]);
219  if (bx_xlo.bigEnd(2) != domain.bigEnd(2)) bx_xlo.growHi(2,ng[2]);
220  if (bx_xhi.smallEnd(2) != domain.smallEnd(2)) bx_xhi.growLo(2,ng[2]);
221  if (bx_xhi.bigEnd(2) != domain.bigEnd(2)) bx_xhi.growHi(2,ng[2]);
222  ParallelFor(
223  bx_xlo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
224  {
225  int dest_comp = icomp+n;
226  int l_bc_type = bc_ptr[n].lo(0);
227  int iflip = dom_lo.x - 1 - i;
228  if (l_bc_type == ERFBCType::foextrap) {
229  dest_arr(i,j,k,dest_comp) = dest_arr(dom_lo.x,j,k,dest_comp);
230  } else if (l_bc_type == ERFBCType::open) {
231  dest_arr(i,j,k,dest_comp) = dest_arr(dom_lo.x,j,k,dest_comp);
232  } else if (l_bc_type == ERFBCType::reflect_even) {
233  dest_arr(i,j,k,dest_comp) = dest_arr(iflip,j,k,dest_comp);
234  } else if (l_bc_type == ERFBCType::reflect_odd) {
235  dest_arr(i,j,k,dest_comp) = -dest_arr(iflip,j,k,dest_comp);
236  } else if (l_bc_type == ERFBCType::hoextrap) {
237  Real delta_i = static_cast<Real>(dom_lo.x - i);
238  dest_arr(i,j,k,dest_comp) = (one + delta_i)*dest_arr(dom_lo.x,j,k,dest_comp) - delta_i*dest_arr(dom_lo.x+1,j,k,dest_comp);
239  }
240  },
241  bx_xhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
242  {
243  int dest_comp = icomp+n;
244  int h_bc_type = bc_ptr[n].hi(0);
245  int iflip = 2*dom_hi.x + 1 - i;
246  if (h_bc_type == ERFBCType::foextrap) {
247  dest_arr(i,j,k,dest_comp) = dest_arr(dom_hi.x,j,k,dest_comp);
248  } else if (h_bc_type == ERFBCType::open) {
249  dest_arr(i,j,k,dest_comp) = dest_arr(dom_hi.x,j,k,dest_comp);
250  } else if (h_bc_type == ERFBCType::reflect_even) {
251  dest_arr(i,j,k,dest_comp) = dest_arr(iflip,j,k,dest_comp);
252  } else if (h_bc_type == ERFBCType::reflect_odd) {
253  dest_arr(i,j,k,dest_comp) = -dest_arr(iflip,j,k,dest_comp);
254  } else if (h_bc_type == ERFBCType::hoextrap) {
255  Real delta_i = static_cast<Real>(i - dom_hi.x);
256  dest_arr(i,j,k,dest_comp) = (one + delta_i)*dest_arr(dom_hi.x,j,k,dest_comp) - delta_i*dest_arr(dom_hi.x-1,j,k,dest_comp);
257  }
258  }
259  );
260  }
261 
262  if (!is_periodic_in_y)
263  {
264  // Populate ghost cells on lo-y and hi-y domain boundaries
265  Box bx_ylo(bx); bx_ylo.setBig (1,dom_lo.y-1);
266  Box bx_yhi(bx); bx_yhi.setSmall(1,dom_hi.y+1);
267  if (bx_ylo.smallEnd(2) != domain.smallEnd(2)) bx_ylo.growLo(2,ng[2]);
268  if (bx_ylo.bigEnd(2) != domain.bigEnd(2)) bx_ylo.growHi(2,ng[2]);
269  if (bx_yhi.smallEnd(2) != domain.smallEnd(2)) bx_yhi.growLo(2,ng[2]);
270  if (bx_yhi.bigEnd(2) != domain.bigEnd(2)) bx_yhi.growHi(2,ng[2]);
271  ParallelFor(
272  bx_ylo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
273  {
274  int dest_comp = icomp+n;
275  int l_bc_type = bc_ptr[n].lo(1);
276  int jflip = dom_lo.y - 1 - j;
277  if (l_bc_type == ERFBCType::foextrap) {
278  dest_arr(i,j,k,dest_comp) = dest_arr(i,dom_lo.y,k,dest_comp);
279  } else if (l_bc_type == ERFBCType::open) {
280  dest_arr(i,j,k,dest_comp) = dest_arr(i,dom_lo.y,k,dest_comp);
281  } else if (l_bc_type == ERFBCType::reflect_even) {
282  dest_arr(i,j,k,dest_comp) = dest_arr(i,jflip,k,dest_comp);
283  } else if (l_bc_type == ERFBCType::reflect_odd) {
284  dest_arr(i,j,k,dest_comp) = -dest_arr(i,jflip,k,dest_comp);
285  } else if (l_bc_type == ERFBCType::hoextrap) {
286  Real delta_j = static_cast<Real>(dom_lo.y - j);
287  dest_arr(i,j,k,dest_comp) = (one + delta_j)*dest_arr(i,dom_lo.y,k,dest_comp) - delta_j*dest_arr(i,dom_lo.y+1,k,dest_comp);
288  }
289 
290  },
291  bx_yhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
292  {
293  int dest_comp = icomp+n;
294  int h_bc_type = bc_ptr[n].hi(1);
295  int jflip = 2*dom_hi.y + 1 - j;
296  if (h_bc_type == ERFBCType::foextrap) {
297  dest_arr(i,j,k,dest_comp) = dest_arr(i,dom_hi.y,k,dest_comp);
298  } else if (h_bc_type == ERFBCType::open) {
299  dest_arr(i,j,k,dest_comp) = dest_arr(i,dom_hi.y,k,dest_comp);
300  } else if (h_bc_type == ERFBCType::reflect_even) {
301  dest_arr(i,j,k,dest_comp) = dest_arr(i,jflip,k,dest_comp);
302  } else if (h_bc_type == ERFBCType::reflect_odd) {
303  dest_arr(i,j,k,dest_comp) = -dest_arr(i,jflip,k,dest_comp);
304  } else if (h_bc_type == ERFBCType::hoextrap) {
305  Real delta_j = static_cast<Real>(j - dom_hi.y);
306  dest_arr(i,j,k,dest_comp) = (one + delta_j)*dest_arr(i,dom_hi.y,k,dest_comp) - delta_j*dest_arr(i,dom_hi.y-1,k,dest_comp);
307  }
308  }
309  );
310  }
311  Gpu::streamSynchronize();
312 }
one
constexpr amrex::Real one
Definition: ERF_Constants.H:9
zero
constexpr amrex::Real zero
Definition: ERF_Constants.H:8
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
NBCVAR_max
#define NBCVAR_max
Definition: ERF_IndexDefines.H:29
NSCALARS
#define NSCALARS
Definition: ERF_IndexDefines.H:16
rho
rho
Definition: ERF_InitCustomPert_Bubble.H:107
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);})
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
ERFPhysBCFunct_cons::impose_lateral_cons_bcs
void impose_lateral_cons_bcs(const amrex::Array4< amrex::Real > &dest_arr, const amrex::Array4< amrex::Real const > &xvel_arr, const amrex::Array4< amrex::Real const > &yvel_arr, const amrex::Box &bx, const amrex::Box &domain, int icomp, int ncomp, amrex::IntVect ng, const double time)
Definition: ERF_BoundaryConditionsCons.cpp:22
BCVars::RhoScalar_bc_comp
@ RhoScalar_bc_comp
Definition: ERF_IndexDefines.H:90
ERFBCType::open
@ open
Definition: ERF_IndexDefines.H:256
ERFBCType::reflect_odd
@ reflect_odd
Definition: ERF_IndexDefines.H:245
ERFBCType::hoextrap
@ hoextrap
Definition: ERF_IndexDefines.H:250
ERFBCType::foextrap
@ foextrap
Definition: ERF_IndexDefines.H:248
ERFBCType::ext_dir
@ ext_dir
Definition: ERF_IndexDefines.H:249
ERFBCType::ext_dir_prim
@ ext_dir_prim
Definition: ERF_IndexDefines.H:252
ERFBCType::ext_dir_upwind
@ ext_dir_upwind
Definition: ERF_IndexDefines.H:257
ERFBCType::int_dir
@ int_dir
Definition: ERF_IndexDefines.H:246
ERFBCType::reflect_even
@ reflect_even
Definition: ERF_IndexDefines.H:247
MicVar_Morr::ng
@ ng
Definition: ERF_Morrison.H:49
MicVar_Morr::nc
@ nc
Definition: ERF_Morrison.H:45
Here is the call graph for this function:

◆ impose_vertical_cons_bcs()

void ERFPhysBCFunct_cons::impose_vertical_cons_bcs ( const amrex::Array4< amrex::Real > &  dest_arr,
const amrex::Box &  bx,
const amrex::Box &  domain,
const amrex::Array4< amrex::Real const > &  z_nd,
const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >  dxInv,
int  icomp,
int  ncomp,
const double  time,
bool  do_terrain_adjustment = true 
)

Impose vertical boundary conditions on conserved variables.

Parameters
[in,out]dest_arrcell-centered data to be filled
[in]bxbox holding data to be filled
[in]domainsimulation domain
[in]z_ndnodal physical height
[in]dxInvinverse cell size
[in]icompstarting component
[in]ncompnumber of components
[in]timetime at which data should be filled
[in]do_terrain_adjustmentwhether to apply terrain-aware Neumann adjustments

Impose vertical boundary conditions on conserved scalars (at cell centers)

Parameters
[in,out]dest_arrthe Array4 of the quantity to be filled
[in]bxthe box associated with this data
[in]domainthe computational domain
[in]z_phys_ndheight coordinate at nodes
[in]dxInvinverse cell size array
[in]icompthe index of the first component to be filled
[in]ncompthe number of components – this can be any value from 1 to NVAR as long as icomp+ncomp <= NVAR-one
[in]timetime at which the data should be filled
[in]do_terrain_adjustmentwhether to apply terrain-aware Neumann adjustments
335 {
336  BL_PROFILE_VAR("impose_vertical_cons_bcs()",impose_vertical_cons_bcs);
337  const auto& dom_lo = lbound(domain);
338  const auto& dom_hi = ubound(domain);
339 
340  Box per_grown_domain(domain);
341  int growx = (m_geom.isPeriodic(0)) ? 1 : 0;
342  int growy = (m_geom.isPeriodic(1)) ? 1 : 0;
343  per_grown_domain.grow(IntVect(growx,growy,0));
344  const auto& perdom_lo = lbound(per_grown_domain);
345  const auto& perdom_hi = ubound(per_grown_domain);
346 
347  GeometryData const& geomdata = m_geom.data();
348 
349  // xlo: ori = 0
350  // ylo: ori = 1
351  // zlo: ori = 2
352  // xhi: ori = 3
353  // yhi: ori = 4
354  // zhi: ori = 5
355 
356  // Based on BCRec for the domain, we need to make BCRec for this Box
357  // 0 is used as starting index for bcrs
358  Vector<BCRec> bcrs(ncomp);
359  GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,NBCVAR_max> l_bc_extdir_vals_d;
360  GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,NBCVAR_max> l_bc_neumann_vals_d;
361 
362  const int* bxlo = bx.loVect();
363  const int* bxhi = bx.hiVect();
364  const int* dlo = domain.loVect();
365  const int* dhi = domain.hiVect();
366 
367  for (int nc = 0; nc < ncomp; nc++)
368  {
369  int bc_comp = (icomp+nc >= RhoScalar_comp && icomp+nc < RhoScalar_comp+NSCALARS) ?
370  BCVars::RhoScalar_bc_comp : icomp+nc;
371  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
372  for (int dir = 0; dir < AMREX_SPACEDIM; dir++)
373  {
374  bcrs[nc].setLo(dir, ( bxlo[dir]<=dlo[dir]
375  ? m_domain_bcs_type[bc_comp].lo(dir) : BCType::int_dir ));
376  bcrs[nc].setHi(dir, ( bxhi[dir]>=dhi[dir]
377  ? m_domain_bcs_type[bc_comp].hi(dir) : BCType::int_dir ));
378  }
379 
380  for (int ori = 0; ori < 2*AMREX_SPACEDIM; ori++) {
381  l_bc_extdir_vals_d[bc_comp][ori] = m_bc_extdir_vals[bc_comp][ori];
382  l_bc_neumann_vals_d[bc_comp][ori] = m_bc_neumann_vals[bc_comp][ori];
383  }
384  }
385 
386  Gpu::DeviceVector<BCRec> bcrs_d(icomp+ncomp);
387  Gpu::copyAsync(Gpu::hostToDevice, bcrs.begin(), bcrs.end(), bcrs_d.begin());
388  const BCRec* bc_ptr = bcrs_d.data();
389 
390  {
391  Box bx_zlo(bx); bx_zlo.setBig (2,dom_lo.z-1);
392  Box bx_zhi(bx); bx_zhi.setSmall(2,dom_hi.z+1);
393  ParallelFor(
394  bx_zlo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
395  {
396  int dest_comp = icomp+n;
397  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
398  BCVars::RhoScalar_bc_comp : dest_comp;
399  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
400  int l_bc_type = bc_ptr[n].lo(2);
401  if (l_bc_type == ERFBCType::ext_dir) {
402  dest_arr(i,j,k,dest_comp) = l_bc_extdir_vals_d[bc_comp][2];
403  } else if (l_bc_type == ERFBCType::ext_dir_prim) {
404  Real rho = dest_arr(i,j,dom_lo.z,Rho_comp);
405  dest_arr(i,j,k,dest_comp) = rho * l_bc_extdir_vals_d[bc_comp][2];
406  }
407  },
408  bx_zhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
409  {
410  int dest_comp = icomp+n;
411  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
412  BCVars::RhoScalar_bc_comp : dest_comp;
413  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
414  int h_bc_type = bc_ptr[n].hi(2);
415  if (h_bc_type == ERFBCType::ext_dir) {
416  dest_arr(i,j,k,dest_comp) = l_bc_extdir_vals_d[bc_comp][5];
417  } else if (h_bc_type == ERFBCType::ext_dir_prim) {
418  Real rho = dest_arr(i,j,dom_hi.z,Rho_comp);
419  dest_arr(i,j,k,dest_comp) = rho * l_bc_extdir_vals_d[bc_comp][5];
420  }
421 
422  }
423  );
424  }
425 
426  {
427  Box bx_zlo(bx); bx_zlo.setBig (2,dom_lo.z-1);
428  Box bx_zhi(bx); bx_zhi.setSmall(2,dom_hi.z+1);
429  // Populate ghost cells on lo-z and hi-z domain boundaries
430  ParallelFor(
431  bx_zlo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
432  {
433  int dest_comp = icomp+n;
434  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
435  BCVars::RhoScalar_bc_comp : dest_comp;
436  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
437  int l_bc_type = bc_ptr[n].lo(2);
438  int kflip = dom_lo.z - 1 - k;
439  if (l_bc_type == ERFBCType::foextrap) {
440  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_lo.z,dest_comp);
441  } else if (l_bc_type == ERFBCType::open) {
442  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_lo.z,dest_comp);
443  } else if (l_bc_type == ERFBCType::reflect_even) {
444  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,kflip,dest_comp);
445  } else if (l_bc_type == ERFBCType::reflect_odd) {
446  dest_arr(i,j,k,dest_comp) = -dest_arr(i,j,kflip,dest_comp);
447  } else if (l_bc_type == ERFBCType::neumann) {
448  Real delta_z = Compute_Z_AtCellCenter(i,j,dom_lo.z,z_phys_nd)
449  - Compute_Z_AtCellCenter(i,j,k ,z_phys_nd);
450  if( (icomp+n) == Rho_comp ) {
451  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_lo.z,dest_comp) -
452  delta_z*l_bc_neumann_vals_d[bc_comp][2];
453  } else {
454  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_lo.z,dest_comp) -
455  delta_z*l_bc_neumann_vals_d[bc_comp][2]*dest_arr(i,j,dom_lo.z,Rho_comp);
456  }
457  } else if (l_bc_type == ERFBCType::hoextrap) {
458  Real delta_k = static_cast<Real>(dom_lo.z - k);
459  dest_arr(i,j,k,dest_comp) = (one + delta_k) * dest_arr(i,j,dom_lo.z ,dest_comp) -
460  delta_k * dest_arr(i,j,dom_lo.z+1,dest_comp);
461  }
462  },
463  bx_zhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n)
464  {
465  int dest_comp = icomp+n;
466  int bc_comp = (dest_comp >= RhoScalar_comp && dest_comp < RhoScalar_comp+NSCALARS) ?
467  BCVars::RhoScalar_bc_comp : dest_comp;
468  if (bc_comp > BCVars::RhoScalar_bc_comp) bc_comp -= (NSCALARS-1);
469  int h_bc_type = bc_ptr[n].hi(2);
470  int kflip = 2*dom_hi.z + 1 - k;
471  if (h_bc_type == ERFBCType::foextrap) {
472  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_hi.z,dest_comp);
473  } else if (h_bc_type == ERFBCType::open) {
474  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_hi.z,dest_comp);
475  } else if (h_bc_type == ERFBCType::reflect_even) {
476  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,kflip,dest_comp);
477  } else if (h_bc_type == ERFBCType::reflect_odd) {
478  dest_arr(i,j,k,dest_comp) = -dest_arr(i,j,kflip,dest_comp);
479  } else if (h_bc_type == ERFBCType::neumann) {
480  Real delta_z = Compute_Z_AtCellCenter(i,j,k ,z_phys_nd)
481  - Compute_Z_AtCellCenter(i,j,dom_hi.z,z_phys_nd);
482  if( (icomp+n) == Rho_comp ) {
483  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_hi.z,dest_comp) +
484  delta_z*l_bc_neumann_vals_d[bc_comp][5];
485  } else {
486  dest_arr(i,j,k,dest_comp) = dest_arr(i,j,dom_hi.z,dest_comp) +
487  delta_z*l_bc_neumann_vals_d[bc_comp][5]*dest_arr(i,j,dom_hi.z,Rho_comp);
488  }
489  } else if (h_bc_type == ERFBCType::hoextrap){
490  Real delta_k = static_cast<Real>(k - dom_hi.z);
491  dest_arr(i,j,k,dest_comp) = (one + delta_k)*dest_arr(i,j,dom_hi.z,dest_comp) - delta_k*dest_arr(i,j,dom_hi.z-1,dest_comp);
492  }
493  }
494  );
495  }
496 
497  if (do_terrain_adjustment && m_z_phys_nd) {
498  const auto& bx_lo = lbound(bx);
499  const auto& bx_hi = ubound(bx);
500  const BCRec* bc_ptr_h = bcrs.data();
501  // Neumann conditions (d<var>/dn = 0) must be aware of the surface normal with terrain.
502  // An additional source term arises from d<var>/dx & d<var>/dy & met_h_xi/eta/zeta.
503  //=====================================================================================
504  // Only modify scalars, U, or V
505  // Loop over each component
506  for (int n = 0; n < ncomp; n++) {
507  // Hit for Neumann condition at kmin
508  int dest_comp = icomp+n;
509  int l_bc_type = bc_ptr_h[n].lo(2);
510  if(l_bc_type == ERFBCType::foextrap)
511  {
512  // Loop over ghost cells in bottom XY-plane (valid box)
513  Box xybx = bx;
514 
515  int k0 = dom_lo.z;
516  if (xybx.smallEnd(2) < 0)
517  {
518  xybx.setBig(2,dom_lo.z-1);
519  xybx.setSmall(2,bx.smallEnd(2));
520 
521  // Get the dz cell size
522  Real dz = geomdata.CellSize(2);
523 
524  // Fill all the Neumann srcs with terrain
525  ParallelFor(xybx, [=] AMREX_GPU_DEVICE (int i, int j, int k)
526  {
527  // Clip indices for ghost-cells
528  int ii = amrex::min(amrex::max(i,perdom_lo.x),perdom_hi.x);
529  int jj = amrex::min(amrex::max(j,perdom_lo.y),perdom_hi.y);
530 
531  // Get metrics
532  Real met_h_xi = Compute_h_xi_AtCellCenter (ii,jj,k0,dxInv,z_phys_nd);
533  Real met_h_eta = Compute_h_eta_AtCellCenter (ii,jj,k0,dxInv,z_phys_nd);
534  Real met_h_zeta = Compute_h_zeta_AtCellCenter(ii,jj,k0,dxInv,z_phys_nd);
535 
536  // GradX at IJK location inside domain -- this relies on the assumption that we have
537  // used foextrap for cell-centered quantities outside the domain to define the gradient as zero
538  Real GradVarx, GradVary;
539  if (i < dom_lo.x-1 || i > dom_hi.x+1 || (i+1 > bx_hi.x && i-1 < bx_lo.x) ) {
540  GradVarx = zero;
541  } else if (i+1 > bx_hi.x) {
542  GradVarx = dxInv[0] * (dest_arr(i ,j,k0,dest_comp) - dest_arr(i-1,j,k0,dest_comp));
543  } else if (i-1 < bx_lo.x) {
544  GradVarx = dxInv[0] * (dest_arr(i+1,j,k0,dest_comp) - dest_arr(i ,j,k0,dest_comp));
545  } else {
546  GradVarx = myhalf * dxInv[0] * (dest_arr(i+1,j,k0,dest_comp) - dest_arr(i-1,j,k0,dest_comp));
547  }
548 
549  // GradY at IJK location inside domain -- this relies on the assumption that we have
550  // used foextrap for cell-centered quantities outside the domain to define the gradient as zero
551  if (j < dom_lo.y-1 || j > dom_hi.y+1 || (j+1 > bx_hi.y && j-1 < bx_lo.y) ) {
552  GradVary = zero;
553  } else if (j+1 > bx_hi.y) {
554  GradVary = dxInv[1] * (dest_arr(i,j ,k0,dest_comp) - dest_arr(i,j-1,k0,dest_comp));
555  } else if (j-1 < bx_lo.y) {
556  GradVary = dxInv[1] * (dest_arr(i,j+1,k0,dest_comp) - dest_arr(i,j ,k0,dest_comp));
557  } else {
558  GradVary = myhalf * dxInv[1] * (dest_arr(i,j+1,k0,dest_comp) - dest_arr(i,j-1,k0,dest_comp));
559  }
560 
561  // Prefactor
562  Real met_fac = met_h_zeta / ( met_h_xi*met_h_xi + met_h_eta*met_h_eta + one );
563 
564  // Accumulate in bottom ghost cell (EXTRAP already populated)
565  dest_arr(i,j,k,dest_comp) -= dz * met_fac * ( met_h_xi * GradVarx + met_h_eta * GradVary );
566  });
567  } // box includes k0
568  } // foextrap
569  } // ncomp
570  } // m_z_phys_nd
571  Gpu::streamSynchronize();
572 }
myhalf
constexpr amrex::Real myhalf
Definition: ERF_Constants.H:13
dxInv
amrex::GpuArray< Real, AMREX_SPACEDIM > dxInv
Definition: ERF_InitCustomPertVels_ParticleTests.H:17
Compute_h_zeta_AtCellCenter
AMREX_FORCE_INLINE AMREX_GPU_DEVICE 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:55
Compute_h_eta_AtCellCenter
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_h_eta_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:85
Compute_Z_AtCellCenter
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_Z_AtCellCenter(const int &i, const int &j, const int &k, const amrex::Array4< const amrex::Real > &z_nd)
Definition: ERF_TerrainMetrics.H:361
Compute_h_xi_AtCellCenter
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real Compute_h_xi_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:70
ERFPhysBCFunct_cons::impose_vertical_cons_bcs
void impose_vertical_cons_bcs(const amrex::Array4< amrex::Real > &dest_arr, const amrex::Box &bx, const amrex::Box &domain, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int icomp, int ncomp, const double time, bool do_terrain_adjustment=true)
Definition: ERF_BoundaryConditionsCons.cpp:329
ERFBCType::neumann
@ neumann
Definition: ERF_IndexDefines.H:254
WSM6SedCellScratch::dz
@ dz
Definition: ERF_AdvanceWSM6.cpp:104
Here is the call graph for this function:

◆ operator()()

void ERFPhysBCFunct_cons::operator() ( amrex::MultiFab &  mf,
amrex::MultiFab &  xvel,
amrex::MultiFab &  yvel,
int  icomp,
int  ncomp,
amrex::IntVect const &  nghost,
const double  time,
int  bccomp_cons,
bool  do_fb = true,
bool  do_terrain_adjustment = true 
)

Impose physical boundary conditions at domain boundaries

Parameters
[in,out]mfconserved-variable MultiFab to be filled
[in]xvelx-velocity MultiFab used by upwind boundary conditions
[in]yvely-velocity MultiFab used by upwind boundary conditions
[in]icompstarting component for conserved variables
[in]ncompnumber of components for conserved variables
[in]nghostnumber of ghost cells to be filled for conserved variables
[in]timetime at which the data should be filled
[in]bccomp_consindex into m_domain_bcs_type for conserved variables
[in]do_fbwhether to fill periodic/interior ghost cells first
[in]do_terrain_adjustmentwhether to apply terrain-aware Neumann adjustments

Impose physical boundary conditions at domain boundaries

Parameters
[in,out]mfMultiFab of cell-centered quantities to be filled
[in]xvelx-velocity MultiFab used by upwind boundary conditions
[in]yvely-velocity MultiFab used by upwind boundary conditions
[in]icompstarting component
[in]ncompnumber of components
[in]nghostnumber of ghost cells to be filled
[in]timetime at which data should be filled
[in]bccompindex into m_domain_bcs_type, unused here
[in]do_fbwhether to fill periodic/interior ghost cells first
[in]do_terrain_adjustmentwhether to apply terrain-aware Neumann adjustments
26 {
27  BL_PROFILE("ERFPhysBCFunct_cons::()");
28 
29  //
30  // We fill all of the interior and periodic ghost cells first, so we can fill
31  // those directly inside the lateral and vertical calls.
32  // If triply periodic this is all we do
33  //
34  if (do_fb) {
35  mf.FillBoundary(icomp,ncomp,m_geom.periodicity());
36  }
37 
38  if (m_geom.isAllPeriodic()) return;
39 
40  const auto& domain = m_geom.Domain();
41  const auto dxInv = m_geom.InvCellSizeArray();
42 
43  // Create a grown domain box containing valid + periodic cells
44  Box gdomain = domain;
45  for (int i = 0; i < AMREX_SPACEDIM; ++i) {
46  if (m_geom.isPeriodic(i)) {
47  gdomain.grow(i, nghost[i]);
48  }
49  }
50 
51 #ifdef AMREX_USE_OMP
52 #pragma omp parallel if (Gpu::notInLaunchRegion())
53 #endif
54  {
55  for (MFIter mfi(mf,false); mfi.isValid(); ++mfi)
56  {
57  //
58  // This is the box we pass to the different routines
59  // NOTE -- this is the full grid box NOT the tile box
60  //
61  Box bx = mfi.validbox();
62 
63  //
64  // These are the boxes we use to test on relative to the domain
65  //
66  Box cbx1 = bx; cbx1.grow(IntVect(nghost[0],nghost[1],0));
67  Box cbx2 = bx; cbx2.grow(nghost);
68 
69  Array4<const Real> z_nd_arr;
70 
71  if (m_z_phys_nd) {
72  z_nd_arr = m_z_phys_nd->const_array(mfi);
73  }
74 
75  if (!gdomain.contains(cbx2)) {
76  Array4< Real> const& cons_arr = mf.array(mfi);
77  Array4<const Real> const& velx_arr = xvel.const_array(mfi);
78  Array4<const Real> const& vely_arr = yvel.const_array(mfi);
79 
80  if (!m_use_real_bcs) {
81  // We send a box with ghost cells in the lateral directions only
82  impose_lateral_cons_bcs(cons_arr,velx_arr,vely_arr,cbx1,domain,icomp,ncomp,nghost,time);
83  }
84 
85  // We send the full FAB box with ghost cells
86  impose_vertical_cons_bcs(cons_arr,cbx2,domain,z_nd_arr,dxInv,icomp,ncomp,time,do_terrain_adjustment);
87  }
88 
89  } // MFIter
90  } // OpenMP
91 } // operator()
Vars::xvel
@ xvel
Definition: ERF_IndexDefines.H:177
Vars::yvel
@ yvel
Definition: ERF_IndexDefines.H:178

Member Data Documentation

◆ m_bc_extdir_vals

amrex::Array<amrex::Array<amrex::Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NBCVAR_max> ERFPhysBCFunct_cons::m_bc_extdir_vals
private

◆ m_bc_neumann_vals

amrex::Array<amrex::Array<amrex::Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NBCVAR_max> ERFPhysBCFunct_cons::m_bc_neumann_vals
private

◆ m_domain_bcs_type

amrex::Vector<amrex::BCRec> ERFPhysBCFunct_cons::m_domain_bcs_type
private

◆ m_domain_bcs_type_d

amrex::Gpu::DeviceVector<amrex::BCRec> ERFPhysBCFunct_cons::m_domain_bcs_type_d
private

◆ m_geom

amrex::Geometry ERFPhysBCFunct_cons::m_geom
private

◆ m_lev

int ERFPhysBCFunct_cons::m_lev
private

◆ m_th_bc_data

amrex::Real* ERFPhysBCFunct_cons::m_th_bc_data
private

◆ m_use_real_bcs

bool ERFPhysBCFunct_cons::m_use_real_bcs
private

◆ m_z_phys_nd

amrex::MultiFab* ERFPhysBCFunct_cons::m_z_phys_nd
private
The documentation for this class was generated from the following files: