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

#include <ERF_DataStruct.H>

Collaboration diagram for SolverChoice:

Public Member Functions

void init_params (int max_level, std::string pp_prefix)
 
void check_params (int max_level)
 
void display (int max_level, std::string pp_prefix)
 
void build_coriolis_forcings_const_lat (std::string pp_prefix)
 
void read_int_string (int max_level, const char *string_to_read, amrex::Vector< int > &vec_to_fill, int default_int)
 

Static Public Member Functions

static void set_mesh_type (MeshType new_mesh_type)
 

Public Attributes

AdvChoice advChoice
 
DiffChoice diffChoice
 
SpongeChoice spongeChoice
 
amrex::Vector< TurbChoiceturbChoice
 
int force_stage1_single_substep = 1
 
amrex::Vector< SubsteppingType > substepping_type
 
amrex::Vector< int > anelastic
 
bool fixed_density = false
 
int ncorr = 1
 
amrex::Real poisson_abstol = 1e-8
 
amrex::Real poisson_reltol = 1e-8
 
bool test_mapfactor = false
 
int buoyancy_type = 1
 
bool use_gravity = false
 
bool use_coriolis = false
 
bool coriolis_3d = true
 
bool rayleigh_damp_U = false
 
bool rayleigh_damp_V = false
 
bool rayleigh_damp_W = false
 
bool rayleigh_damp_T = false
 
amrex::Real rayleigh_dampcoef = 0.2
 
amrex::Real rayleigh_zdamp = 500.0
 
amrex::Real rayleigh_ztop
 
bool rayleigh_damp_substep = false
 
bool immersed_forcing_substep = false
 
bool forest_substep = false
 
bool use_lagged_delta_rt = true
 
amrex::Real gravity
 
amrex::Real c_p = Cp_d
 
amrex::Real rdOcp
 
amrex::Real grid_stretching_ratio = 0
 
amrex::Real zsurf = 0.0
 
amrex::Real dz0
 
bool project_initial_velocity = false
 
amrex::Real coriolis_factor = 0.0
 
amrex::Real cosphi = 0.0
 
amrex::Real sinphi = 0.0
 
bool custom_rhotheta_forcing = false
 
bool custom_moisture_forcing = false
 
bool custom_w_subsidence = false
 
bool custom_geostrophic_profile = false
 
bool custom_forcing_prim_vars = false
 
bool nudging_from_input_sounding = false
 
bool use_rotate_surface_flux = false
 
bool use_shoc = false
 
bool time_avg_vel = false
 
PerturbationType pert_type
 
bool use_num_diff {false}
 
amrex::Real num_diff_coeff {0.}
 
bool rebalance_wrfinput {false}
 
CouplingType coupling_type
 
MoistureType moisture_type
 
WindFarmType windfarm_type
 
WindFarmLocType windfarm_loc_type
 
LandSurfaceType lsm_type
 
RadiationType rad_type
 
ABLDriverType abl_driver_type
 
amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > abl_pressure_grad
 
amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > abl_geo_forcing
 
std::string abl_geo_wind_table
 
bool have_geo_wind_profile {false}
 
bool has_lat_lon {false}
 
bool variable_coriolis {false}
 
int ave_plane {2}
 
bool use_moist_background {false}
 
MoistureComponentIndices moisture_indices
 
bool moisture_tight_coupling {false}
 
std::string windfarm_loc_table
 
std::string windfarm_spec_table
 
std::string windfarm_spec_table_extra
 
std::string windfarm_blade_table
 
std::string windfarm_airfoil_tables
 
amrex::Real sampling_distance_by_D = -1.0
 
amrex::Real turb_disk_angle = -1.0
 
amrex::Real windfarm_x_shift = -1.0
 
amrex::Real windfarm_y_shift = -1.0
 
bool do_forest_drag {false}
 
amrex::Real const_massflux_u = 0.0
 
amrex::Real const_massflux_v = 0.0
 
amrex::Real const_massflux_tau = 1.0
 
amrex::Real const_massflux_layer_lo = -1e34
 
amrex::Real const_massflux_layer_hi = 1e34
 
int massflux_klo {0}
 
int massflux_khi {0}
 
std::string hindcast_boundary_data_dir
 
bool hindcast_lateral_forcing = false
 
amrex::Real hindcast_lateral_sponge_strength = -1.0
 
amrex::Real hindcast_lateral_sponge_length = -1.0
 
amrex::Real hindcast_zhi_sponge_strength = -1.0
 
amrex::Real hindcast_zhi_sponge_length = -1.0
 
bool hindcast_zhi_sponge_damping = false
 

Static Public Attributes

static InitType init_type = InitType::None
 
static SoundingType sounding_type = SoundingType::Ideal
 
static TerrainType terrain_type = TerrainType::None
 
static bool use_real_bcs = false
 
static bool upwind_real_bcs = false
 
static MeshType mesh_type = MeshType::ConstantDz
 

Detailed Description

Container holding many of the algorithmic options and parameters

Member Function Documentation

◆ build_coriolis_forcings_const_lat()

void SolverChoice::build_coriolis_forcings_const_lat ( std::string  pp_prefix)
inline
741  {
742  amrex::ParmParse pp(pp_prefix);
743 
744  // Read the rotational time period (in seconds)
745  amrex::Real rot_time_period = 86400.0;
746  pp.query("rotational_time_period", rot_time_period);
747 
748  coriolis_factor = 2.0 * 2.0 * PI / rot_time_period;
749 
750  amrex::Real latitude = 90.0;
751  pp.query("latitude", latitude);
752 
753  pp.query("coriolis_3d", coriolis_3d);
754 
755  // Convert to radians
756  latitude *= (PI/180.);
757  sinphi = std::sin(latitude);
758  if (coriolis_3d) {
759  cosphi = std::cos(latitude);
760  }
761 
762  amrex::Print() << "Coriolis frequency, f = " << coriolis_factor * sinphi << " 1/s" << std::endl;
763 
764  if (abl_driver_type == ABLDriverType::GeostrophicWind) {
765  // Read in the geostrophic wind -- we only use this to construct
766  // the forcing term so no need to keep it
767  amrex::Vector<amrex::Real> abl_geo_wind(3);
768  pp.queryarr("abl_geo_wind",abl_geo_wind);
769 
770  if(!pp.query("abl_geo_wind_table",abl_geo_wind_table)) {
771  abl_geo_forcing = {
772  -coriolis_factor * (abl_geo_wind[1]*sinphi - abl_geo_wind[2]*cosphi),
773  coriolis_factor * abl_geo_wind[0]*sinphi,
774  -coriolis_factor * abl_geo_wind[0]*cosphi
775  };
776  } else {
777  amrex::Print() << "NOTE: abl_geo_wind_table provided, ignoring input abl_geo_wind" << std::endl;
778  }
779  }
780  }
constexpr amrex::Real PI
Definition: ERF_Constants.H:6
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real pp(amrex::Real y)
Definition: ERF_MicrophysicsUtils.H:230
amrex::Real Real
Definition: ERF_ShocInterface.H:19
amrex::Real coriolis_factor
Definition: ERF_DataStruct.H:876
amrex::Real cosphi
Definition: ERF_DataStruct.H:877
amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > abl_geo_forcing
Definition: ERF_DataStruct.H:919
amrex::Real sinphi
Definition: ERF_DataStruct.H:878
bool coriolis_3d
Definition: ERF_DataStruct.H:845
std::string abl_geo_wind_table
Definition: ERF_DataStruct.H:920
ABLDriverType abl_driver_type
Definition: ERF_DataStruct.H:917

Referenced by init_params().

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

◆ check_params()

void SolverChoice::check_params ( int  max_level)
inline
597  {
598  // Warn for PBL models and moisture - these may not yet be compatible
599  for (int lev = 0; lev <= max_level; lev++) {
600  if ((moisture_type != MoistureType::None) && (turbChoice[lev].pbl_type != PBLType::None)) {
601  amrex::Warning("\n*** WARNING: Moisture may not yet be compatible with PBL models, \n proceed with caution ***");
602  }
603  }
604  //
605  // Buoyancy type check
606  //
607  if (buoyancy_type != 1 && buoyancy_type != 2 && buoyancy_type != 3 && buoyancy_type != 4) {
608  amrex::Abort("buoyancy_type must be 1, 2, 3 or 4");
609  }
610 
611  if (!use_lagged_delta_rt && !(terrain_type == TerrainType::MovingFittedMesh)) {
612  amrex::Error("Can't turn off lagged_delta_rt when terrain not moving");
613  }
614 
615  //
616  // Wind farm checks
617  //
618  if (windfarm_type==WindFarmType::SimpleAD and sampling_distance_by_D < 0.0) {
619  amrex::Abort("To use simplified actuator disks, you need to provide a variable"
620  " erf.sampling_distance_by_D in the inputs which specifies the upstream"
621  " distance as a factor of the turbine diameter at which the incoming free stream"
622  " velocity will be computed at.");
623  }
624  if ( (windfarm_type==WindFarmType::SimpleAD ||
625  windfarm_type==WindFarmType::GeneralAD ) && turb_disk_angle < 0.0) {
626  amrex::Abort("To use simplified actuator disks, you need to provide a variable"
627  " erf.turb_disk_angle_from_x in the inputs which is the angle of the face of the"
628  " turbine disk from the x-axis. A turbine facing an oncoming flow in the x-direction"
629  " will have turb_disk_angle value of 90 deg.");
630  }
631  if (windfarm_loc_type == WindFarmLocType::lat_lon and (windfarm_x_shift < 0.0 or windfarm_y_shift < 0.0)) {
632  amrex::Abort("You are using windfarms with latitude-logitude option to position the turbines."
633  " For this you should provide the inputs erf.windfarm_x_shift and"
634  " erf.windfarm_y_shift which are the values by which the bounding box of the"
635  " windfarm is shifted from the x and the y axes.");
636  }
637  }
bool use_lagged_delta_rt
Definition: ERF_DataStruct.H:861
amrex::Real windfarm_x_shift
Definition: ERF_DataStruct.H:938
WindFarmLocType windfarm_loc_type
Definition: ERF_DataStruct.H:913
amrex::Real sampling_distance_by_D
Definition: ERF_DataStruct.H:936
amrex::Vector< TurbChoice > turbChoice
Definition: ERF_DataStruct.H:826
MoistureType moisture_type
Definition: ERF_DataStruct.H:911
static TerrainType terrain_type
Definition: ERF_DataStruct.H:806
WindFarmType windfarm_type
Definition: ERF_DataStruct.H:912
int buoyancy_type
Definition: ERF_DataStruct.H:840
amrex::Real turb_disk_angle
Definition: ERF_DataStruct.H:937
amrex::Real windfarm_y_shift
Definition: ERF_DataStruct.H:939

Referenced by init_params().

Here is the caller graph for this function:

◆ display()

void SolverChoice::display ( int  max_level,
std::string  pp_prefix 
)
inline
640  {
641  amrex::Print() << "SOLVER CHOICE: " << std::endl;
642  amrex::Print() << "force_stage1_single_substep : " << force_stage1_single_substep << std::endl;
643  for (int lev = 0; lev <= max_level; lev++) {
644  if (anelastic[lev]) {
645  amrex::Print() << "Level " << lev << " is anelastic" << std::endl;
646  }
647  if (substepping_type[lev] == SubsteppingType::None) {
648  amrex::Print() << "No substepping at level " << lev << std::endl;
649  } else if (substepping_type[lev] == SubsteppingType::Explicit) {
650  amrex::Print() << "Explicit substepping at level " << lev << std::endl;
651  } else if (substepping_type[lev] == SubsteppingType::Implicit) {
652  amrex::Print() << "Implicit substepping at level " << lev << std::endl;
653  }
654  }
655  amrex::Print() << "fixed_density : " << fixed_density << std::endl;
656  amrex::Print() << "use_coriolis : " << use_coriolis << std::endl;
657  amrex::Print() << "use_gravity : " << use_gravity << std::endl;
658 
659  if (moisture_type == MoistureType::SAM) {
660  amrex::Print() << "Moisture Model: SAM" << std::endl;
661  } else if (moisture_type == MoistureType::SAM_NoIce) {
662  amrex::Print() << "Moisture Model: SAM No Ice" << std::endl;
663  } else if (moisture_type == MoistureType::SAM_NoPrecip_NoIce) {
664  amrex::Print() << "Moisture Model: SAM No Precip No Ice" << std::endl;
665  } else if (moisture_type == MoistureType::Morrison) {
666  amrex::Print() << "Moisture Model: Morrison" << std::endl;
667  } else if (moisture_type == MoistureType::Morrison_NoIce) {
668  amrex::Print() << "Moisture Model: Morrison_NoIce" << std::endl;
669  } else if (moisture_type == MoistureType::Kessler) {
670  amrex::Print() << "Moisture Model: Kessler" << std::endl;
671  } else if (moisture_type == MoistureType::Kessler_NoRain) {
672  amrex::Print() << "Moisture Model: Kessler No Rain" << std::endl;
673  } else if (moisture_type == MoistureType::SatAdj) {
674  amrex::Print() << "Moisture Model: Saturation Adjustment" << std::endl;
675  } else {
676  amrex::Print() << "Moisture Model: None" << std::endl;
677  }
678 
679  if (terrain_type == TerrainType::StaticFittedMesh) {
680  amrex::Print() << "Terrain Type: StaticFittedMesh" << std::endl;
681  } else if (terrain_type == TerrainType::MovingFittedMesh) {
682  amrex::Print() << "Terrain Type: MovingFittedMesh" << std::endl;
683  } else if (terrain_type == TerrainType::EB) {
684  amrex::Print() << "Terrain Type: EB" << std::endl;
685  } else if (terrain_type == TerrainType::ImmersedForcing) {
686  amrex::Print() << "Terrain Type: ImmersedForcing" << std::endl;
687  } else {
688  amrex::Print() << "Terrain Type: None" << std::endl;
689  }
690 
691  if (mesh_type == MeshType::ConstantDz) {
692  amrex::Print() << " Mesh Type: ConstantDz" << std::endl;
693  } else if (mesh_type == MeshType::StretchedDz) {
694  amrex::Print() << " Mesh Type: StretchedDz" << std::endl;
695  } else if (mesh_type == MeshType::VariableDz) {
696  amrex::Print() << " Mesh Type: VariableDz" << std::endl;
697  } else {
698  amrex::Abort("No mesh_type set!");
699  }
700 
701  amrex::Print() << "ABL Driver Type: " << std::endl;
702  if (abl_driver_type == ABLDriverType::None) {
703  amrex::Print() << " None" << std::endl;
704  } else if (abl_driver_type == ABLDriverType::PressureGradient) {
705  amrex::Print() << " Pressure Gradient "
706  << amrex::RealVect(abl_pressure_grad[0],abl_pressure_grad[1],abl_pressure_grad[2])
707  << std::endl;
708  } else if (abl_driver_type == ABLDriverType::GeostrophicWind) {
709  amrex::Print() << " Geostrophic Wind "
710  << amrex::RealVect(abl_geo_forcing[0],abl_geo_forcing[1],abl_geo_forcing[2])
711  << std::endl;
712  }
713 
714  if (max_level > 0) {
715  amrex::Print() << "Coupling Type: " << std::endl;
716  if (coupling_type == CouplingType::TwoWay) {
717  amrex::Print() << " Two-way" << std::endl;
718  } else if (coupling_type == CouplingType::OneWay) {
719  amrex::Print() << " One-way" << std::endl;
720  }
721  }
722 
723  if (rad_type == RadiationType::RRTMGP) {
724  amrex::Print() << "Radiation Model: RRTMGP" << std::endl;
725  } else {
726  amrex::Print() << "Radiation Model: None" << std::endl;
727  }
728 
729  amrex::Print() << "Buoyancy_type : " << buoyancy_type << std::endl;
730 
731  advChoice.display(pp_prefix);
734 
735  for (int lev = 0; lev <= max_level; lev++) {
736  turbChoice[lev].display(lev);
737  }
738  }
void display(std::string &pp_prefix)
Definition: ERF_AdvStruct.H:211
void display()
Definition: ERF_DiffStruct.H:67
static MeshType mesh_type
Definition: ERF_DataStruct.H:815
RadiationType rad_type
Definition: ERF_DataStruct.H:915
DiffChoice diffChoice
Definition: ERF_DataStruct.H:824
bool use_gravity
Definition: ERF_DataStruct.H:843
int force_stage1_single_substep
Definition: ERF_DataStruct.H:828
amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > abl_pressure_grad
Definition: ERF_DataStruct.H:918
amrex::Vector< SubsteppingType > substepping_type
Definition: ERF_DataStruct.H:830
bool use_coriolis
Definition: ERF_DataStruct.H:844
bool fixed_density
Definition: ERF_DataStruct.H:833
amrex::Vector< int > anelastic
Definition: ERF_DataStruct.H:831
AdvChoice advChoice
Definition: ERF_DataStruct.H:823
SpongeChoice spongeChoice
Definition: ERF_DataStruct.H:825
CouplingType coupling_type
Definition: ERF_DataStruct.H:910
void display()
Definition: ERF_SpongeStruct.H:45
Here is the call graph for this function:

◆ init_params()

void SolverChoice::init_params ( int  max_level,
std::string  pp_prefix 
)
inline
126  {
127  amrex::ParmParse pp(pp_prefix);
128 
129  bool bogus;
130  if (pp.query("use_terrain",bogus) > 0) {
131  amrex::Abort("The input use_terrain is deprecated. Set terrain_type instead.");
132  }
133 
134  pp.query("grid_stretching_ratio", grid_stretching_ratio);
135  if (grid_stretching_ratio != 0) {
136  AMREX_ASSERT_WITH_MESSAGE((grid_stretching_ratio >= 1.),
137  "The grid stretching ratio must be greater than 1");
138  }
139  if (grid_stretching_ratio >= 1) {
140  if (mesh_type == MeshType::ConstantDz) {
141  mesh_type = MeshType::StretchedDz;
142  }
143  if (terrain_type != TerrainType::StaticFittedMesh) {
144  amrex::Print() << "Turning terrain on to enable grid stretching" << std::endl;
145  terrain_type = TerrainType::StaticFittedMesh;
146  }
147  pp.query("zsurface", zsurf);
148  if (zsurf != 0.0) {
149  amrex::Print() << "Nominal zsurface height != 0, may result in unexpected behavior"
150  << std::endl;
151  }
152  pp.get("initial_dz", dz0);
153  }
154 
155  // Do we set map scale factors to 0.5 instead of 1 for testing?
156  pp.query("test_mapfactor", test_mapfactor);
157 
158  // What type of moisture model to use?
159  moisture_type = MoistureType::None; // Default
160  if (pp.query("moisture_type",moisture_type) > 0) {
161  amrex::Abort("The input moisture_type is deprecated. Set moisture_model instead.");
162  }
163  pp.query_enum_case_insensitive("moisture_model",moisture_type);
164  if ( (moisture_type == MoistureType::Morrison) ||
165  (moisture_type == MoistureType::SAM) ) {
167  RhoQ1_comp, // water vapor
168  RhoQ2_comp, // cloud water
169  RhoQ3_comp, // cloud ice
170  RhoQ4_comp, // rain
171  RhoQ5_comp, // snow
172  RhoQ6_comp // graupel
173  );
174  } else if ( (moisture_type == MoistureType::Morrison_NoIce) ||
175  (moisture_type == MoistureType::SAM_NoIce) ) {
177  RhoQ1_comp, // water vapor
178  RhoQ2_comp, // cloud water
179  -1, // cloud ice
180  RhoQ4_comp // rain
181  );
182  } else if ( (moisture_type == MoistureType::SAM_NoPrecip_NoIce) ||
183  (moisture_type == MoistureType::Kessler_NoRain) ||
184  (moisture_type == MoistureType::SatAdj) ) {
186  RhoQ1_comp, // water vapor
187  RhoQ2_comp // cloud water
188  );
189  } else if (moisture_type == MoistureType::Kessler) {
191  RhoQ1_comp, // water vapor
192  RhoQ2_comp, // cloud water
193  -1, // cloud ice
194  RhoQ3_comp // rain
195  );
196  }
197 
198  // TODO: should we set default for dry??
199  // Set a different default for moist vs dry
200  if (moisture_type != MoistureType::None) {
201  if (moisture_type == MoistureType::Kessler_NoRain ||
202  moisture_type == MoistureType::SAM ||
203  moisture_type == MoistureType::SAM_NoIce ||
204  moisture_type == MoistureType::SAM_NoPrecip_NoIce ||
205  moisture_type == MoistureType::Morrison ||
206  moisture_type == MoistureType::Morrison_NoIce ||
207  moisture_type == MoistureType::SatAdj)
208  {
209  buoyancy_type = 1; // uses Rhoprime
210  } else {
211  buoyancy_type = 2; // uses Tprime
212  }
213 
214  pp.query("moisture_tight_coupling",moisture_tight_coupling);
215  }
216 
217  // Which expression (1,2/3 or 4) to use for buoyancy
218  pp.query("buoyancy_type", buoyancy_type);
219 
220  // What type of land surface model to use
221  lsm_type = LandSurfaceType::None; // Default
222  pp.query_enum_case_insensitive("land_surface_model",lsm_type);
223 
224  // What type of radiation model to use
225  rad_type = RadiationType::None; // Default
226  pp.query_enum_case_insensitive("radiation_model", rad_type);
227 
228  // Verify that radiation model cannot be RRTMGP if ERF was not compiled with RRTMGP
229 #ifndef ERF_USE_RRTMGP
230  if (rad_type == RadiationType::RRTMGP)
231  {
232  amrex::Abort("ERF was not compiled with RRTMGP enabled!");
233  }
234 #endif
235 
236  // Is the terrain none, static or moving?
237  std::string terrain_type_temp = "";
238  pp.query("terrain_type", terrain_type_temp);
239  if (terrain_type_temp == "Moving") {
240  amrex::Warning("erf.terrain_type = Moving is deprecated; please replace Moving by MovingFittedMesh");
241  terrain_type = TerrainType::MovingFittedMesh;
242  } else if (terrain_type_temp == "Static") {
243  amrex::Warning("erf.terrain_type = Static is deprecated; please replace Static by StaticFittedMesh");
244  terrain_type = TerrainType::StaticFittedMesh;
245  } else {
246  pp.query_enum_case_insensitive("terrain_type",terrain_type);
247  }
248 
249  //
250  // Read the init_type here to make sure we correctly set the mesh and terrain types
251  //
252  std::string init_type_temp_string;
253  pp.query("init_type",init_type_temp_string);
254  if ( (init_type_temp_string == "Real") || (init_type_temp_string == "real") ) {
255  amrex::Warning("erf.init_type = Real is deprecated; please replace Real by WRFInput");
256  init_type = InitType::WRFInput;
257  use_real_bcs = true;
258  pp.query("upwind_real_bcs",upwind_real_bcs);
259  } else if ( (init_type_temp_string == "Ideal") || (init_type_temp_string == "ideal") ) {
260  amrex::Warning("erf.init_type = Ideal is deprecated; please replace Ideal by WRFInput");
261  init_type = InitType::WRFInput;
262  use_real_bcs = false;
263  } else if (init_type_temp_string == "hindcast") {
264  init_type = InitType::HindCast;
265  use_real_bcs = false;
266  }
267  else {
268  pp.query_enum_case_insensitive("init_type",init_type);
269  use_real_bcs = ( (init_type == InitType::WRFInput) || (init_type == InitType::Metgrid) );
270  if (use_real_bcs) {
271  pp.query("upwind_real_bcs",upwind_real_bcs);
272  }
273  }
274 
275  if ( (init_type == InitType::WRFInput) || (init_type == InitType::Metgrid) ) {
276  if (terrain_type != TerrainType::StaticFittedMesh) {
277  amrex::Abort("Only terrain_type = StaticFittedMesh are allowed with init_type = WRFInput or Metgrid");
278  }
279  }
280 
281 
282 
283  if (init_type == InitType::WRFInput) {
284  if (moisture_type == MoistureType::None) {
285  amrex::Abort("Can't have moisture_type = None with init_type = WRFInput");
286  }
287 
288  // NetCDF wrfbdy lateral boundary file
289  std::string nc_bdy_file_temp_string;
290  bool has_bdy = pp.query("nc_bdy_file", nc_bdy_file_temp_string);
291  if (!has_bdy) use_real_bcs = false;
292 
293  bool use_real_bcs_temp = use_real_bcs;
294  pp.query("use_real_bcs", use_real_bcs_temp);
295  if (use_real_bcs && !use_real_bcs_temp) {
296  use_real_bcs = false;
297  }
298  if (use_real_bcs) {
299  pp.query("upwind_real_bcs",upwind_real_bcs);
300  }
301  }
302 
303  // Check for rebalancing with wrfinput
304  if (init_type == InitType::WRFInput) {
305  pp.query("rebalance_wrfinput",rebalance_wrfinput);
306  }
307 
308  // How to interpret input_sounding
309  if (init_type == InitType::Input_Sounding) {
310  pp.query_enum_case_insensitive("sounding_type",sounding_type);
311  }
312 
313  if (terrain_type == TerrainType::StaticFittedMesh ||
314  terrain_type == TerrainType::MovingFittedMesh) {
315  mesh_type = MeshType::VariableDz;
316  }
317 
318  int n_zlevels = pp.countval("terrain_z_levels");
319  if (n_zlevels > 0)
320  {
321  if (terrain_type == TerrainType::None) {
322  terrain_type = TerrainType::StaticFittedMesh;
323  }
324  if (mesh_type == MeshType::ConstantDz) {
325  mesh_type = MeshType::StretchedDz;
326  }
327  }
328 
329  // Use lagged_delta_rt in the fast integrator?
330  pp.query("use_lagged_delta_rt", use_lagged_delta_rt);
331 
332  // These default to true but are used for unit testing
333  pp.query("use_gravity", use_gravity);
335 
336  pp.query("c_p", c_p);
337  rdOcp = R_d / c_p;
338 
339  read_int_string(max_level, "anelastic", anelastic, 0);
340 
341  // *******************************************************************************
342  // Read substepping_type and allow for different values at each level
343  // *******************************************************************************
344  substepping_type.resize(max_level+1);
345 
346  for (int i = 0; i <= max_level; i++) {
347  substepping_type[i] = SubsteppingType::Implicit;
348  }
349 
350  int nvals = pp.countval("substepping_type");
351  AMREX_ALWAYS_ASSERT(nvals == 0 || nvals == 1 || nvals >= max_level+1);
352 
353  if (nvals == 1) {
354  pp.query_enum_case_insensitive("substepping_type",substepping_type[0]);
355  for (int i = 1; i <= max_level; i++) {
357  }
358  } else if (nvals > 1) { // in this case we have asserted nvals >= max_level+1
359  for (int i = 0; i <= max_level; i++) {
360  pp.query_enum_case_insensitive("substepping_type",substepping_type[i],i);
361  }
362  }
363 
364  // *******************************************************************************
365  // Error check on deprecated input
366  // *******************************************************************************
367  int nvals_old = pp.countval("no_substepping");
368  if (nvals_old > 0) {
369  amrex::Abort("The no_substepping flag is deprecated -- set substepping_type instead");
370  }
371  // *******************************************************************************
372 
373  bool any_anelastic = false;
374  for (int i = 0; i <= max_level; ++i) {
375  if (anelastic[i] == 1) any_anelastic = true;
376  }
377 
378  if (any_anelastic == 1) {
380  fixed_density = true; // We default to true but are allowed to override below
381  buoyancy_type = 3; // (This isn't actually used when anelastic is set)
382  } else {
383  pp.query("project_initial_velocity", project_initial_velocity);
384  }
385 
386  pp.query("fixed_density", fixed_density);
387 
388  // *******************************************************************************
389 
390  pp.query("ncorr", ncorr);
391  pp.query("poisson_abstol", poisson_abstol);
392  pp.query("poisson_reltol", poisson_reltol);
393 
394  for (int lev = 0; lev <= max_level; lev++) {
395  if (anelastic[lev] != 0)
396  {
397  substepping_type[lev] = SubsteppingType::None;
398  }
399  }
400 
401  pp.query("force_stage1_single_substep", force_stage1_single_substep);
402 
403  // Include Coriolis forcing?
404  pp.query("use_coriolis", use_coriolis);
405  pp.query("has_lat_lon", has_lat_lon);
406  pp.query("variable_coriolis", variable_coriolis);
407 
408  // Include Rayleigh damping (separate flags for each variable)
409  pp.query("rayleigh_damp_U", rayleigh_damp_U);
410  pp.query("rayleigh_damp_V", rayleigh_damp_V);
411  pp.query("rayleigh_damp_W", rayleigh_damp_W);
412  pp.query("rayleigh_damp_T", rayleigh_damp_T);
413  pp.query("rayleigh_dampcoef", rayleigh_dampcoef);
414  pp.query("rayleigh_zdamp", rayleigh_zdamp);
415  pp.query("rayleigh_damp_substep", rayleigh_damp_substep); // apply Rayleigh damping source terms in substep only
416 
417  // flags for whether to apply other source terms in substep only
418  pp.query("immersed_forcing_substep", immersed_forcing_substep); // apply Rayleigh damping source terms in substep only
419  pp.query("forest_substep", forest_substep); // apply Rayleigh damping source terms in substep only
420 
421  // Flag to do MOST rotations with terrain
422  pp.query("use_rotate_surface_flux",use_rotate_surface_flux);
424  AMREX_ASSERT_WITH_MESSAGE(terrain_type != TerrainType::None,"MOST stress rotations are only valid with terrain!");
425  }
426 
427  // Which external forcings?
428  abl_driver_type = ABLDriverType::None; // Default: no ABL driver for simulating classical fluid dynamics problems
429  pp.query_enum_case_insensitive("abl_driver_type",abl_driver_type);
430  pp.query("const_massflux_u", const_massflux_u);
431  pp.query("const_massflux_v", const_massflux_v);
432  pp.query("const_massflux_tau", const_massflux_tau);
433  pp.query("const_massflux_layer_lo", const_massflux_layer_lo);
434  pp.query("const_massflux_layer_hi", const_massflux_layer_hi);
435 
436  // Which type of inflow turbulent generation
437  pert_type = PerturbationType::None; // Default
438  pp.query_enum_case_insensitive("perturbation_type",pert_type);
439 
440  amrex::Vector<amrex::Real> abl_pressure_grad_in = {0.0, 0.0, 0.0};
441  pp.queryarr("abl_pressure_grad",abl_pressure_grad_in);
442  for(int i = 0; i < AMREX_SPACEDIM; ++i) abl_pressure_grad[i] = abl_pressure_grad_in[i];
443 
444  amrex::Vector<amrex::Real> abl_geo_forcing_in = {0.0, 0.0, 0.0};
445  if(pp.queryarr("abl_geo_forcing",abl_geo_forcing_in)) {
446  amrex::Print() << "Specified abl_geo_forcing: (";
447  for (int i = 0; i < AMREX_SPACEDIM; ++i) {
448  abl_geo_forcing[i] = abl_geo_forcing_in[i];
449  amrex::Print() << abl_geo_forcing[i] << " ";
450  }
451  amrex::Print() << ")" << std::endl;
452  }
453 
454  if (use_coriolis)
455  {
457  }
458 
459  pp.query("add_custom_rhotheta_forcing", custom_rhotheta_forcing);
460  pp.query("add_custom_moisture_forcing", custom_moisture_forcing);
461  pp.query("add_custom_w_subsidence", custom_w_subsidence);
462  pp.query("add_custom_geostrophic_profile", custom_geostrophic_profile);
463  pp.query("custom_forcing_uses_primitive_vars", custom_forcing_prim_vars);
464 
465  pp.query("nudging_from_input_sounding", nudging_from_input_sounding);
466 
468  AMREX_ALWAYS_ASSERT_WITH_MESSAGE(!(!abl_geo_wind_table.empty() && custom_geostrophic_profile),
469  "Should not have both abl_geo_wind_table and custom_geostrophic_profile set.");
470 
471  pp.query("Ave_Plane", ave_plane);
472 
473  pp.query("use_moist_background", use_moist_background);
474 
475  // Use numerical diffusion?
476  pp.query("num_diff_coeff",num_diff_coeff);
477  AMREX_ASSERT_WITH_MESSAGE(( (num_diff_coeff >= 0.) && (num_diff_coeff <= 1.) ),
478  "Numerical diffusion coefficient must be between 0 & 1.");
480  if (use_num_diff) {
481  amrex::Print() << "6th-order numerical diffusion turned on with coefficient = "
482  << num_diff_coeff << std::endl;
483  num_diff_coeff *= std::pow(2.0,-6);
484  }
485 
486  advChoice.init_params(pp_prefix);
487  diffChoice.init_params(pp_prefix);
488  spongeChoice.init_params(pp_prefix);
489 
490  turbChoice.resize(max_level+1);
491  for (int lev = 0; lev <= max_level; lev++) {
492  turbChoice[lev].init_params(lev,max_level,pp_prefix);
493  }
494 
495  // YSU PBL: use consistent coriolis frequency
496  for (int lev = 0; lev <= max_level; lev++) {
497  if (turbChoice[lev].pbl_ysu_use_consistent_coriolis) {
498  if (use_coriolis) {
499  turbChoice[lev].pbl_ysu_coriolis_freq = coriolis_factor * sinphi;
500  if (lev == 0) {
501  amrex::Print() << "YSU PBL using ERF coriolis frequency: " << turbChoice[lev].pbl_ysu_coriolis_freq << std::endl;
502  }
503  } else {
504  amrex::Abort("YSU cannot use ERF coriolis frequency if not using coriolis");
505  }
506  }
507  }
508  // MRF
509  for (int lev = 0; lev <= max_level; lev++) {
510  if (turbChoice[lev].pbl_ysu_use_consistent_coriolis) {
511  if (use_coriolis) {
512  turbChoice[lev].pbl_ysu_coriolis_freq = coriolis_factor * sinphi;
513  if (lev == 0) {
514  amrex::Print() << "MRF PBL using ERF coriolis frequency: " << turbChoice[lev].pbl_ysu_coriolis_freq << std::endl;
515  }
516  } else {
517  amrex::Abort("MRF cannot use ERF coriolis frequency if not using coriolis");
518  }
519  }
520  }
521 
522  // Are we using SHOC?
523  pp.query("use_shoc", use_shoc);
524 #ifndef ERF_USE_SHOC
525  if (use_shoc) {
526  amrex::Abort("You set use_shoc to true but didn't build with SHOC; you must rebuild the executable");
527  }
528 #endif
529 
530  // Which type of multilevel coupling
531  coupling_type = CouplingType::TwoWay; // Default
532  pp.query_enum_case_insensitive("coupling_type",coupling_type);
533 
534  // Which type of windfarm model
535  windfarm_type = WindFarmType::None; // Default
536  pp.query_enum_case_insensitive("windfarm_type",windfarm_type);
537 
538  static std::string windfarm_loc_type_string = "None";
539  windfarm_loc_type = WindFarmLocType::None;
540  pp.query_enum_case_insensitive("windfarm_loc_type",windfarm_loc_type);
541 
542  pp.query("windfarm_loc_table", windfarm_loc_table);
543  pp.query("windfarm_spec_table", windfarm_spec_table);
544  pp.query("windfarm_blade_table", windfarm_blade_table);
545  pp.query("windfarm_airfoil_tables", windfarm_airfoil_tables);
546  pp.query("windfarm_spec_table_extra", windfarm_spec_table_extra);
547 
548  // Sampling distance upstream of the turbine to find the
549  // incoming free stream velocity as a factor of the diameter of the
550  // turbine. ie. the sampling distance will be this number multiplied
551  // by the diameter of the turbine
552  pp.query("sampling_distance_by_D", sampling_distance_by_D);
553  pp.query("turb_disk_angle_from_x", turb_disk_angle);
554 
555  pp.query("windfarm_x_shift",windfarm_x_shift);
556  pp.query("windfarm_y_shift",windfarm_y_shift);
557  // Test if time averaged data is to be output
558  pp.query("time_avg_vel",time_avg_vel);
559 
560  pp.query("hindcast_lateral_forcing", hindcast_lateral_forcing);
561 
563  pp.query("hindcast_boundary_data_dir", hindcast_boundary_data_dir);
564  if(hindcast_boundary_data_dir.empty()) {
565  amrex::Abort("ERROR: Missing input parameter 'erf.hindcast_boundary_data_dir' for boundary data for lateral forcing");
566  }
567 
568  pp.query("hindcast_lateral_sponge_strength", hindcast_lateral_sponge_strength);
569  pp.query("hindcast_lateral_sponge_length", hindcast_lateral_sponge_length);
570 
571  pp.query("hindcast_zhi_sponge_length", hindcast_zhi_sponge_length);
572  pp.query("hindcast_zhi_sponge_strength", hindcast_zhi_sponge_strength);
573 
574  pp.query("hindcast_zhi_sponge_damping", hindcast_zhi_sponge_damping);
575 
577  amrex::Abort("ERROR: Missing input parameter 'erf.hindcast_lateral_sponge_strength' or it is specified to be less than zero");
578  }
579 
581  amrex::Abort("ERROR: Missing input parameter 'erf.hindcast_lateral_sponge_length' or it is specified to be less than zero");
582  }
583 
585  amrex::Abort("ERROR: Missing input parameter 'erf.hindcast_zhi_sponge_strength' or it is specified to be less than zero");
586  }
587 
589  amrex::Abort("ERROR: Missing input parameter 'erf.hindcast_zhi_sponge_strength' or it is specified to be less than zero");
590  }
591  }
592 
593  check_params(max_level);
594  }
constexpr amrex::Real CONST_GRAV
Definition: ERF_Constants.H:21
constexpr amrex::Real R_d
Definition: ERF_Constants.H:10
#define RhoQ4_comp
Definition: ERF_IndexDefines.H:45
#define RhoQ2_comp
Definition: ERF_IndexDefines.H:43
#define RhoQ3_comp
Definition: ERF_IndexDefines.H:44
#define RhoQ1_comp
Definition: ERF_IndexDefines.H:42
#define RhoQ6_comp
Definition: ERF_IndexDefines.H:47
#define RhoQ5_comp
Definition: ERF_IndexDefines.H:46
@ bogus
Definition: ERF_IndexDefines.H:204
void init_params(std::string pp_prefix)
Definition: ERF_AdvStruct.H:21
void init_params(std::string pp_prefix)
Definition: ERF_DiffStruct.H:21
Definition: ERF_DataStruct.H:99
bool rayleigh_damp_T
Definition: ERF_DataStruct.H:850
amrex::Real dz0
Definition: ERF_DataStruct.H:871
amrex::Real const_massflux_layer_lo
Definition: ERF_DataStruct.H:948
bool rayleigh_damp_V
Definition: ERF_DataStruct.H:848
bool rebalance_wrfinput
Definition: ERF_DataStruct.H:908
amrex::Real hindcast_lateral_sponge_strength
Definition: ERF_DataStruct.H:955
amrex::Real poisson_reltol
Definition: ERF_DataStruct.H:836
bool rayleigh_damp_substep
Definition: ERF_DataStruct.H:854
void build_coriolis_forcings_const_lat(std::string pp_prefix)
Definition: ERF_DataStruct.H:740
amrex::Real rayleigh_zdamp
Definition: ERF_DataStruct.H:852
amrex::Real rdOcp
Definition: ERF_DataStruct.H:866
void read_int_string(int max_level, const char *string_to_read, amrex::Vector< int > &vec_to_fill, int default_int)
Definition: ERF_DataStruct.H:782
std::string windfarm_spec_table
Definition: ERF_DataStruct.H:934
amrex::Real hindcast_zhi_sponge_length
Definition: ERF_DataStruct.H:956
amrex::Real const_massflux_v
Definition: ERF_DataStruct.H:946
int ncorr
Definition: ERF_DataStruct.H:834
bool hindcast_zhi_sponge_damping
Definition: ERF_DataStruct.H:957
std::string windfarm_spec_table_extra
Definition: ERF_DataStruct.H:934
LandSurfaceType lsm_type
Definition: ERF_DataStruct.H:914
amrex::Real c_p
Definition: ERF_DataStruct.H:865
std::string windfarm_loc_table
Definition: ERF_DataStruct.H:934
amrex::Real gravity
Definition: ERF_DataStruct.H:864
void check_params(int max_level)
Definition: ERF_DataStruct.H:596
bool custom_rhotheta_forcing
Definition: ERF_DataStruct.H:881
amrex::Real hindcast_lateral_sponge_length
Definition: ERF_DataStruct.H:955
bool use_shoc
Definition: ERF_DataStruct.H:895
bool hindcast_lateral_forcing
Definition: ERF_DataStruct.H:954
bool moisture_tight_coupling
Definition: ERF_DataStruct.H:932
bool custom_w_subsidence
Definition: ERF_DataStruct.H:883
bool nudging_from_input_sounding
Definition: ERF_DataStruct.H:889
bool rayleigh_damp_U
Definition: ERF_DataStruct.H:847
bool custom_geostrophic_profile
Definition: ERF_DataStruct.H:884
bool immersed_forcing_substep
Definition: ERF_DataStruct.H:857
amrex::Real grid_stretching_ratio
Definition: ERF_DataStruct.H:869
bool have_geo_wind_profile
Definition: ERF_DataStruct.H:921
amrex::Real const_massflux_u
Definition: ERF_DataStruct.H:945
bool use_num_diff
Definition: ERF_DataStruct.H:904
amrex::Real hindcast_zhi_sponge_strength
Definition: ERF_DataStruct.H:956
bool test_mapfactor
Definition: ERF_DataStruct.H:838
static SoundingType sounding_type
Definition: ERF_DataStruct.H:803
bool custom_moisture_forcing
Definition: ERF_DataStruct.H:882
amrex::Real num_diff_coeff
Definition: ERF_DataStruct.H:905
std::string windfarm_blade_table
Definition: ERF_DataStruct.H:935
amrex::Real zsurf
Definition: ERF_DataStruct.H:870
bool variable_coriolis
Definition: ERF_DataStruct.H:924
bool project_initial_velocity
Definition: ERF_DataStruct.H:873
static bool upwind_real_bcs
Definition: ERF_DataStruct.H:812
bool use_moist_background
Definition: ERF_DataStruct.H:929
bool custom_forcing_prim_vars
Definition: ERF_DataStruct.H:885
bool rayleigh_damp_W
Definition: ERF_DataStruct.H:849
PerturbationType pert_type
Definition: ERF_DataStruct.H:901
static InitType init_type
Definition: ERF_DataStruct.H:800
amrex::Real const_massflux_layer_hi
Definition: ERF_DataStruct.H:949
static bool use_real_bcs
Definition: ERF_DataStruct.H:809
amrex::Real poisson_abstol
Definition: ERF_DataStruct.H:835
MoistureComponentIndices moisture_indices
Definition: ERF_DataStruct.H:930
bool has_lat_lon
Definition: ERF_DataStruct.H:923
bool use_rotate_surface_flux
Definition: ERF_DataStruct.H:892
amrex::Real const_massflux_tau
Definition: ERF_DataStruct.H:947
bool time_avg_vel
Definition: ERF_DataStruct.H:898
bool forest_substep
Definition: ERF_DataStruct.H:858
amrex::Real rayleigh_dampcoef
Definition: ERF_DataStruct.H:851
std::string windfarm_airfoil_tables
Definition: ERF_DataStruct.H:935
int ave_plane
Definition: ERF_DataStruct.H:926
std::string hindcast_boundary_data_dir
Definition: ERF_DataStruct.H:953
void init_params(std::string pp_prefix)
Definition: ERF_SpongeStruct.H:17
Here is the call graph for this function:

◆ read_int_string()

void SolverChoice::read_int_string ( int  max_level,
const char *  string_to_read,
amrex::Vector< int > &  vec_to_fill,
int  default_int 
)
inline
784  {
785  amrex::ParmParse pp("erf");
786  int nvals = pp.countval(string_to_read);
787  AMREX_ALWAYS_ASSERT(nvals == 0 || nvals == 1 || nvals >= max_level+1);
788  amrex::Vector<int> temp; temp.resize(nvals);
789  pp.queryarr(string_to_read,temp);
790  if (nvals == 0) {
791  for (int i = 0; i <= max_level; ++i) vec_to_fill.push_back(default_int);
792  } else if (nvals == 1) {
793  for (int i = 0; i <= max_level; ++i) vec_to_fill.push_back(temp[0]);
794  } else {
795  for (int i = 0; i <= max_level; ++i) vec_to_fill.push_back(temp[i]);
796  }
797  }

Referenced by init_params().

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

◆ set_mesh_type()

static void SolverChoice::set_mesh_type ( MeshType  new_mesh_type)
inlinestatic
819  {
820  mesh_type = new_mesh_type;
821  }

Referenced by ProblemBase::init_custom_terrain().

Here is the caller graph for this function:

Member Data Documentation

◆ abl_driver_type

ABLDriverType SolverChoice::abl_driver_type

◆ abl_geo_forcing

amrex::GpuArray<amrex::Real, AMREX_SPACEDIM> SolverChoice::abl_geo_forcing

◆ abl_geo_wind_table

std::string SolverChoice::abl_geo_wind_table

◆ abl_pressure_grad

amrex::GpuArray<amrex::Real, AMREX_SPACEDIM> SolverChoice::abl_pressure_grad

◆ advChoice

◆ anelastic

amrex::Vector<int> SolverChoice::anelastic

◆ ave_plane

int SolverChoice::ave_plane {2}

◆ buoyancy_type

int SolverChoice::buoyancy_type = 1

◆ c_p

◆ const_massflux_layer_hi

amrex::Real SolverChoice::const_massflux_layer_hi = 1e34

Referenced by init_params().

◆ const_massflux_layer_lo

amrex::Real SolverChoice::const_massflux_layer_lo = -1e34

Referenced by init_params().

◆ const_massflux_tau

amrex::Real SolverChoice::const_massflux_tau = 1.0

Referenced by init_params(), and make_mom_sources().

◆ const_massflux_u

amrex::Real SolverChoice::const_massflux_u = 0.0

Referenced by init_params(), and make_mom_sources().

◆ const_massflux_v

amrex::Real SolverChoice::const_massflux_v = 0.0

Referenced by init_params(), and make_mom_sources().

◆ coriolis_3d

bool SolverChoice::coriolis_3d = true

◆ coriolis_factor

amrex::Real SolverChoice::coriolis_factor = 0.0

◆ cosphi

amrex::Real SolverChoice::cosphi = 0.0

◆ coupling_type

CouplingType SolverChoice::coupling_type

◆ custom_forcing_prim_vars

bool SolverChoice::custom_forcing_prim_vars = false

◆ custom_geostrophic_profile

bool SolverChoice::custom_geostrophic_profile = false

Referenced by init_params().

◆ custom_moisture_forcing

bool SolverChoice::custom_moisture_forcing = false

Referenced by init_params(), and make_sources().

◆ custom_rhotheta_forcing

bool SolverChoice::custom_rhotheta_forcing = false

Referenced by init_params(), and make_sources().

◆ custom_w_subsidence

bool SolverChoice::custom_w_subsidence = false

◆ diffChoice

◆ do_forest_drag

bool SolverChoice::do_forest_drag {false}

Referenced by make_mom_sources().

◆ dz0

amrex::Real SolverChoice::dz0

Referenced by init_params().

◆ fixed_density

bool SolverChoice::fixed_density = false

◆ force_stage1_single_substep

int SolverChoice::force_stage1_single_substep = 1

Referenced by display(), and init_params().

◆ forest_substep

bool SolverChoice::forest_substep = false

Referenced by init_params(), and make_mom_sources().

◆ gravity

◆ grid_stretching_ratio

amrex::Real SolverChoice::grid_stretching_ratio = 0

Referenced by init_params().

◆ has_lat_lon

bool SolverChoice::has_lat_lon {false}

Referenced by init_params(), and make_mom_sources().

◆ have_geo_wind_profile

bool SolverChoice::have_geo_wind_profile {false}

Referenced by init_params(), and make_mom_sources().

◆ hindcast_boundary_data_dir

std::string SolverChoice::hindcast_boundary_data_dir

Referenced by init_params().

◆ hindcast_lateral_forcing

bool SolverChoice::hindcast_lateral_forcing = false

Referenced by init_params(), and make_mom_sources().

◆ hindcast_lateral_sponge_length

amrex::Real SolverChoice::hindcast_lateral_sponge_length = -1.0

◆ hindcast_lateral_sponge_strength

amrex::Real SolverChoice::hindcast_lateral_sponge_strength = -1.0

◆ hindcast_zhi_sponge_damping

bool SolverChoice::hindcast_zhi_sponge_damping = false

◆ hindcast_zhi_sponge_length

amrex::Real SolverChoice::hindcast_zhi_sponge_length = -1.0

◆ hindcast_zhi_sponge_strength

amrex::Real SolverChoice::hindcast_zhi_sponge_strength = -1.0

◆ immersed_forcing_substep

bool SolverChoice::immersed_forcing_substep = false

◆ init_type

InitType SolverChoice::init_type = InitType::None
inlinestatic

Referenced by init_params(), and make_mom_sources().

◆ lsm_type

LandSurfaceType SolverChoice::lsm_type

◆ massflux_khi

int SolverChoice::massflux_khi {0}

Referenced by make_mom_sources().

◆ massflux_klo

int SolverChoice::massflux_klo {0}

Referenced by make_mom_sources().

◆ mesh_type

◆ moisture_indices

MoistureComponentIndices SolverChoice::moisture_indices

◆ moisture_tight_coupling

bool SolverChoice::moisture_tight_coupling {false}

Referenced by init_params().

◆ moisture_type

◆ ncorr

int SolverChoice::ncorr = 1

Referenced by init_params().

◆ nudging_from_input_sounding

bool SolverChoice::nudging_from_input_sounding = false

◆ num_diff_coeff

amrex::Real SolverChoice::num_diff_coeff {0.}

◆ pert_type

PerturbationType SolverChoice::pert_type

Referenced by init_params(), and make_sources().

◆ poisson_abstol

amrex::Real SolverChoice::poisson_abstol = 1e-8

Referenced by init_params().

◆ poisson_reltol

amrex::Real SolverChoice::poisson_reltol = 1e-8

Referenced by init_params().

◆ project_initial_velocity

bool SolverChoice::project_initial_velocity = false

Referenced by init_params().

◆ rad_type

RadiationType SolverChoice::rad_type

Referenced by display(), init_params(), and make_sources().

◆ rayleigh_damp_substep

bool SolverChoice::rayleigh_damp_substep = false

◆ rayleigh_damp_T

bool SolverChoice::rayleigh_damp_T = false

Referenced by init_params(), and make_sources().

◆ rayleigh_damp_U

bool SolverChoice::rayleigh_damp_U = false

Referenced by init_params(), and make_mom_sources().

◆ rayleigh_damp_V

bool SolverChoice::rayleigh_damp_V = false

Referenced by init_params(), and make_mom_sources().

◆ rayleigh_damp_W

bool SolverChoice::rayleigh_damp_W = false

Referenced by init_params(), and make_mom_sources().

◆ rayleigh_dampcoef

amrex::Real SolverChoice::rayleigh_dampcoef = 0.2

◆ rayleigh_zdamp

amrex::Real SolverChoice::rayleigh_zdamp = 500.0

◆ rayleigh_ztop

amrex::Real SolverChoice::rayleigh_ztop

Referenced by make_mom_sources(), and make_sources().

◆ rdOcp

◆ rebalance_wrfinput

bool SolverChoice::rebalance_wrfinput {false}

Referenced by init_params().

◆ sampling_distance_by_D

amrex::Real SolverChoice::sampling_distance_by_D = -1.0

Referenced by check_params(), and init_params().

◆ sinphi

amrex::Real SolverChoice::sinphi = 0.0

◆ sounding_type

SoundingType SolverChoice::sounding_type = SoundingType::Ideal
inlinestatic

Referenced by init_params().

◆ spongeChoice

SpongeChoice SolverChoice::spongeChoice

◆ substepping_type

amrex::Vector<SubsteppingType> SolverChoice::substepping_type

Referenced by display(), and init_params().

◆ terrain_type

◆ test_mapfactor

bool SolverChoice::test_mapfactor = false

Referenced by init_params().

◆ time_avg_vel

bool SolverChoice::time_avg_vel = false

Referenced by init_params().

◆ turb_disk_angle

amrex::Real SolverChoice::turb_disk_angle = -1.0

Referenced by check_params(), and init_params().

◆ turbChoice

◆ upwind_real_bcs

bool SolverChoice::upwind_real_bcs = false
inlinestatic

Referenced by init_params().

◆ use_coriolis

bool SolverChoice::use_coriolis = false

◆ use_gravity

bool SolverChoice::use_gravity = false

Referenced by display(), and init_params().

◆ use_lagged_delta_rt

bool SolverChoice::use_lagged_delta_rt = true

Referenced by check_params(), and init_params().

◆ use_moist_background

bool SolverChoice::use_moist_background {false}

Referenced by init_params().

◆ use_num_diff

bool SolverChoice::use_num_diff {false}

◆ use_real_bcs

bool SolverChoice::use_real_bcs = false
inlinestatic

Referenced by init_params().

◆ use_rotate_surface_flux

bool SolverChoice::use_rotate_surface_flux = false

◆ use_shoc

bool SolverChoice::use_shoc = false

◆ variable_coriolis

bool SolverChoice::variable_coriolis {false}

Referenced by init_params(), and make_mom_sources().

◆ windfarm_airfoil_tables

std::string SolverChoice::windfarm_airfoil_tables

Referenced by init_params().

◆ windfarm_blade_table

std::string SolverChoice::windfarm_blade_table

Referenced by init_params().

◆ windfarm_loc_table

std::string SolverChoice::windfarm_loc_table

Referenced by init_params().

◆ windfarm_loc_type

WindFarmLocType SolverChoice::windfarm_loc_type

Referenced by check_params(), and init_params().

◆ windfarm_spec_table

std::string SolverChoice::windfarm_spec_table

Referenced by init_params().

◆ windfarm_spec_table_extra

std::string SolverChoice::windfarm_spec_table_extra

Referenced by init_params().

◆ windfarm_type

WindFarmType SolverChoice::windfarm_type

Referenced by check_params(), and init_params().

◆ windfarm_x_shift

amrex::Real SolverChoice::windfarm_x_shift = -1.0

Referenced by check_params(), and init_params().

◆ windfarm_y_shift

amrex::Real SolverChoice::windfarm_y_shift = -1.0

Referenced by check_params(), and init_params().

◆ zsurf

amrex::Real SolverChoice::zsurf = 0.0

Referenced by init_params().


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