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

#include <ERF_PhysBCFunct.H>

Collaboration diagram for ERFPhysBCFunct_w:
Collaboration graph
[legend]

Public Member Functions

 ERFPhysBCFunct_w (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+NVAR_max > bc_extdir_vals, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max > bc_neumann_vals, const TerrainType &terrain_type, std::unique_ptr< amrex::MultiFab > &z_phys_nd, const bool use_real_bcs)
 
 ~ERFPhysBCFunct_w ()
 
void operator() (amrex::MultiFab &mf, amrex::MultiFab &xvel, amrex::MultiFab &yvel, amrex::IntVect const &nghost, const amrex::Real time, int bccomp_u, int bccomp_v, int bccomp_w)
 
void impose_lateral_zvel_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, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int bccomp_w)
 
void impose_vertical_zvel_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, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int bccomp_u, int bccomp_v, int bccomp_w, TerrainType terrain_type)
 

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+NVAR_max > m_bc_extdir_vals
 
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max > m_bc_neumann_vals
 
TerrainType m_terrain_type
 
amrex::MultiFab * m_z_phys_nd
 
bool m_use_real_bcs
 

Constructor & Destructor Documentation

◆ ERFPhysBCFunct_w()

ERFPhysBCFunct_w::ERFPhysBCFunct_w ( 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+NVAR_max >  bc_extdir_vals,
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max >  bc_neumann_vals,
const TerrainType &  terrain_type,
std::unique_ptr< amrex::MultiFab > &  z_phys_nd,
const bool  use_real_bcs 
)
inline
194  : m_lev(lev),
195  m_geom(geom), m_domain_bcs_type(domain_bcs_type),
196  m_domain_bcs_type_d(domain_bcs_type_d),
197  m_bc_extdir_vals(bc_extdir_vals),
198  m_bc_neumann_vals(bc_neumann_vals),
199  m_terrain_type(terrain_type),
200  m_z_phys_nd(z_phys_nd.get()),
201  m_use_real_bcs(use_real_bcs)
202  {}
ERFPhysBCFunct_w::m_domain_bcs_type
amrex::Vector< amrex::BCRec > m_domain_bcs_type
Definition: ERF_PhysBCFunct.H:239
ERFPhysBCFunct_w::m_geom
amrex::Geometry m_geom
Definition: ERF_PhysBCFunct.H:238
ERFPhysBCFunct_w::m_lev
int m_lev
Definition: ERF_PhysBCFunct.H:237
ERFPhysBCFunct_w::m_bc_neumann_vals
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max > m_bc_neumann_vals
Definition: ERF_PhysBCFunct.H:242
ERFPhysBCFunct_w::m_use_real_bcs
bool m_use_real_bcs
Definition: ERF_PhysBCFunct.H:245
ERFPhysBCFunct_w::m_domain_bcs_type_d
amrex::Gpu::DeviceVector< amrex::BCRec > m_domain_bcs_type_d
Definition: ERF_PhysBCFunct.H:240
ERFPhysBCFunct_w::m_terrain_type
TerrainType m_terrain_type
Definition: ERF_PhysBCFunct.H:243
ERFPhysBCFunct_w::m_z_phys_nd
amrex::MultiFab * m_z_phys_nd
Definition: ERF_PhysBCFunct.H:244
ERFPhysBCFunct_w::m_bc_extdir_vals
amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max > m_bc_extdir_vals
Definition: ERF_PhysBCFunct.H:241

◆ ~ERFPhysBCFunct_w()

ERFPhysBCFunct_w::~ERFPhysBCFunct_w ( )
inline
204 {}

Member Function Documentation

◆ impose_lateral_zvel_bcs()

void ERFPhysBCFunct_w::impose_lateral_zvel_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,
const amrex::Array4< amrex::Real const > &  z_nd,
const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >  dxInv,
int  bccomp_w 
)
23 {
24  BL_PROFILE_VAR("impose_lateral_zvel_bcs()",impose_lateral_zvel_bcs);
25  const auto& dom_lo = lbound(domain);
26  const auto& dom_hi = ubound(domain);
27 
28  // Based on BCRec for the domain, we need to make BCRec for this Box
29  // bccomp is used as starting index for m_domain_bcs_type
30  // 0 is used as starting index for bcrs
31  int ncomp = 1;
32  Vector<BCRec> bcrs_w(1);
33  setBC(enclosedCells(bx), domain, bccomp, 0, 1, m_domain_bcs_type, bcrs_w);
34 
35  // xlo: ori = 0
36  // ylo: ori = 1
37  // zlo: ori = 2
38  // xhi: ori = 3
39  // yhi: ori = 4
40  // zhi: ori = 5
41 
42  Gpu::DeviceVector<BCRec> bcrs_w_d(ncomp);
43  Gpu::copyAsync(Gpu::hostToDevice, bcrs_w.begin(), bcrs_w.end(), bcrs_w_d.begin());
44  const BCRec* bc_ptr_w = bcrs_w_d.data();
45 
46  GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NVAR_max> l_bc_extdir_vals_d;
47 
48  bool l_use_terrain = (m_z_phys_nd != nullptr);
49 
50  for (int i = 0; i < ncomp; i++)
51  for (int ori = 0; ori < 2*AMREX_SPACEDIM; ori++)
52  l_bc_extdir_vals_d[i][ori] = m_bc_extdir_vals[bccomp+i][ori];
53 
54  GeometryData const& geomdata = m_geom.data();
55  bool is_periodic_in_x = geomdata.isPeriodic(0);
56  bool is_periodic_in_y = geomdata.isPeriodic(1);
57 
58  FArrayBox dhdtfab;
59 
60  // First do all ext_dir bcs
61  if (!is_periodic_in_x)
62  {
63  Box bx_xlo(bx); bx_xlo.setBig (0,dom_lo.x-1);
64  Box bx_xhi(bx); bx_xhi.setSmall(0,dom_hi.x+1);
65  ParallelFor(
66  bx_xlo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) {
67  int iflip = dom_lo.x - 1 - i;
68  if (bc_ptr_w[n].lo(0) == ERFBCType::ext_dir) {
69  dest_arr(i,j,k) = l_bc_extdir_vals_d[n][0];
70  if (l_use_terrain) {
71  dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
72  }
73  } else if (bc_ptr_w[n].lo(0) == ERFBCType::foextrap) {
74  dest_arr(i,j,k) = dest_arr(dom_lo.x,j,k);
75  } else if (bc_ptr_w[n].lo(0) == ERFBCType::open) {
76  dest_arr(i,j,k) = dest_arr(dom_lo.x,j,k);
77  } else if (bc_ptr_w[n].lo(0) == ERFBCType::reflect_even) {
78  dest_arr(i,j,k) = dest_arr(iflip,j,k);
79  } else if (bc_ptr_w[n].lo(0) == ERFBCType::reflect_odd) {
80  dest_arr(i,j,k) = -dest_arr(iflip,j,k);
81  }
82  },
83  bx_xhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) {
84  int iflip = 2*dom_hi.x + 1 - i;
85  if (bc_ptr_w[n].hi(0) == ERFBCType::ext_dir) {
86  dest_arr(i,j,k) = l_bc_extdir_vals_d[n][3];
87  if (l_use_terrain) {
88  dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
89  }
90  } else if (bc_ptr_w[n].hi(0) == ERFBCType::foextrap) {
91  dest_arr(i,j,k) = dest_arr(dom_hi.x,j,k);
92  } else if (bc_ptr_w[n].hi(0) == ERFBCType::open) {
93  dest_arr(i,j,k) = dest_arr(dom_hi.x,j,k);
94  } else if (bc_ptr_w[n].hi(0) == ERFBCType::reflect_even) {
95  dest_arr(i,j,k) = dest_arr(iflip,j,k);
96  } else if (bc_ptr_w[n].hi(0) == ERFBCType::reflect_odd) {
97  dest_arr(i,j,k) = -dest_arr(iflip,j,k);
98  }
99  }
100  );
101  }
102 
103  // First do all ext_dir bcs
104  if (!is_periodic_in_y)
105  {
106  Box bx_ylo(bx); bx_ylo.setBig (1,dom_lo.y-1);
107  Box bx_yhi(bx); bx_yhi.setSmall(1,dom_hi.y+1);
108  ParallelFor(bx_ylo, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) {
109  int jflip = dom_lo.y - 1 - j;
110  if (bc_ptr_w[n].lo(1) == ERFBCType::ext_dir) {
111  dest_arr(i,j,k) = l_bc_extdir_vals_d[n][1];
112  if (l_use_terrain) {
113  dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
114  }
115  } else if (bc_ptr_w[n].lo(1) == ERFBCType::foextrap) {
116  dest_arr(i,j,k) = dest_arr(i,dom_lo.y,k);
117  } else if (bc_ptr_w[n].lo(1) == ERFBCType::open) {
118  dest_arr(i,j,k) = dest_arr(i,dom_lo.y,k);
119  } else if (bc_ptr_w[n].lo(1) == ERFBCType::reflect_even) {
120  dest_arr(i,j,k) = dest_arr(i,jflip,k);
121  } else if (bc_ptr_w[n].lo(1) == ERFBCType::reflect_odd) {
122  dest_arr(i,j,k) = -dest_arr(i,jflip,k);
123  }
124  },
125  bx_yhi, ncomp, [=] AMREX_GPU_DEVICE (int i, int j, int k, int n) {
126  int jflip = 2*dom_hi.y + 1 - j;
127  if (bc_ptr_w[n].hi(1) == ERFBCType::ext_dir) {
128  dest_arr(i,j,k) = l_bc_extdir_vals_d[n][4];
129  dest_arr(i,j,k) = WFromOmega(i,j,k,dest_arr(i,j,k),xvel_arr,yvel_arr,z_phys_nd,dxInv);
130  } else if (bc_ptr_w[n].hi(1) == ERFBCType::foextrap) {
131  dest_arr(i,j,k) = dest_arr(i,dom_hi.y,k);
132  } else if (bc_ptr_w[n].hi(1) == ERFBCType::open) {
133  dest_arr(i,j,k) = dest_arr(i,dom_hi.y,k);
134  } else if (bc_ptr_w[n].hi(1) == ERFBCType::reflect_even) {
135  dest_arr(i,j,k) = dest_arr(i,jflip,k);
136  } else if (bc_ptr_w[n].hi(1) == ERFBCType::reflect_odd) {
137  dest_arr(i,j,k) = -dest_arr(i,jflip,k);
138  }
139  });
140  }
141 
142  Gpu::streamSynchronize();
143 }
NVAR_max
#define NVAR_max
Definition: IndexDefines.H:27
WFromOmega
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real WFromOmega(int i, int j, int k, amrex::Real omega, amrex::Real u, amrex::Real v, const amrex::Array4< const amrex::Real > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > &dxInv)
Definition: TerrainMetrics.H:399
ERFPhysBCFunct_w::impose_lateral_zvel_bcs
void impose_lateral_zvel_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, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int bccomp_w)
Definition: BoundaryConditions_zvel.cpp:16
ERFBCType::open
@ open
Definition: IndexDefines.H:157
ERFBCType::reflect_odd
@ reflect_odd
Definition: IndexDefines.H:148
ERFBCType::foextrap
@ foextrap
Definition: IndexDefines.H:151
ERFBCType::ext_dir
@ ext_dir
Definition: IndexDefines.H:152
ERFBCType::reflect_even
@ reflect_even
Definition: IndexDefines.H:150
Here is the call graph for this function:

◆ impose_vertical_zvel_bcs()

void ERFPhysBCFunct_w::impose_vertical_zvel_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,
const amrex::Array4< amrex::Real const > &  z_nd,
const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >  dxInv,
int  bccomp_u,
int  bccomp_v,
int  bccomp_w,
TerrainType  terrain_type 
)
167 {
168  BL_PROFILE_VAR("impose_vertical_zvel_bcs()",impose_vertical_zvel_bcs);
169  const auto& dom_lo = lbound(domain);
170  const auto& dom_hi = ubound(domain);
171 
172  // xlo: ori = 0
173  // ylo: ori = 1
174  // zlo: ori = 2
175  // xhi: ori = 3
176  // yhi: ori = 4
177  // zhi: ori = 5
178 
179  // Based on BCRec for the domain, we need to make BCRec for this Box
180  // bccomp is used as starting index for m_domain_bcs_type
181  // 0 is used as starting index for bcrs
182  int ncomp = 1;
183  Vector<BCRec> bcrs_u(1), bcrs_v(1), bcrs_w(1);
184  setBC(enclosedCells(bx), domain, bccomp_u, 0, 1, m_domain_bcs_type, bcrs_u);
185  setBC(enclosedCells(bx), domain, bccomp_v, 0, 1, m_domain_bcs_type, bcrs_v);
186  setBC(enclosedCells(bx), domain, bccomp_w, 0, 1, m_domain_bcs_type, bcrs_w);
187 
188  // We use these for the asserts below
189  const BCRec* bc_ptr_u_h = bcrs_u.data();
190  const BCRec* bc_ptr_v_h = bcrs_v.data();
191  const BCRec* bc_ptr_w_h = bcrs_w.data();
192 
193  bool l_use_terrain = (m_z_phys_nd != nullptr);
194  bool l_moving_terrain = (terrain_type == TerrainType::Moving);
195 
196  GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NVAR_max> l_bc_extdir_vals_d;
197 
198  for (int i = 0; i < ncomp; i++) {
199  for (int ori = 0; ori < 2*AMREX_SPACEDIM; ori++) {
200  l_bc_extdir_vals_d[i][ori] = m_bc_extdir_vals[bccomp_w+i][ori];
201  }
202  }
203 
204  // *******************************************************
205  // Bottom boundary
206  // *******************************************************
207 
208  // At the bottom boundary we always assert no normal flow
209  if (m_lev == 0) {
210  AMREX_ALWAYS_ASSERT(bc_ptr_w_h[0].lo(2) == ERFBCType::ext_dir);
211  } else {
212  // If we do not reach to the top or bottom boundary then the z-vel should be
213  // filled by interpolation from the coarser grid using ERF_FillPatcher.
214  }
215 
216  // Moving terrain
217  if (l_use_terrain && l_moving_terrain)
218  {
219  //************************************************************
220  // NOTE: z_t depends on the time interval in which it is
221  // evaluated so we can't arbitrarily define it at a
222  // given time, we must specify an interval
223  //************************************************************
224 
225  // Static terrain
226  } else if (l_use_terrain) {
227 
228  if (m_lev == 0) {
229  AMREX_ALWAYS_ASSERT( (bc_ptr_u_h[0].lo(2) == ERFBCType::ext_dir && bc_ptr_v_h[0].lo(2) == ERFBCType::ext_dir) ||
230  (bc_ptr_u_h[0].lo(2) != ERFBCType::ext_dir && bc_ptr_v_h[0].lo(2) != ERFBCType::ext_dir) );
231  } else {
232  // If we do not reach to the top or bottom boundary then the z-vel should be
233  // filled by interpolation from the coarser grid using ERF_FillPatcher.
234  }
235  if (bx.smallEnd(2) == dom_lo.z) {
236  ParallelFor(makeSlab(bx,2,dom_lo.z), [=] AMREX_GPU_DEVICE (int i, int j, int k) {
237  dest_arr(i,j,k) = WFromOmega(i,j,k,l_bc_extdir_vals_d[0][2],xvel_arr,yvel_arr,z_phys_nd,dxInv);
238  });
239  }
240 
241  // No terrain
242  } else {
243  if (bx.smallEnd(2) == dom_lo.z) {
244  ParallelFor(makeSlab(bx,2,dom_lo.z), [=] AMREX_GPU_DEVICE (int i, int j, int k) {
245  dest_arr(i,j,k) = l_bc_extdir_vals_d[0][2];
246  });
247  }
248  }
249 
250  // *******************************************************
251  // Top boundary
252  // *******************************************************
253 
254  if (m_lev == 0) {
255  AMREX_ALWAYS_ASSERT(bc_ptr_w_h[0].hi(2) == ERFBCType::ext_dir ||
256  bc_ptr_w_h[0].hi(2) == ERFBCType::neumann_int);
257  } else {
258  // If we do not reach to the top or bottom boundary then the z-vel should be
259  // filled by interpolation from the coarser grid using ERF_FillPatcher.
260  }
261 
262 
263  // NOTE: if we set SlipWall at top, that generates ERFBCType::ext_dir which sets w=0 here
264  // NOTE: if we set Outflow at top, that generates ERFBCType::foextrap which doesn't touch w here
265  if (bx.bigEnd(2) == dom_hi.z+1) {
266  if (bc_ptr_w_h[0].hi(2) == ERFBCType::ext_dir) {
267  ParallelFor(makeSlab(bx,2,dom_hi.z+1), [=] AMREX_GPU_DEVICE (int i, int j, int k)
268  {
269  if (l_use_terrain) {
270  dest_arr(i,j,k) = WFromOmega(i,j,k,l_bc_extdir_vals_d[0][5],xvel_arr,yvel_arr,z_phys_nd,dxInv);
271  } else {
272  dest_arr(i,j,k) = l_bc_extdir_vals_d[0][5];
273  }
274  });
275  } else if (bc_ptr_w_h[0].hi(2) == ERFBCType::neumann_int) {
276  ParallelFor(makeSlab(bx,2,dom_hi.z+1), [=] AMREX_GPU_DEVICE (int i, int j, int k)
277  {
278  dest_arr(i,j,k) = (4.0*dest_arr(i,j,dom_hi.z) - dest_arr(i,j,dom_hi.z-1))/3.0;
279  });
280  }
281  }
282  Gpu::streamSynchronize();
283 }
ERFPhysBCFunct_w::impose_vertical_zvel_bcs
void impose_vertical_zvel_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, const amrex::Array4< amrex::Real const > &z_nd, const amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > dxInv, int bccomp_u, int bccomp_v, int bccomp_w, TerrainType terrain_type)
Definition: BoundaryConditions_zvel.cpp:159
ERFBCType::neumann_int
@ neumann_int
Definition: IndexDefines.H:156
Here is the call graph for this function:

◆ operator()()

void ERFPhysBCFunct_w::operator() ( amrex::MultiFab &  mf,
amrex::MultiFab &  xvel,
amrex::MultiFab &  yvel,
amrex::IntVect const &  nghost,
const amrex::Real  time,
int  bccomp_u,
int  bccomp_v,
int  bccomp_w 
)
197 {
198  BL_PROFILE("ERFPhysBCFunct_w::()");
199 
200  if (m_geom.isAllPeriodic()) return;
201 
202  const auto& domain = m_geom.Domain();
203  const auto dxInv = m_geom.InvCellSizeArray();
204 
205  Box gdomainz = surroundingNodes(domain,2);
206  for (int i = 0; i < AMREX_SPACEDIM; ++i) {
207  if (m_geom.isPeriodic(i)) {
208  gdomainz.grow(i, nghost[i]);
209  }
210  }
211  // We want to make sure we impose the z-vels at k=0 if the box includes k=0
212  if (gdomainz.smallEnd(2) == 0) gdomainz.setSmall(2,1);
213 
214 #ifdef AMREX_USE_OMP
215 #pragma omp parallel if (Gpu::notInLaunchRegion())
216 #endif
217  {
218  for (MFIter mfi(mf,false); mfi.isValid(); ++mfi)
219  {
220  //
221  // This is the box we pass to the different routines
222  // NOTE -- this is the full grid NOT the tile box
223  //
224  Box bx = mfi.validbox();
225 
226  //
227  // These are the boxes we use to test on relative to the domain
228  //
229  Box zbx = surroundingNodes(bx,2); zbx.grow(0,nghost[0]);
230  zbx.grow(1,nghost[1]);
231  Array4<const Real> z_nd_arr;
232 
233  if (m_z_phys_nd)
234  {
235  z_nd_arr = m_z_phys_nd->const_array(mfi);
236  }
237 
238  Array4<const Real> const& velx_arr = xvel.const_array(mfi);;
239  Array4<const Real> const& vely_arr = yvel.const_array(mfi);;
240  Array4< Real> const& velz_arr = mf.array(mfi);;
241 
242  if (!m_use_real_bcs)
243  {
244  if (!gdomainz.contains(zbx))
245  {
246  impose_lateral_zvel_bcs(velz_arr,velx_arr,vely_arr,zbx,domain,z_nd_arr,dxInv,bccomp_w);
247  }
248  } // m_use_real_bcs
249 
250  if (!gdomainz.contains(zbx)) {
251  impose_vertical_zvel_bcs(velz_arr,velx_arr,vely_arr,zbx,domain,z_nd_arr,dxInv,
252  bccomp_u, bccomp_v, bccomp_w, m_terrain_type);
253  }
254  } // MFIter
255  } // OpenMP
256 } // operator()
Vars::xvel
@ xvel
Definition: IndexDefines.H:100
Vars::yvel
@ yvel
Definition: IndexDefines.H:101

Member Data Documentation

◆ m_bc_extdir_vals

amrex::Array<amrex::Array<amrex::Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NVAR_max> ERFPhysBCFunct_w::m_bc_extdir_vals
private

◆ m_bc_neumann_vals

amrex::Array<amrex::Array<amrex::Real, AMREX_SPACEDIM*2>,AMREX_SPACEDIM+NVAR_max> ERFPhysBCFunct_w::m_bc_neumann_vals
private

◆ m_domain_bcs_type

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

◆ m_domain_bcs_type_d

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

◆ m_geom

amrex::Geometry ERFPhysBCFunct_w::m_geom
private

◆ m_lev

int ERFPhysBCFunct_w::m_lev
private

◆ m_terrain_type

TerrainType ERFPhysBCFunct_w::m_terrain_type
private

◆ m_use_real_bcs

bool ERFPhysBCFunct_w::m_use_real_bcs
private

◆ m_z_phys_nd

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