ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
InputSoundingData Struct Reference

#include <ERF_InputSoundingData.H>

Collaboration diagram for InputSoundingData:

Public Member Functions

 InputSoundingData ()
 
void resize_arrays ()
 
void read_from_file (const amrex::Geometry &geom, const amrex::Vector< amrex::Real > &zlevels_stag, int itime)
 
void calc_rho_p (int itime)
 
void calc_rho_p_isentropic (int itime)
 
void host_to_device (int itime)
 
int size (int itime) const
 

Public Attributes

int ntimes
 
amrex::Real tau_nudging = 5.0
 
amrex::Vector< std::string > input_sounding_file = {}
 
amrex::Vector< amrex::Realinput_sounding_time = {}
 
int n_sounding_files = 0
 
int n_sounding_times = 0
 
bool assume_dry {false}
 
amrex::Real press_ref_inp_sound
 
amrex::Real theta_ref_inp_sound
 
amrex::Real qv_ref_inp_sound
 
amrex::Vector< amrex::Vector< amrex::Real > > z_inp_sound
 
amrex::Vector< amrex::Vector< amrex::Real > > theta_inp_sound
 
amrex::Vector< amrex::Vector< amrex::Real > > qv_inp_sound
 
amrex::Vector< amrex::Vector< amrex::Real > > U_inp_sound
 
amrex::Vector< amrex::Vector< amrex::Real > > V_inp_sound
 
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > z_inp_sound_d
 
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > theta_inp_sound_d
 
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > qv_inp_sound_d
 
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > U_inp_sound_d
 
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > V_inp_sound_d
 
amrex::Vector< amrex::Realpm_integ
 
amrex::Vector< amrex::Realrhod_integ
 
amrex::Gpu::DeviceVector< amrex::Realp_inp_sound_d
 
amrex::Gpu::DeviceVector< amrex::Realrho_inp_sound_d
 

Detailed Description

Data structure storing input sounding data. Also handles reading the input file for sounding data and hydrostatic column integration.

Constructor & Destructor Documentation

◆ InputSoundingData()

InputSoundingData::InputSoundingData ( )
inline
25  {
26  amrex::ParmParse pp("erf");
27  pp.query("tau_nudging", tau_nudging);
28 
29  // Read in input_sounding filename
30  n_sounding_files = pp.countval("input_sounding_file");
31  if (n_sounding_files > 0) {
33  pp.queryarr("input_sounding_file", input_sounding_file, 0, n_sounding_files);
34  } else {
35  n_sounding_files = 1;
37  input_sounding_file[0] = "input_sounding";
38  }
39 
40  // Read in input_sounding times
41  n_sounding_times = pp.countval("input_sounding_time");
42 
43  if (n_sounding_times > 0) {
45  pp.queryarr("input_sounding_time", input_sounding_time, 0, n_sounding_times);
46  } else {
47  n_sounding_times = 1;
49  input_sounding_time[0] = 0.0;
50  }
51 
52  // If we have more files than times or times than files we just use the minimum
53  int n = std::min(n_sounding_times, n_sounding_files);
54  n_sounding_files = n;
55  n_sounding_times = n;
56  input_sounding_file.resize(n);
57  input_sounding_time.resize(n);
58  }
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real pp(amrex::Real y)
Definition: ERF_MicrophysicsUtils.H:230
int n_sounding_times
Definition: ERF_InputSoundingData.H:399
amrex::Vector< amrex::Real > input_sounding_time
Definition: ERF_InputSoundingData.H:397
int n_sounding_files
Definition: ERF_InputSoundingData.H:398
amrex::Real tau_nudging
Definition: ERF_InputSoundingData.H:394
amrex::Vector< std::string > input_sounding_file
Definition: ERF_InputSoundingData.H:396
Here is the call graph for this function:

Member Function Documentation

◆ calc_rho_p()

void InputSoundingData::calc_rho_p ( int  itime)
inline
177  {
178  /* Calculate density and pressure, roughly following the procedure in
179  * WRF dyn_em/module_initialize_ideal.F. We integrate hydrostatically
180  * from the surface up through the air column to get the dry density
181  * and moist pressure.
182  */
183  const amrex::Real tol = 1.0e-12;
184  const int Ninp = size(itime);
185  pm_integ.resize(Ninp);
186  rhod_integ.resize(Ninp);
187 
188  // evaluate surface quantities (k=0): total pressure and dry air
192  R_d/Cp_d,
194 
195  amrex::Print() << "ideal sounding init: surface dry air density = "
196  << std::setprecision(15)
197  << rhod_integ[0] << " kg/m^3" << std::endl;
198 
199  // Note:
200  // p_dry = rho_d R_d T
201  // p_tot = rho_m R_d T_v
202  // = rho_d(1 + q_v) R_d T_v
203 
204 #if 0 // Printing
205  // In this absence of moisture, this moist profile will match the
206  // following dry profile
207  amrex::Print() << "z p_m rho_d theta qv U V" << std::endl;
208  amrex::Print() << z_inp_sound[itime][0]
209  << " " << pm_integ[0]
210  << " " << rhod_integ[0]
211  << " " << theta_inp_sound[itime][0]
212  << " " << qv_inp_sound[itime][0]
213  << " " << U_inp_sound[itime][0]
214  << " " << V_inp_sound[itime][0]
215  << std::endl;
216 #endif
217 
218  // integrate from surface to domain top
219  amrex::Real dz, F, C;
220  amrex::Real rho_tot_hi, rho_tot_lo;
221  for (int k=1; k < size(itime); ++k)
222  {
223  // Vertical grid spacing
224  dz = z_inp_sound[itime][k] - z_inp_sound[itime][k-1];
225 
226  // Establish known constant
227  rho_tot_lo = rhod_integ[k-1] * (1. + qv_inp_sound[itime][k-1]);
228  C = -pm_integ[k-1] + 0.5*rho_tot_lo*CONST_GRAV*dz;
229 
230  // Initial guess and residual
231  pm_integ[k] = pm_integ[k-1];
233  pm_integ[k],
234  R_d/Cp_d,
235  qv_inp_sound[itime][k]);
236  rho_tot_hi = rhod_integ[k] * (1. + qv_inp_sound[itime][k]);
237  F = pm_integ[k] + 0.5*rho_tot_hi*CONST_GRAV*dz + C;
238 
239  // Do iterations
240  if (std::abs(F)>tol) HSEutils::Newton_Raphson_hse(tol, R_d/Cp_d, dz,
241  CONST_GRAV, C, theta_inp_sound[itime][k],
242  qv_inp_sound[itime][k], qv_inp_sound[itime][k],
243  pm_integ[k], rhod_integ[k], F);
244 #if 0 // Printing
245  amrex::Print() << z_inp_sound[itime][k]
246  << " " << pm_integ[k]
247  << " " << rhod_integ[k]
248  << " " << theta_inp_sound[itime][k]
249  << " " << qv_inp_sound[itime][k]
250  << " " << U_inp_sound[itime][k]
251  << " " << V_inp_sound[itime][k]
252  << std::endl;
253 #endif
254  }
255  // Note: at this point, the surface pressure, density of the dry air
256  // column is stored in pm_integ[0], rhod_integ[0]
257 
258  // update
259  host_to_device(itime);
260  }
constexpr amrex::Real Cp_d
Definition: ERF_Constants.H:12
constexpr amrex::Real CONST_GRAV
Definition: ERF_Constants.H:21
constexpr amrex::Real R_d
Definition: ERF_Constants.H:10
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real getRhogivenThetaPress(const amrex::Real th, const amrex::Real p, const amrex::Real rdOcp, const amrex::Real qv=0.0)
Definition: ERF_EOS.H:96
amrex::Real Real
Definition: ERF_ShocInterface.H:16
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void Newton_Raphson_hse(const Real &m_tol, const Real &RdOCp, const Real &dz, const Real &g, const Real &C, const Real &T, const Real &qt, const Real &qv, Real &P, Real &rd, Real &F)
Definition: ERF_HSEUtils.H:35
amrex::Real press_ref_inp_sound
Definition: ERF_InputSoundingData.H:404
void host_to_device(int itime)
Definition: ERF_InputSoundingData.H:343
amrex::Real theta_ref_inp_sound
Definition: ERF_InputSoundingData.H:404
amrex::Vector< amrex::Real > pm_integ
Definition: ERF_InputSoundingData.H:413
amrex::Vector< amrex::Real > rhod_integ
Definition: ERF_InputSoundingData.H:415
amrex::Vector< amrex::Vector< amrex::Real > > theta_inp_sound
Definition: ERF_InputSoundingData.H:407
amrex::Real qv_ref_inp_sound
Definition: ERF_InputSoundingData.H:404
amrex::Vector< amrex::Vector< amrex::Real > > z_inp_sound
Definition: ERF_InputSoundingData.H:407
amrex::Vector< amrex::Vector< amrex::Real > > qv_inp_sound
Definition: ERF_InputSoundingData.H:407
amrex::Vector< amrex::Vector< amrex::Real > > U_inp_sound
Definition: ERF_InputSoundingData.H:407
amrex::Vector< amrex::Vector< amrex::Real > > V_inp_sound
Definition: ERF_InputSoundingData.H:407
int size(int itime) const
Definition: ERF_InputSoundingData.H:382
Here is the call graph for this function:

◆ calc_rho_p_isentropic()

void InputSoundingData::calc_rho_p_isentropic ( int  itime)
inline
263  {
264  /* Calculate density and pressure assuming isentropic (constant theta)
265  background conditions. This does not use Newton-Raphson iterations
266  to calculate rho and p.
267  */
268  const int Ninp = size(itime);
269  pm_integ.resize(Ninp);
270  rhod_integ.resize(Ninp);
271 
272  // evaluate surface quantities (k=0): total pressure and dry air
276  R_d/Cp_d,
278 
279  const amrex::Real th0 = theta_ref_inp_sound;
280  const amrex::Real p0_pow = std::pow(p_0, (Gamma-1)/Gamma);
281 
282  amrex::Print() << "isentropic sounding init: surface dry air density = "
283  << std::setprecision(15)
284  << rhod_integ[0] << " kg/m^3" << std::endl;
285 
286 #if 0 // Printing
287  // In this absence of moisture, this moist profile will match the
288  // following dry profile
289  amrex::Print() << "z p_m rho_d theta qv U V" << std::endl;
290  amrex::Print() << z_inp_sound[itime][0]
291  << " " << pm_integ[0]
292  << " " << rhod_integ[0]
293  << " " << theta_inp_sound[itime][0]
294  << " " << qv_inp_sound[itime][0]
295  << " " << U_inp_sound[itime][0]
296  << " " << V_inp_sound[itime][0]
297  << std::endl;
298 #endif
299 
300  // integrate from surface to domain top
301  amrex::Real dz;
302  for (int k=1; k < size(itime); ++k)
303  {
304  // Vertical grid spacing
305  dz = z_inp_sound[itime][k] - z_inp_sound[itime][k-1];
306 
307  // Isentropic pressure at next level
308  amrex::Real qvmean = (assume_dry) ? 0.0 : 0.5*(qv_inp_sound[itime][k-1] + qv_inp_sound[itime][k]);
309  amrex::Real thm0 = th0 * (1 + R_v/R_d * qvmean);
310  amrex::Real plo_pow = std::pow(pm_integ[k-1], (Gamma-1)/Gamma);
311  pm_integ[k] = (Gamma-1)/Gamma *
312  (-CONST_GRAV * p0_pow / (R_d * thm0) * (1 + qvmean) * dz
313  + Gamma/(Gamma-1) * plo_pow);
314  pm_integ[k] = std::pow(pm_integ[k], Gamma / (Gamma-1));
315 
316  // Note: The pressure calculated here is copied to `p_inp_sound_d`
317  // and currently not used.
318 
319  // Get corresponding dry air density
321  pm_integ[k],
322  R_d/Cp_d,
323  qv_inp_sound[itime][k]);
324 
325 #if 0 // Printing
326  amrex::Print() << z_inp_sound[itime][k]
327  << " " << pm_integ[k]
328  << " " << rhod_integ[k]
329  << " " << theta_inp_sound[itime][k]
330  << " " << qv_inp_sound[itime][k]
331  << " " << U_inp_sound[itime][k]
332  << " " << V_inp_sound[itime][k]
333  << std::endl;
334 #endif
335  }
336  // Note: at this point, the surface pressure, density of the dry air
337  // column is stored in pm_integ[0], rhod_integ[0]
338 
339  // update
340  host_to_device(itime);
341  }
constexpr amrex::Real R_v
Definition: ERF_Constants.H:11
constexpr amrex::Real p_0
Definition: ERF_Constants.H:18
constexpr amrex::Real Gamma
Definition: ERF_Constants.H:19
bool assume_dry
Definition: ERF_InputSoundingData.H:401
Here is the call graph for this function:

◆ host_to_device()

void InputSoundingData::host_to_device ( int  itime)
inline
344  {
345  const int Ninp = size(itime);
346  z_inp_sound_d[itime].resize(Ninp);
347  theta_inp_sound_d[itime].resize(Ninp);
348  qv_inp_sound_d[itime].resize(Ninp);
349  U_inp_sound_d[itime].resize(Ninp);
350  V_inp_sound_d[itime].resize(Ninp);
351 
352  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
353  z_inp_sound[itime].begin(), z_inp_sound[itime].end(),
354  z_inp_sound_d[itime].begin());
355  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
356  theta_inp_sound[itime].begin(), theta_inp_sound[itime].end(),
357  theta_inp_sound_d[itime].begin());
358  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
359  qv_inp_sound[itime].begin(), qv_inp_sound[itime].end(),
360  qv_inp_sound_d[itime].begin());
361  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
362  U_inp_sound[itime].begin(), U_inp_sound[itime].end(),
363  U_inp_sound_d[itime].begin());
364  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
365  V_inp_sound[itime].begin(), V_inp_sound[itime].end(),
366  V_inp_sound_d[itime].begin());
367 
368  if (rhod_integ.size() > 0)
369  {
370  //amrex::Print() << "Copying rho_d, p_d to device" << std::endl;
371  rho_inp_sound_d.resize(size(itime)+2);
372  p_inp_sound_d.resize(size(itime)+2);
373  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
374  rhod_integ.begin(), rhod_integ.end(),
375  rho_inp_sound_d.begin());
376  amrex::Gpu::copy(amrex::Gpu::hostToDevice,
377  pm_integ.begin(), pm_integ.end(),
378  p_inp_sound_d.begin());
379  }
380  }
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > theta_inp_sound_d
Definition: ERF_InputSoundingData.H:410
amrex::Gpu::DeviceVector< amrex::Real > p_inp_sound_d
Definition: ERF_InputSoundingData.H:417
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > V_inp_sound_d
Definition: ERF_InputSoundingData.H:410
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > qv_inp_sound_d
Definition: ERF_InputSoundingData.H:410
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > z_inp_sound_d
Definition: ERF_InputSoundingData.H:410
amrex::Gpu::DeviceVector< amrex::Real > rho_inp_sound_d
Definition: ERF_InputSoundingData.H:417
amrex::Vector< amrex::Gpu::DeviceVector< amrex::Real > > U_inp_sound_d
Definition: ERF_InputSoundingData.H:410

Referenced by calc_rho_p(), calc_rho_p_isentropic(), and read_from_file().

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

◆ read_from_file()

void InputSoundingData::read_from_file ( const amrex::Geometry &  geom,
const amrex::Vector< amrex::Real > &  zlevels_stag,
int  itime 
)
inline
80  {
81  const int klo = 0;
82  const int khi = geom.Domain().bigEnd()[AMREX_SPACEDIM-1];
83  const int Nz = geom.Domain().size()[AMREX_SPACEDIM-1];
84  const amrex::Real dz = geom.CellSize()[AMREX_SPACEDIM-1];
85 
86  const bool use_terrain = (zlevels_stag.size() > 0);
87  const amrex::Real zbot = (use_terrain) ? zlevels_stag[klo] : geom.ProbLo(AMREX_SPACEDIM-1);
88  const amrex::Real ztop = (use_terrain) ? zlevels_stag[khi+1] : geom.ProbHi(AMREX_SPACEDIM-1);
89 
90  z_inp_sound[itime].resize(Nz+2);
91  theta_inp_sound[itime].resize(Nz+2);
92  qv_inp_sound[itime].resize(Nz+2);
93  U_inp_sound[itime].resize(Nz+2);
94  V_inp_sound[itime].resize(Nz+2);
95 
96  // Read the input_sounding file
97  amrex::Print() << "input_sounding file location : " << input_sounding_file[itime] << std::endl;
98  std::ifstream input_sounding_reader(input_sounding_file[itime]);
99  if(!input_sounding_reader.is_open()) {
100  amrex::Error("Error opening the input_sounding file\n");
101  }
102  else {
103  // Read the contents of the input_sounding file
104  amrex::Print() << "Successfully opened the input_sounding file. Now reading... " << std::endl;
105  std::string line;
106 
107  // First, read the input data into temp vectors; then, interpolate vectors to the
108  // domain lo/hi and cell centers (from level 0)
109  amrex::Vector<amrex::Real> z_inp_sound_tmp, theta_inp_sound_tmp, qv_inp_sound_tmp,
110  U_inp_sound_tmp, V_inp_sound_tmp;
111 
112  // Read surface quantities from the first line
113  std::getline(input_sounding_reader, line);
114  std::istringstream iss(line);
116  press_ref_inp_sound *= 100; // convert from hPa to Pa
117  qv_ref_inp_sound *= 0.001; // convert from g/kg to kg/kg
118 
119  // Add surface
120  z_inp_sound_tmp.push_back(zbot); // height above sea level [m]
121  theta_inp_sound_tmp.push_back(theta_ref_inp_sound);
122  qv_inp_sound_tmp.push_back(qv_ref_inp_sound);
123  U_inp_sound_tmp.push_back(0);
124  V_inp_sound_tmp.push_back(0);
125 
126  // Read the vertical profile at each given height
127  amrex::Real z, theta, qv, U, V;
128  while(std::getline(input_sounding_reader, line)) {
129  std::istringstream iss_z(line);
130  iss_z >> z >> theta >> qv >> U >> V;
131  if (z == zbot) {
132  AMREX_ALWAYS_ASSERT(theta == theta_inp_sound_tmp[0]);
133  AMREX_ALWAYS_ASSERT(qv*0.001 == qv_inp_sound_tmp[0]); // convert from g/kg to kg/kg
134  U_inp_sound_tmp[0] = U;
135  V_inp_sound_tmp[0] = V;
136  } else {
137  AMREX_ALWAYS_ASSERT(z > z_inp_sound_tmp[z_inp_sound_tmp.size()-1]); // sounding is increasing in height
138  z_inp_sound_tmp.push_back(z);
139  theta_inp_sound_tmp.push_back(theta);
140  qv_inp_sound_tmp.push_back(qv*0.001); // convert from g/kg to kg/kg
141  U_inp_sound_tmp.push_back(U);
142  V_inp_sound_tmp.push_back(V);
143  if (z >= ztop) break;
144  }
145  }
146 
147  // At this point, we have an input_sounding from zbot up to
148  // z_inp_sound_tmp[N-1] >= ztop. Now, interpolate to grid level 0 heights
149  const int Ninp = z_inp_sound_tmp.size();
150  z_inp_sound[itime][0] = zbot;
151  theta_inp_sound[itime][0] = theta_inp_sound_tmp[0];
152  qv_inp_sound[itime][0] = qv_inp_sound_tmp[0];
153  U_inp_sound[itime][0] = U_inp_sound_tmp[0];
154  V_inp_sound[itime][0] = V_inp_sound_tmp[0];
155  for (int k=0; k < Nz; ++k) {
156  z_inp_sound[itime][k+1] = (use_terrain) ? 0.5 * (zlevels_stag[k] + zlevels_stag[k+1])
157  : zbot + (k + 0.5) * dz;
158  theta_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), theta_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
159  qv_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), qv_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
160  U_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), U_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
161  V_inp_sound[itime][k+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), V_inp_sound_tmp.dataPtr(), z_inp_sound[itime][k+1], Ninp);
162  }
163  z_inp_sound[itime][Nz+1] = ztop;
164  theta_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), theta_inp_sound_tmp.dataPtr(), ztop, Ninp);
165  qv_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), qv_inp_sound_tmp.dataPtr(), ztop, Ninp);
166  U_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), U_inp_sound_tmp.dataPtr(), ztop, Ninp);
167  V_inp_sound[itime][Nz+1] = interpolate_1d(z_inp_sound_tmp.dataPtr(), V_inp_sound_tmp.dataPtr(), ztop, Ninp);
168  }
169 
170  amrex::Print() << "Successfully read the " << itime << "th input_sounding file..." << std::endl;
171  input_sounding_reader.close();
172 
173  host_to_device(itime);
174  }
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real interpolate_1d(const amrex::Real *alpha, const amrex::Real *beta, const amrex::Real alpha_interp, const int alpha_size)
Definition: ERF_Interpolation_1D.H:12
@ theta
Definition: ERF_MM5.H:20
@ qv
Definition: ERF_Kessler.H:28
@ U
Definition: ERF_IndexDefines.H:108
@ V
Definition: ERF_IndexDefines.H:109
Here is the call graph for this function:

◆ resize_arrays()

void InputSoundingData::resize_arrays ( )
inline
61  {
63 
64  z_inp_sound.resize(ntimes);
65  theta_inp_sound.resize(ntimes);
66  qv_inp_sound.resize(ntimes);
67  U_inp_sound.resize(ntimes);
68  V_inp_sound.resize(ntimes);
69 
70  z_inp_sound_d.resize(ntimes);
71  theta_inp_sound_d.resize(ntimes);
72  qv_inp_sound_d.resize(ntimes);
73  U_inp_sound_d.resize(ntimes);
74  V_inp_sound_d.resize(ntimes);
75  }
int ntimes
Definition: ERF_InputSoundingData.H:392

◆ size()

int InputSoundingData::size ( int  itime) const
inline
383  {
384  AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == theta_inp_sound[itime].size());
385  AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == qv_inp_sound[itime].size());
386  AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == U_inp_sound[itime].size());
387  AMREX_ALWAYS_ASSERT(z_inp_sound[itime].size() == V_inp_sound[itime].size());
388  return z_inp_sound[itime].size();
389  }

Referenced by calc_rho_p(), calc_rho_p_isentropic(), host_to_device(), init_bx_scalars_from_input_sounding(), init_bx_scalars_from_input_sounding_hse(), and init_bx_velocities_from_input_sounding().

Here is the caller graph for this function:

Member Data Documentation

◆ assume_dry

bool InputSoundingData::assume_dry {false}

◆ input_sounding_file

amrex::Vector<std::string> InputSoundingData::input_sounding_file = {}

◆ input_sounding_time

amrex::Vector<amrex::Real> InputSoundingData::input_sounding_time = {}

◆ n_sounding_files

int InputSoundingData::n_sounding_files = 0

Referenced by InputSoundingData(), and resize_arrays().

◆ n_sounding_times

int InputSoundingData::n_sounding_times = 0

Referenced by InputSoundingData().

◆ ntimes

int InputSoundingData::ntimes

Referenced by resize_arrays().

◆ p_inp_sound_d

amrex::Gpu::DeviceVector<amrex::Real> InputSoundingData::p_inp_sound_d

Referenced by host_to_device().

◆ pm_integ

amrex::Vector<amrex::Real> InputSoundingData::pm_integ

◆ press_ref_inp_sound

amrex::Real InputSoundingData::press_ref_inp_sound

◆ qv_inp_sound

amrex::Vector<amrex::Vector<amrex::Real> > InputSoundingData::qv_inp_sound

◆ qv_inp_sound_d

amrex::Vector<amrex::Gpu::DeviceVector<amrex::Real> > InputSoundingData::qv_inp_sound_d

◆ qv_ref_inp_sound

amrex::Real InputSoundingData::qv_ref_inp_sound

◆ rho_inp_sound_d

amrex::Gpu::DeviceVector<amrex::Real> InputSoundingData::rho_inp_sound_d

◆ rhod_integ

amrex::Vector<amrex::Real> InputSoundingData::rhod_integ

◆ tau_nudging

amrex::Real InputSoundingData::tau_nudging = 5.0

◆ theta_inp_sound

amrex::Vector<amrex::Vector<amrex::Real> > InputSoundingData::theta_inp_sound

◆ theta_inp_sound_d

amrex::Vector<amrex::Gpu::DeviceVector<amrex::Real> > InputSoundingData::theta_inp_sound_d

◆ theta_ref_inp_sound

amrex::Real InputSoundingData::theta_ref_inp_sound

◆ U_inp_sound

amrex::Vector<amrex::Vector<amrex::Real> > InputSoundingData::U_inp_sound

◆ U_inp_sound_d

amrex::Vector<amrex::Gpu::DeviceVector<amrex::Real> > InputSoundingData::U_inp_sound_d

◆ V_inp_sound

amrex::Vector<amrex::Vector<amrex::Real> > InputSoundingData::V_inp_sound

◆ V_inp_sound_d

amrex::Vector<amrex::Gpu::DeviceVector<amrex::Real> > InputSoundingData::V_inp_sound_d

◆ z_inp_sound

amrex::Vector<amrex::Vector<amrex::Real> > InputSoundingData::z_inp_sound

◆ z_inp_sound_d


The documentation for this struct was generated from the following file: