ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Functions
ERF_ApplySpongeZoneBCs_ReadFromFile.cpp File Reference
#include <AMReX_MultiFab.H>
#include <ERF_SrcHeaders.H>
#include <ERF_InputSpongeData.H>
Include dependency graph for ERF_ApplySpongeZoneBCs_ReadFromFile.cpp:

Functions

void ApplySpongeZoneBCsForMom_ReadFromFile (const SpongeChoice &spongeChoice, const Geometry geom, const Box &tbx, const Box &tby, const Array4< const Real > &cell_data, const Array4< const Real > &z_phys_cc, const Array4< Real > &rho_u_rhs, const Array4< Real > &rho_v_rhs, const Array4< const Real > &rho_u, const Array4< const Real > &rho_v, const Vector< Real * > d_sponge_ptrs_at_lev)
 

Function Documentation

◆ ApplySpongeZoneBCsForMom_ReadFromFile()

void ApplySpongeZoneBCsForMom_ReadFromFile ( const SpongeChoice &  spongeChoice,
const Geometry  geom,
const Box &  tbx,
const Box &  tby,
const Array4< const Real > &  cell_data,
const Array4< const Real > &  z_phys_cc,
const Array4< Real > &  rho_u_rhs,
const Array4< Real > &  rho_v_rhs,
const Array4< const Real > &  rho_u,
const Array4< const Real > &  rho_v,
const Vector< Real * >  d_sponge_ptrs_at_lev 
)

Apply sponge zone damping to momentum RHS using target states read from a file.

Parameters
[in]spongeChoiceSponge zone configuration.
[in]geomGeometry for grid spacing and bounds.
[in]tbxBox for x-momentum update.
[in]tbyBox for y-momentum update.
[in]cell_dataCell-centered state data.
[in]z_phys_ccCell-centered physical height.
[in,out]rho_u_rhsRight-hand side for x-momentum.
[in,out]rho_v_rhsRight-hand side for y-momentum.
[in]rho_uCurrent x-momentum.
[in]rho_vCurrent y-momentum.
[in]d_sponge_ptrs_at_levPointers to target sponge velocities.
34 {
35  // Domain cell size and real bounds
36  auto dx = geom.CellSizeArray();
37  auto ProbHiArr = geom.ProbHiArray();
38  auto ProbLoArr = geom.ProbLoArray();
39 
40  const Real sponge_strength = spongeChoice.sponge_strength;
41  const int use_xlo_sponge_damping = spongeChoice.use_xlo_sponge_damping;
42  const int use_xhi_sponge_damping = spongeChoice.use_xhi_sponge_damping;
43  const int use_ylo_sponge_damping = spongeChoice.use_ylo_sponge_damping;
44  const int use_yhi_sponge_damping = spongeChoice.use_yhi_sponge_damping;
45  const int use_zlo_sponge_damping = spongeChoice.use_zlo_sponge_damping;
46  const int use_zhi_sponge_damping = spongeChoice.use_zhi_sponge_damping;
47 
48  const Real xlo_sponge_end = spongeChoice.xlo_sponge_end;
49  const Real xhi_sponge_start = spongeChoice.xhi_sponge_start;
50  const Real ylo_sponge_end = spongeChoice.ylo_sponge_end;
51  const Real yhi_sponge_start = spongeChoice.yhi_sponge_start;
52  const Real zlo_sponge_end = spongeChoice.zlo_sponge_end;
53  const Real zhi_sponge_start = spongeChoice.zhi_sponge_start;
54 
55  // Domain valid box
56  const Box& domain = geom.Domain();
57  int domlo_x = domain.smallEnd(0);
58  int domhi_x = domain.bigEnd(0) + 1;
59  int domlo_y = domain.smallEnd(1);
60  int domhi_y = domain.bigEnd(1) + 1;
61 
62  Real* ubar_sponge = d_sponge_ptrs_at_lev[Sponge::ubar_sponge];
63  Real* vbar_sponge = d_sponge_ptrs_at_lev[Sponge::vbar_sponge];
64 
65  if(use_xlo_sponge_damping)AMREX_ALWAYS_ASSERT(xlo_sponge_end > ProbLoArr[0]);
66  if(use_xhi_sponge_damping)AMREX_ALWAYS_ASSERT(xhi_sponge_start < ProbHiArr[0]);
67  if(use_ylo_sponge_damping)AMREX_ALWAYS_ASSERT(ylo_sponge_end > ProbLoArr[1]);
68  if(use_yhi_sponge_damping)AMREX_ALWAYS_ASSERT(yhi_sponge_start < ProbHiArr[1]);
69  if(use_zlo_sponge_damping)AMREX_ALWAYS_ASSERT(zlo_sponge_end > ProbLoArr[2]);
70  if(use_zhi_sponge_damping)AMREX_ALWAYS_ASSERT(zhi_sponge_start < ProbHiArr[2]);
71 
72  // Ramp lengths, computed here so that the kernels divide only by a valid length: the
73  // optimiser evaluates the guarded ramps of the sides that are switched off too, and the
74  // lengths of those sides (whose ends are never read from the inputs) can be zero
75  const Real L_xlo = use_xlo_sponge_damping ? (xlo_sponge_end - ProbLoArr[0]) : one;
76  const Real L_xhi = use_xhi_sponge_damping ? (ProbHiArr[0] - xhi_sponge_start) : one;
77  const Real L_ylo = use_ylo_sponge_damping ? (ylo_sponge_end - ProbLoArr[1]) : one;
78  const Real L_yhi = use_yhi_sponge_damping ? (ProbHiArr[1] - yhi_sponge_start) : one;
79  const Real L_zlo = use_zlo_sponge_damping ? (zlo_sponge_end - ProbLoArr[2]) : one;
80  const Real L_zhi = use_zhi_sponge_damping ? (ProbHiArr[2] - zhi_sponge_start) : one;
81 
82  ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
83  {
84  int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
85  int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
86 
87  Real x = ProbLoArr[0] + ii * dx[0];
88  Real y = ProbLoArr[1] + (jj+myhalf) * dx[1];
89  Real z = z_phys_cc(i,j,k);
90 
91  // x lo sponge
92  if(use_xlo_sponge_damping){
93  if (x < xlo_sponge_end) {
94  Real xi = (xlo_sponge_end - x) / L_xlo;
95  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
96  }
97  }
98  // x hi sponge
99  if(use_xhi_sponge_damping){
100  if (x > xhi_sponge_start) {
101  Real xi = (x - xhi_sponge_start) / L_xhi;
102  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
103  }
104  }
105 
106  // y lo sponge
107  if(use_ylo_sponge_damping){
108  if (y < ylo_sponge_end) {
109  Real xi = (ylo_sponge_end - y) / L_ylo;
110  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
111  }
112  }
113  // x right sponge
114  if(use_yhi_sponge_damping){
115  if (y > yhi_sponge_start) {
116  Real xi = (y - yhi_sponge_start) / L_yhi;
117  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
118  }
119  }
120 
121  // z lo sponge
122  if(use_zlo_sponge_damping){
123  if (z < zlo_sponge_end) {
124  Real xi = (zlo_sponge_end - z) / L_zlo;
125  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
126  }
127  }
128 
129 
130  // z hi sponge
131  if(use_zhi_sponge_damping){
132  if (z > zhi_sponge_start) {
133  Real xi = (z - zhi_sponge_start) / L_zhi;
134  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
135  }
136  }
137  });
138 
139 
140  ParallelFor(tby, [=] AMREX_GPU_DEVICE(int i, int j, int k)
141  {
142  int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
143  int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
144 
145  Real x = ProbLoArr[0] + (ii+myhalf) * dx[0];
146  Real y = ProbLoArr[1] + jj * dx[1];
147  Real z = z_phys_cc(i,j,k);
148 
149  // x lo sponge
150  if(use_xlo_sponge_damping){
151  if (x < xlo_sponge_end) {
152  Real xi = (xlo_sponge_end - x) / L_xlo;
153  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
154  }
155  }
156  // x hi sponge
157  if(use_xhi_sponge_damping){
158  if (x > xhi_sponge_start) {
159  Real xi = (x - xhi_sponge_start) / L_xhi;
160  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
161  }
162  }
163 
164  // y lo sponge
165  if(use_ylo_sponge_damping){
166  if (y < ylo_sponge_end) {
167  Real xi = (ylo_sponge_end - y) / L_ylo;
168  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
169  }
170  }
171  // x right sponge
172  if(use_yhi_sponge_damping){
173  if (y > yhi_sponge_start) {
174  Real xi = (y - yhi_sponge_start) / L_yhi;
175  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
176  }
177  }
178 
179  // z lo sponge
180  if(use_zlo_sponge_damping){
181  if (z < zlo_sponge_end) {
182  Real xi = (zlo_sponge_end - z) / L_zlo;
183  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
184  }
185  }
186 
187 
188  // z hi sponge
189  if(use_zhi_sponge_damping){
190  if (z > zhi_sponge_start) {
191  Real xi = (z - zhi_sponge_start) / L_zhi;
192  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
193  }
194  }
195  });
196 }
vbar_sponge
@ vbar_sponge
Definition: ERF_DataStruct.H:202
ubar_sponge
@ ubar_sponge
Definition: ERF_DataStruct.H:202
Coord::y
@ y
Coord::x
@ x
Coord::z
@ z
dx
const Real dx
Definition: ERF_InitCustomPert_ABL.H:44
AMREX_ALWAYS_ASSERT
AMREX_ALWAYS_ASSERT(bx.length()[2]==khi+1)
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);})
one
constexpr amrex::Real one
Definition: ERF_NumericalConstants.H:37
myhalf
constexpr amrex::Real myhalf
Definition: ERF_NumericalConstants.H:41
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
SpongeChoice::zlo_sponge_end
amrex::Real zlo_sponge_end
Physical end location of the low-z sponge layer.
Definition: ERF_SpongeStruct.H:105
SpongeChoice::xlo_sponge_end
amrex::Real xlo_sponge_end
Physical end location of the low-x sponge layer.
Definition: ERF_SpongeStruct.H:103
SpongeChoice::use_zlo_sponge_damping
bool use_zlo_sponge_damping
Whether sponge damping is applied at the low-z boundary.
Definition: ERF_SpongeStruct.H:94
SpongeChoice::ylo_sponge_end
amrex::Real ylo_sponge_end
Physical end location of the low-y sponge layer.
Definition: ERF_SpongeStruct.H:104
SpongeChoice::sponge_strength
amrex::Real sponge_strength
Sponge damping strength.
Definition: ERF_SpongeStruct.H:97
SpongeChoice::yhi_sponge_start
amrex::Real yhi_sponge_start
Physical start location of the high-y sponge layer.
Definition: ERF_SpongeStruct.H:104
SpongeChoice::use_zhi_sponge_damping
bool use_zhi_sponge_damping
Whether sponge damping is applied at the high-z boundary.
Definition: ERF_SpongeStruct.H:95
SpongeChoice::use_xlo_sponge_damping
bool use_xlo_sponge_damping
Whether sponge damping is applied at the low-x boundary.
Definition: ERF_SpongeStruct.H:90
SpongeChoice::xhi_sponge_start
amrex::Real xhi_sponge_start
Physical start location of the high-x sponge layer.
Definition: ERF_SpongeStruct.H:103
SpongeChoice::use_xhi_sponge_damping
bool use_xhi_sponge_damping
Whether sponge damping is applied at the high-x boundary.
Definition: ERF_SpongeStruct.H:91
SpongeChoice::use_yhi_sponge_damping
bool use_yhi_sponge_damping
Whether sponge damping is applied at the high-y boundary.
Definition: ERF_SpongeStruct.H:93
SpongeChoice::use_ylo_sponge_damping
bool use_ylo_sponge_damping
Whether sponge damping is applied at the low-y boundary.
Definition: ERF_SpongeStruct.H:92
SpongeChoice::zhi_sponge_start
amrex::Real zhi_sponge_start
Physical start location of the high-z sponge layer.
Definition: ERF_SpongeStruct.H:105

Referenced by make_mom_sources().

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