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  ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
73  {
74  int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
75  int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
76 
77  Real x = ProbLoArr[0] + ii * dx[0];
78  Real y = ProbLoArr[1] + (jj+myhalf) * dx[1];
79  Real z = z_phys_cc(i,j,k);
80 
81  // x lo sponge
82  if(use_xlo_sponge_damping){
83  if (x < xlo_sponge_end) {
84  Real xi = (xlo_sponge_end - x) / (xlo_sponge_end - ProbLoArr[0]);
85  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
86  }
87  }
88  // x hi sponge
89  if(use_xhi_sponge_damping){
90  if (x > xhi_sponge_start) {
91  Real xi = (x - xhi_sponge_start) / (ProbHiArr[0] - xhi_sponge_start);
92  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
93  }
94  }
95 
96  // y lo sponge
97  if(use_ylo_sponge_damping){
98  if (y < ylo_sponge_end) {
99  Real xi = (ylo_sponge_end - y) / (ylo_sponge_end - ProbLoArr[1]);
100  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
101  }
102  }
103  // x right sponge
104  if(use_yhi_sponge_damping){
105  if (y > yhi_sponge_start) {
106  Real xi = (y - yhi_sponge_start) / (ProbHiArr[1] - yhi_sponge_start);
107  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
108  }
109  }
110 
111  // z lo sponge
112  if(use_zlo_sponge_damping){
113  if (z < zlo_sponge_end) {
114  Real xi = (zlo_sponge_end - z) / (zlo_sponge_end - ProbLoArr[2]);
115  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
116  }
117  }
118 
119 
120  // z hi sponge
121  if(use_zhi_sponge_damping){
122  if (z > zhi_sponge_start) {
123  Real xi = (z - zhi_sponge_start) / (ProbHiArr[2] - zhi_sponge_start);
124  rho_u_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_u(i, j, k) - cell_data(i,j,k,0)*ubar_sponge[k]);
125  }
126  }
127  });
128 
129 
130  ParallelFor(tby, [=] AMREX_GPU_DEVICE(int i, int j, int k)
131  {
132  int ii = amrex::min(amrex::max(i, domlo_x), domhi_x);
133  int jj = amrex::min(amrex::max(j, domlo_y), domhi_y);
134 
135  Real x = ProbLoArr[0] + (ii+myhalf) * dx[0];
136  Real y = ProbLoArr[1] + jj * dx[1];
137  Real z = z_phys_cc(i,j,k);
138 
139  // x lo sponge
140  if(use_xlo_sponge_damping){
141  if (x < xlo_sponge_end) {
142  Real xi = (xlo_sponge_end - x) / (xlo_sponge_end - ProbLoArr[0]);
143  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
144  }
145  }
146  // x hi sponge
147  if(use_xhi_sponge_damping){
148  if (x > xhi_sponge_start) {
149  Real xi = (x - xhi_sponge_start) / (ProbHiArr[0] - xhi_sponge_start);
150  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
151  }
152  }
153 
154  // y lo sponge
155  if(use_ylo_sponge_damping){
156  if (y < ylo_sponge_end) {
157  Real xi = (ylo_sponge_end - y) / (ylo_sponge_end - ProbLoArr[1]);
158  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
159  }
160  }
161  // x right sponge
162  if(use_yhi_sponge_damping){
163  if (y > yhi_sponge_start) {
164  Real xi = (y - yhi_sponge_start) / (ProbHiArr[1] - yhi_sponge_start);
165  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
166  }
167  }
168 
169  // z lo sponge
170  if(use_zlo_sponge_damping){
171  if (z < zlo_sponge_end) {
172  Real xi = (zlo_sponge_end - z) / (zlo_sponge_end - ProbLoArr[2]);
173  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
174  }
175  }
176 
177 
178  // z hi sponge
179  if(use_zhi_sponge_damping){
180  if (z > zhi_sponge_start) {
181  Real xi = (z - zhi_sponge_start) / (ProbHiArr[2] - zhi_sponge_start);
182  rho_v_rhs(i, j, k) -= sponge_strength * xi * xi * (rho_v(i, j, k) - cell_data(i,j,k,0)*vbar_sponge[k]);
183  }
184  }
185  });
186 }
myhalf
constexpr amrex::Real myhalf
Definition: ERF_Constants.H:13
vbar_sponge
@ vbar_sponge
Definition: ERF_DataStruct.H:161
ubar_sponge
@ ubar_sponge
Definition: ERF_DataStruct.H:161
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);})
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:104
SpongeChoice::xlo_sponge_end
amrex::Real xlo_sponge_end
Physical end location of the low-x sponge layer.
Definition: ERF_SpongeStruct.H:102
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:103
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:103
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:102
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:104

Referenced by make_mom_sources().

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