SolverChoice Struct Reference

#include <ERF_DataStruct.H>

Collaboration diagram for SolverChoice:

Public Member Functions
void	init_params (int max_level, std::string pp_prefix)
	Read solver-wide algorithmic options from the input parameter database. More...
void	check_params (int max_level, const amrex::Vector< amrex::Geometry > &geom_vect, amrex::GpuArray< ERF_BC, AMREX_SPACEDIM *2 > phys_bc_type)
	Validate solver options after geometry and boundary conditions are known. More...
void	display (int max_level, std::string pp_prefix)
	Print the configured solver, physics, and transport options. More...
void	build_coriolis_forcings_const_lat (std::string pp_prefix)
	Build constant-latitude Coriolis forcing parameters. More...
void	read_int_string (int max_level, const char *string_to_read, amrex::Vector< int > &vec_to_fill, int default_int)
	Read one integer value or one value per AMR level. More...
bool	use_perturbation (int lev) const
	Query whether any turbulent perturbation mode is enabled on a level. More...
bool	use_direct_perturbation (int lev) const
	Query whether direct turbulent perturbations are enabled on a level. More...
bool	use_source_perturbation (int lev) const
	Query whether source-term turbulent perturbations are enabled on a level. More...
bool	use_wvel_perturbation (int lev) const
	Query whether vertical-velocity CPM perturbations are enabled on a level. More...
bool	uses_shoc_family () const noexcept
	Query whether any SHOC-family PBL scheme is active. More...
bool	pbl_suppresses_microphysics_condensation () const noexcept
	Query whether the active PBL scheme suppresses microphysics condensation. More...
bool	any_perturbation () const
	Query whether any level uses a turbulent perturbation mode. More...

Static Public Member Functions
static void	set_mesh_type (MeshType new_mesh_type)
	Override the globally selected mesh type. More...

Public Attributes
AdvChoice	advChoice
	Advection-related options. More...
DiffChoice	diffChoice
	Diffusion-related options. More...
DampingChoice	dampingChoice
	Damping-related options. More...
SpongeChoice	spongeChoice
	Sponge-layer options. More...
amrex::Vector< TurbChoice >	turbChoice
	Turbulence options for each AMR level. More...
EBChoice	ebChoice
	Embedded-boundary options. More...
int	force_stage1_single_substep = 1
	Flag forcing a single substep in the first RK stage. More...
amrex::Vector< SubsteppingType >	substepping_type
	Acoustic substepping type for each AMR level. More...
amrex::Vector< int >	anelastic
	Per-level flag selecting anelastic dynamics. More...
amrex::Vector< int >	fixed_density
	Per-level flag selecting fixed-density treatment. More...
amrex::Vector< int >	project_initial_velocity
	Per-level flag for projecting the initial velocity. More...
amrex::Vector< int >	buoyancy_type
	Per-level buoyancy formulation selector. More...
amrex::Vector< int >	is_land
	Per-level land/water selector. More...
bool	substepping_diag = false
	Whether to emit extra CFL diagnostics for compressible substepping. More...
amrex::Real	beta_s = amrex::Real(0.1)
	Time off-centering coefficient for forward weighting. More...
amrex::Vector< amrex::Vector< amrex::Real > >	vert_implicit_fac
	Per-level, per-stage implicit vertical diffusion factors. More...
bool	implicit_thermal_diffusion = true
	Whether implicit vertical thermal diffusion is included. More...
bool	implicit_moisture_diffusion = true
	Whether implicit vertical moisture diffusion is included. More...
bool	implicit_ke_diffusion = true
	Whether implicit vertical TKE diffusion is included. More...
bool	implicit_momentum_diffusion = true
	Whether implicit vertical momentum diffusion is included. More...
bool	implicit_before_substep = true
	Whether implicit diffusion is applied before acoustic substepping. More...
int	ncorr = 1
	Number of projection correction iterations. More...
amrex::Real	poisson_abstol = amrex::Real(1e-8)
	Absolute tolerance for the Poisson solve. More...
amrex::Real	poisson_reltol = amrex::Real(1e-8)
	Relative tolerance for the Poisson solve. More...
bool	test_mapfactor = false
	Whether to use test map scale factors. More...
int	gradp_type = 0
	Terrain-fitted horizontal pressure-gradient formulation. More...
bool	use_pert_pres_gradient = true
	Whether momentum equations use perturbational pressure gradients. More...
bool	use_gravity = false
	Whether gravitational forcing is enabled. More...
bool	use_coriolis = false
	Whether Coriolis forcing is enabled. More...
bool	coriolis_3d = true
	Whether the three-dimensional Coriolis terms are included. More...
bool	four_stream_radiation = false
	Whether the four-stream radiation approximation is enabled. More...
bool	immersed_forcing_substep = false
	Whether immersed-forcing source terms are applied only during substeps. More...
bool	forest_substep = false
	Whether canopy source terms are applied only during substeps. More...
amrex::Real	if_Cd_momentum = amrex::Real(50.0)
	Immersed-forcing drag coefficient for momentum. More...
amrex::Real	if_Cd_scalar = amrex::Real(10.0)
	Immersed-forcing drag coefficient for scalars. More...
bool	if_implicit_drag = false
amrex::Real	if_z0 = amrex::Real(0.1)
	Immersed-forcing roughness length [m]. More...
amrex::Real	if_surf_temp_flux = amrex::Real(1e-8)
	Immersed-forcing surface temperature flux [K m/s]. More...
amrex::Real	if_init_surf_temp = zero
	Initial immersed-forcing surface temperature [K]. More...
amrex::Real	if_surf_heating_rate = zero
	Immersed-forcing surface heating rate [K/hr]. More...
amrex::Real	if_Olen_in = amrex::Real(1e-8)
	Input Obukhov length for immersed-forcing MOST [m]. More...
bool	if_use_most = false
	Whether immersed-forcing MOST is enabled. More...
bool	if_stability_correction = false
	Whether immersed-forcing stability corrections are enabled. More...
amrex::Real	if_ws_floor = 0.001
	Wind-speed floor for immersed-forcing MOST [m/s]. More...
amrex::Real	if_damp_alpha = 0.5
	Immersed-forcing damping coefficient. More...
bool	use_lagged_delta_rt = true
	Whether to use lagged delta terms for moving terrain. More...
bool	rebalance_wrf_input = true
	Whether to rebalance states from wrfinput and wrfbdy data. More...
amrex::Real	gravity
	Effective gravitational acceleration. More...
amrex::Real	c_p = Cp_d
	Specific heat at constant pressure for dry air [J/(kg-K)]. More...
amrex::Real	rdOcp
	Ratio of dry-air gas constant to c_p. More...
amrex::Real	grid_stretching_ratio = 0
	Vertical grid stretching ratio. More...
amrex::Real	zsurf = zero
	Nominal surface height for stretched-grid setup. More...
amrex::Real	dz0
	Initial vertical grid spacing for stretched-grid setup. More...
amrex::Real	coriolis_factor = zero
	Twice the planetary rotation rate used for Coriolis forcing. More...
amrex::Real	cosphi = zero
	Cosine of the latitude used for Coriolis forcing. More...
amrex::Real	sinphi = zero
	Sine of the latitude used for Coriolis forcing. More...
bool	custom_rhotheta_forcing = false
	Whether custom rho-theta forcing is enabled. More...
bool	custom_moisture_forcing = false
	Whether custom moisture forcing is enabled. More...
bool	custom_w_subsidence = false
	Whether custom vertical subsidence is enabled. More...
bool	do_theta_advection = true
	Whether custom vertical subsidence is applied to rho-theta. More...
bool	do_mom_advection = true
	Whether custom vertical subsidence is applied to momentum. More...
bool	custom_geostrophic_profile = false
	Whether a custom geostrophic wind profile is used. More...
bool	custom_forcing_prim_vars = false
	Whether custom forcing operates on primitive variables. More...
bool	spatial_rhotheta_forcing = false
	Whether spatially varying rho-theta forcing is enabled. More...
bool	spatial_moisture_forcing = false
	Whether spatially varying moisture forcing is enabled. More...
bool	nudging_from_input_sounding = false
	Whether solution fields are nudged toward input sounding data. More...
bool	use_rotate_surface_flux = false
	Whether MOST surface fluxes are rotated with terrain. More...
bool	use_eamxx_shoc = false
	Whether any level uses the EAMxx SHOC PBL scheme. More...
bool	use_native_shoc = false
	Whether any level uses the native SHOC PBL scheme. More...
bool	transport_scalar = true
	Whether the passive scalar component is transported. More...
bool	time_avg_vel = false
	Whether time-averaged velocity fields are output. More...
amrex::Vector< PerturbationType >	pert_type
	Turbulent perturbation type for each AMR level. More...
bool	use_num_diff {false}
	Whether sixth-order numerical diffusion is enabled. More...
amrex::Real	num_diff_coeff {zero}
	Numerical diffusion coefficient after input scaling. More...
CouplingType	coupling_type
	Multilevel coupling strategy. More...
MoistureType	moisture_type
	Moisture or microphysics model. More...
WindFarmType	windfarm_type
	Wind-farm model. More...
WindFarmLocType	windfarm_loc_type
	Coordinate system for wind-farm turbine locations. More...
LandSurfaceType	lsm_type
	Land-surface model. More...
RadiationType	rad_type
	Radiation model. More...
ABLDriverType	abl_driver_type
	Atmospheric boundary-layer driver type. More...
amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >	abl_pressure_grad
	Applied ABL pressure-gradient forcing vector. More...
amrex::GpuArray< amrex::Real, AMREX_SPACEDIM >	abl_geo_forcing
	Applied geostrophic-wind forcing vector. More...
std::string	abl_geo_wind_table
	Path to a time-varying geostrophic wind table. More...
bool	have_geo_wind_profile {false}
	Whether a geostrophic wind profile has been configured. More...
bool	variable_coriolis {false}
	Whether spatially varying Coriolis forcing is enabled. More...
int	ave_plane {2}
	Averaging plane index used by diagnostics. More...
MoistureComponentIndices	moisture_indices
	Conserved-state component indices for active moisture species. More...
bool	moisture_tight_coupling {false}
	Whether moisture updates use tight coupling. More...
std::string	windfarm_loc_table
	Wind-farm location table path. More...
std::string	windfarm_spec_table
	Wind-farm turbine specification table path. More...
std::string	windfarm_spec_table_extra
	Additional wind-farm turbine specification table path. More...
std::string	windfarm_blade_table
	Wind-farm blade table path. More...
std::string	windfarm_airfoil_tables
	Wind-farm airfoil table paths. More...
amrex::Real	sampling_distance_by_D = -one
	Turbine inflow sampling distance normalized by rotor diameter. More...
amrex::Real	turb_disk_angle = -one
	Turbine disk angle from the x axis [deg]. More...
amrex::Real	windfarm_x_shift = -one
	Wind-farm x-coordinate shift. More...
amrex::Real	windfarm_y_shift = -one
	Wind-farm y-coordinate shift. More...
amrex::Real	bdy_nudge_factor = amrex::Real(10.0)
	Boundary sponge nudging factor. More...
bool	use_wrf_bdy_density = false
amrex::Real	bdy_rho_nudge_factor = amrex::Real(-1.0)
int	bdy_moist_nudge_type = 0
	Moist-variable nudging strategy in boundary regions. More...
bool	use_wrf_height_grid {true}
bool	do_forest_drag {false}
	Whether forest canopy drag is enabled. More...
amrex::Real	const_massflux_u = zero
	Target constant mass flux in the x direction. More...
amrex::Real	const_massflux_v = zero
	Target constant mass flux in the y direction. More...
amrex::Real	const_massflux_tau = one
	Relaxation time scale for constant-mass-flux forcing. More...
amrex::Real	const_massflux_layer_lo = amrex::Real(-bogus_large_value)
	Lower height of the constant-mass-flux forcing layer. More...
amrex::Real	const_massflux_layer_hi = amrex::Real( bogus_large_value)
	Upper height of the constant-mass-flux forcing layer. More...
int	massflux_klo {0}
	Lower vertical index for constant-mass-flux forcing. More...
int	massflux_khi {0}
	Upper vertical index for constant-mass-flux forcing. More...
std::string	hindcast_boundary_data_dir
	Directory containing hindcast lateral boundary data. More...
std::string	hindcast_surface_data_dir
	Directory containing hindcast surface boundary data. More...
amrex::Real	hindcast_data_interval_in_hrs = -one
	Time interval between hindcast data files [hr]. More...
bool	hindcast_lateral_forcing = false
	Whether hindcast lateral forcing is enabled. More...
bool	hindcast_surface_bcs = false
	Whether hindcast surface boundary conditions are enabled. More...
amrex::Real	hindcast_lateral_sponge_strength = -one
	Strength of the hindcast lateral sponge layer. More...
amrex::Real	hindcast_lateral_sponge_length = -one
	Length of the hindcast lateral sponge layer. More...
amrex::Real	hindcast_zhi_sponge_strength = -one
	Strength of the upper hindcast sponge layer. More...
amrex::Real	hindcast_zhi_sponge_length = -one
	Length of the upper hindcast sponge layer. More...
bool	hindcast_zhi_sponge_damping = false
	Whether upper-boundary hindcast sponge damping is enabled. More...
bool	io_hurricane_eye_tracker = false
	Whether hurricane-eye tracking output is enabled. More...
amrex::Real	hurricane_eye_latitude = -1e10
	Initial hurricane-eye latitude. More...
amrex::Real	hurricane_eye_longitude = -1e10
	Initial hurricane-eye longitude. More...
bool	is_init_for_ensemble = false
	Whether initialization is for an ensemble simulation. More...
int	n_ensemble = -1
	Number of ensemble members. More...
amrex::Real	ens_pert_correlated_radius = -1.0
	Spatial correlation radius for ensemble perturbations. More...
amrex::Real	ens_pert_amplitude = -1.0
	Amplitude of ensemble initialization perturbations. More...
std::string	coarse_bckgnd_data_file
	Coarse background data file used for ensemble initialization. More...

Static Public Attributes
static InitType	init_type = InitType::None
	Initial-condition source selected for the run. More...
static SoundingType	sounding_type = SoundingType::Ideal
	Interpretation used for input sounding profiles. More...
static TerrainType	terrain_type = TerrainType::None
	Terrain or immersed-boundary representation. More...
static BuildingsType	buildings_type = BuildingsType::None
	Building representation. More...
static bool	use_real_bcs = false
	Whether real-data lateral boundary conditions are used. More...
static MeshType	mesh_type = MeshType::ConstantDz
	Vertical mesh representation. More...

Detailed Description

Container holding many of the algorithmic options and parameters

Member Function Documentation

any_perturbation()

bool SolverChoice::any_perturbation ( ) const

inline

Query whether any level uses a turbulent perturbation mode.

Returns

True if at least one configured level has source, direct, or CPM perturbations.

    {
        for (const auto& type : pert_type) {
            if (type == PerturbationType::Source ||
                type == PerturbationType::Direct ||
                type == PerturbationType::CPM) {
                return true;
            }
        }
        return false;
    }

build_coriolis_forcings_const_lat()

void SolverChoice::build_coriolis_forcings_const_lat ( std::string  pp_prefix )

inline

Build constant-latitude Coriolis forcing parameters.

Parameters

pp_prefix

ParmParse prefix for the ERF input namespace.

    {
        amrex::ParmParse pp(pp_prefix);
 
        // Read the rotational time period (in seconds)
        double rot_time_period = 86400.0;
        pp.query("rotational_time_period", rot_time_period);
 
        coriolis_factor = static_cast<amrex::Real>(4.0 * PI / rot_time_period);
 
        pp.query("coriolis_3d", coriolis_3d);
 
        // Convert to radians
        amrex::Real latitude_for_coriolis = amrex::Real(90.0);
        pp.query("latitude", latitude_for_coriolis);
        latitude_for_coriolis *= (PI/amrex::Real(180.));
        sinphi = std::sin(latitude_for_coriolis);
 
        // Note: cosphi defaults to 0
        if (coriolis_3d) {
            cosphi = std::cos(latitude_for_coriolis);
        }
 
        amrex::Print() << "Coriolis frequency, f = " << coriolis_factor * sinphi << " 1/s" << std::endl;
 
        if (abl_driver_type == ABLDriverType::GeostrophicWind) {
            // Read in the geostrophic wind -- we only use this to construct
            //     the forcing term so no need to keep it
            amrex::Vector<amrex::Real> abl_geo_wind(3);
            pp.queryarr("abl_geo_wind",abl_geo_wind);
 
            if(!pp.query("abl_geo_wind_table",abl_geo_wind_table)) {
                abl_geo_forcing = {
                    -coriolis_factor * (abl_geo_wind[1]*sinphi - abl_geo_wind[2]*cosphi),
                     coriolis_factor *  abl_geo_wind[0]*sinphi,
                    -coriolis_factor *  abl_geo_wind[0]*cosphi
                };
            } else {
                amrex::Print() << "NOTE: abl_geo_wind_table provided, ignoring input abl_geo_wind" << std::endl;
            }
        }
    }

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, const amrex::Vector< amrex::Geometry > &  geom_vect, amrex::GpuArray< ERF_BC, AMREX_SPACEDIM *2 >  phys_bc_type  )

inline

Validate solver options after geometry and boundary conditions are known.

Parameters

max_level	Maximum AMR level configured for the run.
geom_vect	Geometry for each AMR level.
phys_bc_type	Physical boundary-condition types.

    {
#if 0
        // Warn for PBL models and moisture - these may not yet be compatible
        for (int lev = 0; lev <= max_level; lev++) {
            if ((moisture_type != MoistureType::None) && (turbChoice[lev].pbl_type != PBLType::None)) {
                amrex::Warning("\n*** WARNING: Moisture may not yet be compatible with PBL models, \n    proceed with caution ***");
            }
        }
#endif
        //
        // Buoyancy type check
        //
        for (int lev = 0; lev <= max_level; lev++) {
            if (buoyancy_type[lev] != 1 && buoyancy_type[lev] != 2 && buoyancy_type[lev] != 3 && buoyancy_type[lev] != 4) {
                amrex::Error("buoyancy_type must be 1, 2, 3 or 4");
            }
        }
 
        if (!use_lagged_delta_rt && !(terrain_type == TerrainType::MovingFittedMesh)) {
            amrex::Error("Can't turn off lagged_delta_rt when terrain not moving");
        }
 
        //
        // Wind farm checks
        //
        if (windfarm_type==WindFarmType::SimpleAD and sampling_distance_by_D < zero) {
             amrex::Error("To use simplified actuator disks, you need to provide a variable"
                           " erf.sampling_distance_by_D in the inputs which specifies the upstream"
                           " distance as a factor of the turbine diameter at which the incoming free stream"
                           " velocity will be computed at.");
        }
        if ( (windfarm_type==WindFarmType::SimpleAD ||
              windfarm_type==WindFarmType::GeneralAD ) && turb_disk_angle < zero) {
            amrex::Error("To use simplified actuator disks, you need to provide a variable"
                          " erf.turb_disk_angle_from_x in the inputs which is the angle of the face of the"
                          " turbine disk from the x-axis. A turbine facing an oncoming flow in the x-direction"
                          " will have turb_disk_angle value of 90 deg.");
        }
        if (windfarm_loc_type == WindFarmLocType::lat_lon and (windfarm_x_shift < zero or windfarm_y_shift < zero)) {
            amrex::Error("You are using windfarms with latitude-logitude option to position the turbines."
                         " For this you should provide the inputs erf.windfarm_x_shift and"
                         " erf.windfarm_y_shift which are the values by which the bounding box of the"
                         " windfarm is shifted from the x and the y axes.");
        }
 
 
        if ( (const_massflux_u != 0) && !(geom_vect[0].isPeriodic(0)) ) {
            amrex::Error("Constant mass flux (in x) should be used with periodic boundaries");
        }
 
        if ( (const_massflux_v != 0) && !(geom_vect[0].isPeriodic(1)) ) {
            amrex::Error("Constant mass flux (in y) should be used with periodic boundaries");
        }
 
        // Mesoscale diffusion -- test if LES appropriate with this dx,dy
        for (int lev = 0; lev <= max_level; lev++) {
            if ((geom_vect[lev].CellSize(0) > amrex::Real(2000.)) || (geom_vect[lev].CellSize(1) > amrex::Real(2000.)))
            {
                if ( (turbChoice[lev].les_type == LESType::Smagorinsky) && !turbChoice[lev].smag2d ) {
                    amrex::Warning("Should use 2-D Smagorinsky for mesoscale resolution");
                } else if (turbChoice[lev].les_type == LESType::Deardorff) {
                    amrex::Warning("Should not use Deardorff LES for mesoscale resolution");
                }
            }
        }
 
        // Turn off implicit solve if we have no diffusion
        bool l_use_kturb = turbChoice[0].use_kturb;
        for (int lev = 1; lev <= max_level; lev++) {
            l_use_kturb = (l_use_kturb || turbChoice[lev].use_kturb);
        }
        bool l_use_diff    = ( (diffChoice.molec_diff_type != MolecDiffType::None) || l_use_kturb );
 
        for (int lev = 0; lev <= max_level; lev++) {
            bool l_implicit_diff = (vert_implicit_fac[lev][0] > zero ||
                                    vert_implicit_fac[lev][1] > zero ||
                                    vert_implicit_fac[lev][2] > zero);
            if (l_implicit_diff && !l_use_diff) {
                amrex:: Print() << "No molecular or turbulent diffusion, turning off implicit solve at level " << lev << std::endl;
                vert_implicit_fac[lev][0] = zero;
                vert_implicit_fac[lev][1] = zero;
                vert_implicit_fac[lev][2] = zero;
            }
        }
 
        // Countergradient validation: ensure required implicit diffusion is enabled
        for (int lev = 0; lev <= max_level; lev++) {
            if (turbChoice[lev].enable_mrf_countergradient) {
                AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
                    vert_implicit_fac[lev][0] > zero ||
                    vert_implicit_fac[lev][1] > zero ||
                    vert_implicit_fac[lev][2] > zero,
                    "enable_mrf_countergradient requires vert_implicit_fac > 0");
                AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
                    implicit_thermal_diffusion,
                    "enable_mrf_countergradient requires implicit_thermal_diffusion = true");
                if (moisture_type != MoistureType::None) {
                    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
                        implicit_moisture_diffusion,
                        "enable_mrf_countergradient with moisture requires implicit_moisture_diffusion = true");
                }
            }
        }
 
        for (int lev = 0; lev <= max_level; lev++) {
            turbChoice[lev].check_params(phys_bc_type);
        }
    }

Here is the call graph for this function:

display()

void SolverChoice::display ( int  max_level, std::string  pp_prefix  )

inline

Print the configured solver, physics, and transport options.

Parameters

max_level	Maximum AMR level configured for the run.
pp_prefix	ParmParse prefix used to display nested choices.

    {
        amrex::Print() << "SOLVER CHOICE: " << std::endl;
        for (int lev = 0; lev <= max_level; lev++) {
            amrex::Print() << "At level " << lev << " : " << std::endl;
            if (anelastic[lev]) {
                amrex::Print() << "   anelastic with no substepping" << std::endl;
            } else {
               if (substepping_type[lev] == SubsteppingType::None) {
                   amrex::Print() << "   compressible with no substepping" << std::endl;
               } else if (substepping_type[lev] == SubsteppingType::Implicit) {
                   amrex::Print() << "   compressible with implicit substepping" << std::endl;
               }
           }
           if (fixed_density[lev]) {
               amrex::Print() << "   and fixed density" << std::endl;
           }
        }
 
        for (int lev = 0; lev <= max_level; lev++) {
            amrex::Print() << "vert_implicit_fac at level " << lev << " : "
                           << vert_implicit_fac[lev][0] << " "
                           << vert_implicit_fac[lev][1] << " "
                           << vert_implicit_fac[lev][2];
            if (vert_implicit_fac[lev][0] > zero ||
                vert_implicit_fac[lev][1] > zero ||
                vert_implicit_fac[lev][2] > zero)
            {
                amrex::Print() << " (theta = " << implicit_thermal_diffusion
                               << ", moisture = " << implicit_moisture_diffusion
                               << ", tke = " << implicit_ke_diffusion
                               << ", momenta = " << implicit_momentum_diffusion;
#ifdef ERF_IMPLICIT_W
                amrex::Print() << ", including w";
#endif
                amrex::Print() << ")";
            }
        }
        amrex::Print() << std::endl;
        amrex::Print() << "use_coriolis                : " << use_coriolis << std::endl;
        amrex::Print() << "use_gravity                 : " << use_gravity << std::endl;
 
        if (moisture_type == MoistureType::SAM) {
            amrex::Print() << "Moisture Model: SAM" << std::endl;
        } else if (moisture_type == MoistureType::SAM_NoIce) {
            amrex::Print() << "Moisture Model: SAM No Ice" << std::endl;
        } else if (moisture_type == MoistureType::SAM_NoPrecip_NoIce) {
            amrex::Print() << "Moisture Model: SAM No Precip No Ice" << std::endl;
        } else if (moisture_type == MoistureType::Morrison) {
            amrex::Print() << "Moisture Model: Morrison" << std::endl;
        } else if (moisture_type == MoistureType::Morrison_NoIce) {
            amrex::Print() << "Moisture Model: Morrison_NoIce" << std::endl;
        } else if (moisture_type == MoistureType::WSM6) {
            amrex::Print() << "Moisture Model: WSM6" << std::endl;
        } else if (moisture_type == MoistureType::Kessler) {
            amrex::Print() << "Moisture Model: Kessler" << std::endl;
        } else if (moisture_type == MoistureType::Kessler_NoRain) {
            amrex::Print() << "Moisture Model: Kessler No Rain" << std::endl;
        } else if (moisture_type == MoistureType::SatAdj) {
            amrex::Print() << "Moisture Model: Saturation Adjustment" << std::endl;
        } else if (moisture_type == MoistureType::MoistNoCondensation) {
            amrex::Print() << "Moisture Model: MoistNoCondensation" << std::endl;
        } else {
            amrex::Print() << "Moisture Model: None" << std::endl;
        }
 
        if (terrain_type == TerrainType::StaticFittedMesh) {
            amrex::Print() << "Terrain Type: StaticFittedMesh" << std::endl;
        } else if (terrain_type == TerrainType::MovingFittedMesh) {
            amrex::Print() << "Terrain Type: MovingFittedMesh" << std::endl;
        } else if (terrain_type == TerrainType::EB) {
            amrex::Print() << "Terrain Type: EB" << std::endl;
            ebChoice.display();
        } else if (terrain_type == TerrainType::ImmersedForcing) {
            amrex::Print() << "Terrain Type: ImmersedForcing" << std::endl;
        } else {
            amrex::Print() << "Terrain Type: None" << std::endl;
        }
 
        if (buildings_type == BuildingsType::ImmersedForcing) {
            amrex::Print() << "Buildings Type: ImmersedForcing" << std::endl;
        } else {
            amrex::Print() << "Buildings Type: None" << std::endl;
        }
 
        if (mesh_type == MeshType::ConstantDz) {
            amrex::Print() << "   Mesh Type: ConstantDz" << std::endl;
        } else if (mesh_type == MeshType::StretchedDz) {
            amrex::Print() << "   Mesh Type: StretchedDz" << std::endl;
        } else if (mesh_type == MeshType::VariableDz) {
            amrex::Print() << "   Mesh Type: VariableDz" << std::endl;
        } else {
            amrex::Error("No mesh_type set!");
        }
 
        amrex::Print() << "ABL Driver Type: " << std::endl;
        if (abl_driver_type == ABLDriverType::None) {
            amrex::Print() << "    None" << std::endl;
        } else if (abl_driver_type == ABLDriverType::PressureGradient) {
            amrex::Print() << "    Pressure Gradient "
                           << amrex::RealVect(abl_pressure_grad[0],abl_pressure_grad[1],abl_pressure_grad[2])
                           << std::endl;
        } else if (abl_driver_type == ABLDriverType::GeostrophicWind) {
            amrex::Print() << "    Geostrophic Wind "
                           << amrex::RealVect(abl_geo_forcing[0],abl_geo_forcing[1],abl_geo_forcing[2])
                           << std::endl;
        }
 
        if (max_level > 0) {
            amrex::Print() << "Coupling Type: " << std::endl;
            if (coupling_type == CouplingType::TwoWay) {
                amrex::Print() << "    Two-way" << std::endl;
            } else if (coupling_type == CouplingType::OneWay) {
                amrex::Print() << "    One-way" << std::endl;
            }
        }
 
        if (rad_type == RadiationType::RRTMGP) {
            amrex::Print() << "Radiation Model: RRTMGP" << std::endl;
        } else {
            amrex::Print() << "Radiation Model: None" << std::endl;
        }
 
        amrex::Print() << "Gradp_type                  : " << gradp_type << std::endl;
 
        for (int lev = 0; lev <= max_level; lev++) {
            amrex::Print() << "Buoyancy_type at level " << lev << " : " << buoyancy_type[lev] << std::endl;
        }
 
            advChoice.display(pp_prefix);
           diffChoice.display();
         spongeChoice.display();
        dampingChoice.display();
 
        for (int lev = 0; lev <= max_level; lev++) {
            turbChoice[lev].display(lev);
        }
    }

Here is the call graph for this function:

init_params()

void SolverChoice::init_params ( int  max_level, std::string  pp_prefix  )

inline

Read solver-wide algorithmic options from the input parameter database.

Parameters

max_level	Maximum AMR level configured for the run.
pp_prefix	ParmParse prefix for the ERF input namespace.

    {
        amrex::ParmParse pp(pp_prefix);
 
        bool bogus_bool;
        if (pp.query("use_terrain",bogus_bool) > 0)  {
            amrex::Error("The input use_terrain is deprecated.  Set terrain_type instead.");
        }
 
        if (pp.query("use_moist_background",bogus_bool) > 0)  {
            amrex::Error("The input use_moist_background is deprecated.  Set init_type = MoistBaseState instead.");
        }
 
        // Do we set map scale factors to myhalf instead of 1 for testing?
        pp.query("test_mapfactor", test_mapfactor);
 
        // Which horizontal pressure gradient formulation to use with terrain fitted coords?
        // 0: dp/dx with dp/dz correction (default)
        // 1: gradient of vertically interpolated p, see Klemp 2011
        pp.query("gradp_type", gradp_type);
        AMREX_ALWAYS_ASSERT(gradp_type == 0 || gradp_type == 1);
 
        // For the lateral pressure gradient to be used in the momentum equation, should we
        // take the x- and y-derivatives of the perturbational pressure or the full pressure?
        pp.query("use_pert_pres_gradient", use_pert_pres_gradient);
 
        // What type of moisture model to use?
        moisture_type = MoistureType::None; // Default
        if (pp.query("moisture_type",moisture_type) > 0) {
            amrex::Error("The input moisture_type is deprecated.  Set moisture_model instead.");
        }
 
        pp.query_enum_case_insensitive("moisture_model",moisture_type);
        if (moisture_type == MoistureType::Morrison) {
            moisture_indices = MoistureComponentIndices(
                RhoQ1_comp,  // water vapor
                RhoQ2_comp,  // cloud water
                RhoQ3_comp,  // cloud ice
                RhoQ4_comp,  // rain
                RhoQ5_comp,  // snow
                RhoQ6_comp,  // graupel
                RhoQ7_comp,  // number concentration of cloud water
                RhoQ8_comp,  // number concentration of cloud ice
                RhoQ9_comp,  // number concentration of rain
                RhoQ10_comp,  // number concentration of snow
                RhoQ11_comp  // number concentration of graupel
            );
        } else if ( (moisture_type == MoistureType::WSM6) ||
                    (moisture_type == MoistureType::SAM) ) {
            moisture_indices = MoistureComponentIndices(
                RhoQ1_comp,  // water vapor
                RhoQ2_comp,  // cloud water
                RhoQ3_comp,  // cloud ice
                RhoQ4_comp,  // rain
                RhoQ5_comp,  // snow
                RhoQ6_comp   // graupel
            );
        } else if ( (moisture_type == MoistureType::Morrison_NoIce) ||
                    (moisture_type == MoistureType::SAM_NoIce) ) {
            moisture_indices = MoistureComponentIndices(
                RhoQ1_comp,  // water vapor
                RhoQ2_comp,  // cloud water
                -1,          // cloud ice
                RhoQ4_comp   // rain
            );
        } else if ( (moisture_type == MoistureType::SAM_NoPrecip_NoIce) ||
                    (moisture_type == MoistureType::Kessler_NoRain)     ||
                    (moisture_type == MoistureType::SatAdj)             ||
                    (moisture_type == MoistureType::MoistNoCondensation) ) {
            moisture_indices = MoistureComponentIndices(
                RhoQ1_comp,  // water vapor
                RhoQ2_comp   // cloud water
            );
        } else if (moisture_type == MoistureType::Kessler) {
            moisture_indices = MoistureComponentIndices(
                RhoQ1_comp,  // water vapor
                RhoQ2_comp,  // cloud water
                -1,          // cloud ice
                RhoQ3_comp   // rain
            );
        } else if (moisture_type == MoistureType::SuperDroplets) {
            moisture_indices = MoistureComponentIndices(
                RhoQ1_comp,  // water vapor
                RhoQ2_comp,  // cloud water
                -1,          // cloud ice
                RhoQ3_comp   // rain
            );
        }
 
        // Set a default for dry
        buoyancy_type.resize(max_level+1);
        for (int i = 0; i <= max_level; ++i) {
            buoyancy_type[i] = 1; // uses Rhoprime
        }
 
        // Set a default for moist
        if (moisture_type != MoistureType::None) {
            if ( !(moisture_type == MoistureType::Kessler_NoRain     ||
                   moisture_type == MoistureType::SAM                ||
                   moisture_type == MoistureType::SAM_NoIce          ||
                   moisture_type == MoistureType::SAM_NoPrecip_NoIce ||
                   moisture_type == MoistureType::Morrison ||
                   moisture_type == MoistureType::Morrison_NoIce ||
                   moisture_type == MoistureType::WSM6 ||
                   moisture_type == MoistureType::SatAdj) )
            {
                for (int i = 0; i <= max_level; ++i) {
                    buoyancy_type[i] = 2; // uses Tprime
                }
            }
 
            pp.query("moisture_tight_coupling",moisture_tight_coupling);
        }
 
        // Which expression (1,2/3 or 4) to use for buoyancy
        int default_buoyancy_type = buoyancy_type[0];
        read_int_string(max_level, "buoyancy_type", buoyancy_type, default_buoyancy_type);
 
        // What type of land surface model to use
        lsm_type = LandSurfaceType::None; // Default
        pp.query_enum_case_insensitive("land_surface_model",lsm_type);
 
        read_int_string(max_level, "is_land", is_land, 1);
        for (int lev = 0; lev <= max_level; ++lev) {
            if (is_land[lev] == 1) {
                amrex::Print() << "Level " << lev << " is land" << std::endl;
            } else if (is_land[lev] == 0) {
                amrex::Print() << "Level " << lev << " is water" << std::endl;
            } else {
                amrex::Error("is_land should be 0 or 1");
            }
        }
 
        // What type of radiation model to use
        rad_type = RadiationType::None; // Default
        pp.query_enum_case_insensitive("radiation_model", rad_type);
 
        // Verify that radiation model cannot be RRTMGP if ERF was not compiled with RRTMGP
#ifndef ERF_USE_RRTMGP
        if (rad_type == RadiationType::RRTMGP)
        {
            amrex::Error("ERF was not compiled with RRTMGP enabled!");
        }
#endif
 
        // Is the terrain none, static or moving?
        std::string terrain_type_temp = "";
        pp.query("terrain_type", terrain_type_temp);
        if (terrain_type_temp == "Moving") {
            amrex::Warning("erf.terrain_type = Moving is deprecated; please replace Moving by MovingFittedMesh");
            terrain_type = TerrainType::MovingFittedMesh;
        } else if (terrain_type_temp == "Static") {
            amrex::Warning("erf.terrain_type = Static is deprecated; please replace Static by StaticFittedMesh");
            terrain_type = TerrainType::StaticFittedMesh;
        } else {
            pp.query_enum_case_insensitive("terrain_type",terrain_type);
        }
 
        // Get buildings type
        std::string buildings_type_temp = "";
        pp.query("buildings_type", buildings_type_temp);
        if (buildings_type_temp == "ImmersedForcing") {
            buildings_type = BuildingsType::ImmersedForcing;
        }
 
        //
        // Read the init_type here to make sure we correctly set the mesh and terrain types
        //
        std::string init_type_temp_string;
 
        int found = pp.query("init_type",init_type_temp_string);
 
        if ( (init_type_temp_string == "Real") || (init_type_temp_string == "real") ) {
            amrex::Error("erf.init_type = Real is deprecated; please replace Real by WRFInput");
        } else if ( (init_type_temp_string == "Ideal") || (init_type_temp_string == "ideal") ) {
            amrex::Error("erf.init_type = Ideal is deprecated; please replace Ideal by WRFInput");
        } else {
            pp.query_enum_case_insensitive("init_type",init_type);
            use_real_bcs = ( (init_type == InitType::WRFInput) || (init_type == InitType::Metgrid) );
        }
 
        if ( (init_type == InitType::WRFInput) || (init_type == InitType::Metgrid) ) {
            if (terrain_type != TerrainType::StaticFittedMesh) {
                amrex::Error("Only terrain_type = StaticFittedMesh are allowed with init_type = WRFInput or Metgrid");
            }
        }
 
        if (init_type == InitType::MoistBaseState) {
            if (moisture_type == MoistureType::None) {
                amrex::Error("Makes no sense to have moist base state with no moisture model");
            }
        }
 
        if (init_type == InitType::WRFInput) {
            if (moisture_type == MoistureType::None) {
                amrex::Error("Can't have moisture_type = None with init_type = WRFInput");
            }
 
            // NetCDF wrfbdy lateral boundary file
            std::string nc_bdy_file_temp_string;
            bool has_bdy = pp.query("nc_bdy_file", nc_bdy_file_temp_string);
            if (!has_bdy) use_real_bcs = false;
 
            bool use_real_bcs_temp = use_real_bcs;
            pp.query("use_real_bcs", use_real_bcs_temp);
            if (use_real_bcs && !use_real_bcs_temp) {
                use_real_bcs = false;
            }
        }
 
        if (found == 0 || init_type == InitType::None) {
            amrex::Print() << "init_type must now be set.  The options are " << std::endl;
            amrex::Print() << " Input_Sounding, NCFile, WRFInput, Metgrid, Uniform, " << std::endl;
            amrex::Print() << " ConstantDensity, Isentropic, MoistBaseState, or HindCast " << std::endl;
            amrex::Error("Please add a string for init_type to your inputs file or command line");
        }
 
        // How to interpret input_sounding
        if (init_type == InitType::Input_Sounding) {
            pp.query_enum_case_insensitive("sounding_type",sounding_type);
        }
 
        if (terrain_type == TerrainType::StaticFittedMesh ||
            terrain_type == TerrainType::MovingFittedMesh) {
            mesh_type = MeshType::VariableDz;
        }
 
        if ( (moisture_type == MoistureType::SAM                ||
              moisture_type == MoistureType::SAM_NoIce          ||
              moisture_type == MoistureType::SAM_NoPrecip_NoIce   ) &&
             (mesh_type == MeshType::VariableDz) )
        {
            amrex::Abort("SAM is not correct with variable dz -- choose another moisture model");
        }
 
        pp.query("grid_stretching_ratio", grid_stretching_ratio);
        if (grid_stretching_ratio != 0) {
            AMREX_ASSERT_WITH_MESSAGE((grid_stretching_ratio >= one),
                                      "The grid stretching ratio must be greater than 1");
        }
        if (grid_stretching_ratio >= 1) {
            if (terrain_type == TerrainType::None) {
                terrain_type = TerrainType::StaticFittedMesh;
            }
            if (mesh_type == MeshType::ConstantDz) {
                mesh_type = MeshType::StretchedDz;
            }
            pp.query("zsurface", zsurf);
            if (zsurf != zero) {
                amrex::Print() << "Nominal zsurface height != 0, may result in unexpected behavior"
                    << std::endl;
            }
            pp.get("initial_dz", dz0);
        }
 
        int n_zlevels = pp.countval("terrain_z_levels");
        if (n_zlevels > 0)
        {
            if (terrain_type == TerrainType::None) {
                terrain_type = TerrainType::StaticFittedMesh;
            }
            if (mesh_type == MeshType::ConstantDz) {
                mesh_type = MeshType::StretchedDz;
            }
        }
 
        // Use lagged_delta_rt in the fast integrator?
        pp.query("use_lagged_delta_rt", use_lagged_delta_rt);
 
        // Keep the default wrf grid or remake our own
        pp.query("use_wrf_height_grid",use_wrf_height_grid);
 
        // Rebalance wrf state?
        pp.query("rebalance_wrf_input", rebalance_wrf_input);
 
        // Must rebalance if not using WRF grid
        if (!use_wrf_height_grid && !rebalance_wrf_input) {
            amrex::Print() << "Must rebalance when not using WRF height grid. Setting rebalance_wrf_input to true \n";
            rebalance_wrf_input = true;
        }
 
        // These default to true but are used for unit testing
        pp.query("use_gravity", use_gravity);
 
        // Initializing from Metgrid or WRFInput without gravity makes no sense
        if ( !use_gravity && ( (init_type == InitType::WRFInput) || (init_type == InitType::Metgrid) ) ) {
            amrex::Print() << "Setting use_gravity to true due to init_type = WRFInput / Metgrid " << std::endl;
            use_gravity = true;
        }
 
        gravity = use_gravity? CONST_GRAV: zero;
 
        pp.query("c_p", c_p);
        rdOcp = R_d / c_p;
 
        // *******************************************************************************
        // Read anelastic etc and over-ride if necessary
        // *******************************************************************************
 
        read_int_string(max_level, "anelastic", anelastic, 0);
        read_int_string(max_level, "fixed_density", fixed_density, 0);
        read_int_string(max_level, "project_initial_velocity", project_initial_velocity, 0);
 
        bool any_anelastic = false;
        bool any_compress  = false;
        for (int i = 0; i <= max_level; ++i) {
            if (anelastic[i] == 1) {
                project_initial_velocity[i] = 1;
                fixed_density[i]            = 1; // We default to true but are allowed to override below
                buoyancy_type[i]            = 3; // (This isn't actually used when anelastic is set)
                any_anelastic               = true;
            } else {
                any_compress                = true;
            }
        }
 
        // Want to have different immersed forcing defaults depending on anelastic or fully compressible.
        // We should have different starting values because the stability of the method is dependent on dt.
        // dt is coarser for anelastic --> need to loosen stiffness of immersed forcing.
        if (any_anelastic) {
            immersed_forcing_substep  = false;
            if_Cd_momentum            = amrex::Real(50.0);
            if_Cd_scalar              = amrex::Real(5.0);
        } else {
            immersed_forcing_substep  = true;
            if_Cd_momentum            = amrex::Real(500.0);
            if_Cd_scalar              = amrex::Real(50.0);
        }
 
        // *******************************************************************************
        // Read substepping_type and allow for different values at each level
        // *******************************************************************************
        substepping_type.resize(max_level+1);
 
        for (int i = 0; i <= max_level; i++) {
            substepping_type[i] = SubsteppingType::Implicit;
        }
 
        for (int i = 0; i <= max_level; i++) {
            query_one_or_per_level_enum_case_insensitive(
                pp, "substepping_type", substepping_type[i], i, max_level);
        }
 
        pp.query("substepping_diag", substepping_diag);
 
        pp.query("beta_s", beta_s);
 
 
 
        // *******************************************************************************
        // Error check on deprecated input
        // *******************************************************************************
        int nvals_old = pp.countval("no_substepping");
        if (nvals_old > 0) {
            amrex::Error("The no_substepping flag is deprecated -- set substepping_type instead");
        }
 
        // *******************************************************************************
 
        pp.query("ncorr", ncorr);
        pp.query("poisson_abstol", poisson_abstol);
        pp.query("poisson_reltol", poisson_reltol);
#ifdef AMREX_USE_FLOAT
        poisson_abstol = amrex::max(poisson_abstol,amrex::Real(1e-6));
        poisson_reltol = amrex::max(poisson_reltol,amrex::Real(1e-6));
#endif
        for (int lev = 0; lev <= max_level; lev++) {
            if (anelastic[lev] != 0)
            {
                substepping_type[lev] = SubsteppingType::None;
            }
        }
 
        pp.query("force_stage1_single_substep", force_stage1_single_substep);
 
        // Include Coriolis forcing?
        pp.query("use_coriolis", use_coriolis);
        pp.query("variable_coriolis", variable_coriolis);
 
        // Include four stream radiation approximation
        pp.query("four_stream_radiation", four_stream_radiation);
 
        // flags for whether to apply other source terms in substep only
        pp.query("immersed_forcing_substep", immersed_forcing_substep); // apply immersed forcing source terms in substep only
        pp.query("forest_substep", forest_substep);                     // apply canopy-related source terms in substep only
 
        // immersed forcing parameters
        pp.query("if_Cd_momentum", if_Cd_momentum);
        pp.query("if_Cd_scalar", if_Cd_scalar);
        pp.query("if_implicit_drag", if_implicit_drag); // flag for implicit vs. explicit drag formulation
        pp.query("if_z0", if_z0);
        pp.query("if_surf_temp_flux", if_surf_temp_flux);
        pp.query("if_init_surf_temp", if_init_surf_temp);
 
        pp.query("if_surf_heating_rate", if_surf_heating_rate);
 
        // Modify rate to be in units of K / s rather than K / hr
        if_surf_heating_rate /= amrex::Real(3600.0);        // [K/s]
 
        pp.query("if_Olen", if_Olen_in);
        pp.query("if_use_most",if_use_most);
        pp.query("if_stability_correction",if_stability_correction);
        pp.query("if_ws_floor",if_ws_floor);
        pp.query("if_damp_alpha",if_damp_alpha);
 
        if ((if_init_surf_temp > zero        && if_surf_temp_flux != amrex::Real(1e-8)) ||
            (if_init_surf_temp > zero        && if_Olen_in        != amrex::Real(1e-8)) ||
            (if_Olen_in != amrex::Real(1e-8) && if_surf_temp_flux != amrex::Real(1e-8)))
        {
            amrex::Error("Can only specify one of init_surf_temp, surf_temp_flux, or Olen");
        }
 
        // Flag to do MOST rotations with terrain
        pp.query("use_rotate_surface_flux",use_rotate_surface_flux);
        if (use_rotate_surface_flux) {
            AMREX_ASSERT_WITH_MESSAGE(terrain_type != TerrainType::None,"MOST stress rotations are only valid with terrain!");
        }
 
        // Which external forcings?
        abl_driver_type = ABLDriverType::None; // Default: no ABL driver for simulating classical fluid dynamics problems
        pp.query_enum_case_insensitive("abl_driver_type",abl_driver_type);
        pp.query("const_massflux_u", const_massflux_u);
        pp.query("const_massflux_v", const_massflux_v);
        pp.query("const_massflux_tau", const_massflux_tau);
        pp.query("const_massflux_layer_lo", const_massflux_layer_lo);
        pp.query("const_massflux_layer_hi", const_massflux_layer_hi);
 
        // Which type of inflow turbulent generation
        pert_type.resize(max_level+1);
        for (int lev = 0; lev <= max_level; ++lev) {
            pert_type[lev] = PerturbationType::None; // Default
            query_one_or_per_level_enum_case_insensitive(
                pp, "perturbation_type", pert_type[lev], lev, max_level);
        }
 
        amrex::Vector<amrex::Real> abl_pressure_grad_in = {zero, zero, zero};
        pp.queryarr("abl_pressure_grad",abl_pressure_grad_in);
        for(int i = 0; i < AMREX_SPACEDIM; ++i) abl_pressure_grad[i] = abl_pressure_grad_in[i];
 
        amrex::Vector<amrex::Real> abl_geo_forcing_in = {zero, zero, zero};
        if(pp.queryarr("abl_geo_forcing",abl_geo_forcing_in)) {
            amrex::Print() << "Specified abl_geo_forcing: (";
            for (int i = 0; i < AMREX_SPACEDIM; ++i) {
                abl_geo_forcing[i] = abl_geo_forcing_in[i];
                amrex::Print() << abl_geo_forcing[i] << " ";
            }
            amrex::Print() << ")" << std::endl;
        }
 
        if (use_coriolis)
        {
            build_coriolis_forcings_const_lat(pp_prefix);
        }
 
        pp.query("add_custom_rhotheta_forcing", custom_rhotheta_forcing);
        pp.query("add_custom_moisture_forcing", custom_moisture_forcing);
        pp.query("add_custom_w_subsidence", custom_w_subsidence);
        pp.query("add_do_theta_advection", do_theta_advection);  // If true, apply custom subsidence to (rho*theta) when add_custom_w_subsidence is used
        pp.query("add_do_mom_advection", do_mom_advection);      // If true, apply custom subsidence to momentum when add_custom_w_subsidence is used
        pp.query("add_custom_geostrophic_profile", custom_geostrophic_profile);
        pp.query("custom_forcing_uses_primitive_vars", custom_forcing_prim_vars);
        pp.query("spatial_rhotheta_forcing", spatial_rhotheta_forcing);
        pp.query("spatial_moisture_forcing", spatial_moisture_forcing);
 
        pp.query("nudging_from_input_sounding", nudging_from_input_sounding);
 
        have_geo_wind_profile = (!abl_geo_wind_table.empty() || custom_geostrophic_profile);
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(!(!abl_geo_wind_table.empty() && custom_geostrophic_profile),
            "Should not have both abl_geo_wind_table and custom_geostrophic_profile set.");
 
        pp.query("Ave_Plane", ave_plane);
 
        // Use numerical diffusion?
        pp.query("num_diff_coeff",num_diff_coeff);
        AMREX_ASSERT_WITH_MESSAGE(( (num_diff_coeff >= zero) && (num_diff_coeff <= one) ),
                                  "Numerical diffusion coefficient must be between 0 & one");
        use_num_diff = (num_diff_coeff > 0);
        if (use_num_diff) {
            amrex::Print() << "6th-order numerical diffusion turned on with coefficient = "
                << num_diff_coeff << std::endl;
            num_diff_coeff *= amrex::Math::powi<-6>(two);
        }
 
            advChoice.init_params(pp_prefix);
           diffChoice.init_params(pp_prefix);
        dampingChoice.init_params(pp_prefix);
         spongeChoice.init_params(pp_prefix);
             ebChoice.init_params(pp_prefix);
 
        turbChoice.resize(max_level+1);
        for (int lev = 0; lev <= max_level; lev++) {
            turbChoice[lev].init_params(lev,max_level,pp_prefix);
        }
 
        vert_implicit_fac.resize(max_level+1);
        for (int lev = 0; lev <= max_level; lev++) {
            vert_implicit_fac[lev].resize(3);
            vert_implicit_fac[lev][0] = one;
            vert_implicit_fac[lev][1] = one;
            vert_implicit_fac[lev][2] = zero;
        }
 
        // YSU PBL: use consistent coriolis frequency
        for (int lev = 0; lev <= max_level; lev++) {
            if (turbChoice[lev].pbl_ysu_use_consistent_coriolis) {
                if (use_coriolis) {
                    turbChoice[lev].pbl_ysu_coriolis_freq = coriolis_factor * sinphi;
                    if (lev == 0) {
                        amrex::Print() << "YSU PBL using ERF coriolis frequency: " << turbChoice[lev].pbl_ysu_coriolis_freq << std::endl;
                    }
                } else {
                    amrex::Error("YSU cannot use ERF coriolis frequency if not using coriolis");
                }
            }
        }
        // MRF
        for (int lev = 0; lev <= max_level; lev++) {
            if (turbChoice[lev].pbl_ysu_use_consistent_coriolis) {
                if (use_coriolis) {
                    turbChoice[lev].pbl_ysu_coriolis_freq = coriolis_factor * sinphi;
                    if (lev == 0) {
                        amrex::Print() << "MRF PBL using ERF coriolis frequency: " << turbChoice[lev].pbl_ysu_coriolis_freq << std::endl;
                    }
                } else {
                    amrex::Error("MRF cannot use ERF coriolis frequency if not using coriolis");
                }
            }
        }
 
        // What's the strength of the bdy nudging?
        pp.query("bdy_nudge_factor",bdy_nudge_factor);
 
        // Optionally use the dry-air density reconstructed from wrfbdy.
        pp.query("use_wrf_bdy_density", use_wrf_bdy_density);
        pp.query("bdy_rho_nudge_factor", bdy_rho_nudge_factor);
 
        // Which approach to nudging the moist variables in the boundary region?
        pp.query("bdy_moist_nudge_type",bdy_moist_nudge_type);
 
        // Are me transporting the scalar component?
        pp.query("transport_scalar",transport_scalar);
 
        for (int lev = 0; lev <= max_level; ++lev) {
            if (turbChoice[lev].uses_eamxx_shoc()) {
                use_eamxx_shoc = true;
            }
            if (turbChoice[lev].uses_native_shoc()) {
                use_native_shoc = true;
            }
        }
 
        // Implicit vertical diffusion (not available with SHOC family)
        if (uses_shoc_family()) {
            amrex::Print() << "Turning off native vertical implicit solve at all levels with SHOC family PBL scheme." << std::endl;
            for (int lev = 0; lev <= max_level; lev++) {
               vert_implicit_fac[lev][0] = zero;
               vert_implicit_fac[lev][1] = zero;
               vert_implicit_fac[lev][2] = zero;
            }
        } else {
            // This controls the time-centering of the vertical differences in the diffusive term
            bool do_vert_implicit = true;
            pp.query("vert_implicit", do_vert_implicit);
 
            if (!do_vert_implicit) {
                for (int lev = 0; lev <= max_level; lev++) {
                   amrex::Print() << "Turning off native vertical implicit solve from vert_implicit flag at level " << lev << std::endl;
                   vert_implicit_fac[lev][0] = zero;
                   vert_implicit_fac[lev][1] = zero;
                   vert_implicit_fac[lev][2] = zero;
                }
            } else {
 
                for (int lev = 0; lev <= max_level; lev++) {
                   if (anelastic[lev]) {
                       amrex::Print() << "Turning off native vertical implicit solve flag because anelastic at level " << lev << std::endl;
                       vert_implicit_fac[lev][0] = zero;
                       vert_implicit_fac[lev][1] = zero;
                       vert_implicit_fac[lev][2] = zero;
                    }
                }
 
                // This may be one value for all RK stages or a different value in each stage
                int n_impfac = pp.countval("vert_implicit_fac");
                AMREX_ALWAYS_ASSERT(n_impfac == 0 || n_impfac == 1 || n_impfac==3);
                if (n_impfac > 0 && do_vert_implicit) {
                    amrex::Print() << "Overriding defaults with specified implicit factor(s)" << std::endl;
                }
 
                if (n_impfac == 1) {
                    amrex::Real fac_in;
                    pp.get("vert_implicit_fac", fac_in);
                    for (int lev = 0; lev <= max_level; lev++) {
                        for (int i=0; i<3; ++i) {
                            vert_implicit_fac[lev][i] = fac_in;
                        }
                    }
                } else if (n_impfac == 3) {
                    for (int lev = 0; lev <= max_level; lev++) {
                        pp.getarr("vert_implicit_fac", vert_implicit_fac[lev]);
                    }
                }
 
                // If true (default), include implicit contributions to vertical
                // thermal diffusion
                pp.query("implicit_thermal_diffusion", implicit_thermal_diffusion);
 
                // If true (default), include implicit contributions to vertical
                // moisture diffusion
                pp.query("implicit_moisture_diffusion", implicit_moisture_diffusion);
 
                // If true (default), include implicit contributions to vertical
                // KE diffusion
                pp.query("implicit_ke_diffusion", implicit_ke_diffusion);
 
                // If true (default), include implicit contributions in tau13, tau23,
                // (and if ERF_IMPLICIT_W is set, tau33) to correct u, v, (and w).
                pp.query("implicit_momentum_diffusion", implicit_momentum_diffusion);
 
                // This controls when the vertical implicit solve for the diffusive terms will happen relative to
                //      the acoustic substepping (if it happens, i.e. if any of the implicit_fac > zero)
                // The default is true (i.e. that it happens before the acoustic substepping).
                pp.query("implicit_before_substep", implicit_before_substep);
                for (int lev = 0; lev <= max_level; lev++) {
                    if ( (substepping_type[lev] == SubsteppingType::None) && !implicit_before_substep) {
                        amrex::Print() << "implicit_before_substep cannot be false without substepping; setting to true." << "\n";
                        implicit_before_substep = true;
                    }
                }
 
                // Do not allow implicit vertical diff with EB
 
                if (terrain_type == TerrainType::EB) {
                    for (int lev = 0; lev <= max_level; lev++) {
                        if (do_vert_implicit) {
                            amrex::Print() << "Implicit diffusion is not supported with EB; turning off at level " << lev << "\n";
                            vert_implicit_fac[lev][0] = zero;
                            vert_implicit_fac[lev][1] = zero;
                            vert_implicit_fac[lev][2] = zero;
                        }
                    }
                }
 
                if (!implicit_thermal_diffusion  &&
                    !implicit_moisture_diffusion &&
                    !implicit_ke_diffusion       &&
                    !implicit_momentum_diffusion) {
                    amrex::Print() << "Thermal, moisture, KE, and momentum diffusion are all turned off; turning off vertical implicit solve." << std::endl;
                    for (int lev = 0; lev <= max_level; lev++) {
                        vert_implicit_fac[lev][0] = zero;
                        vert_implicit_fac[lev][1] = zero;
                        vert_implicit_fac[lev][2] = zero;
                    }
                }
            } // do_vert_implicit
        } // uses_shoc_family
 
        // Which type of multilevel coupling
        coupling_type = CouplingType::TwoWay; // Default
        pp.query_enum_case_insensitive("coupling_type",coupling_type);
 
        // Test for hybrid (compressible + anelastic) -- in this case we must use one-way coupling
        if (any_anelastic && any_compress) {
            coupling_type = CouplingType::OneWay;
        }
 
        // Which type of windfarm model
        windfarm_type = WindFarmType::None; // Default
        pp.query_enum_case_insensitive("windfarm_type",windfarm_type);
 
        windfarm_loc_type = WindFarmLocType::None;
        pp.query_enum_case_insensitive("windfarm_loc_type",windfarm_loc_type);
 
        pp.query("windfarm_loc_table",  windfarm_loc_table);
        pp.query("windfarm_spec_table", windfarm_spec_table);
        pp.query("windfarm_blade_table", windfarm_blade_table);
        pp.query("windfarm_airfoil_tables", windfarm_airfoil_tables);
        pp.query("windfarm_spec_table_extra", windfarm_spec_table_extra);
 
        // Sampling distance upstream of the turbine to find the
        // incoming free stream velocity as a factor of the diameter of the
        // turbine. ie. the sampling distance will be this number multiplied
        // by the diameter of the turbine
        pp.query("sampling_distance_by_D", sampling_distance_by_D);
        pp.query("turb_disk_angle_from_x", turb_disk_angle);
 
        pp.query("windfarm_x_shift",windfarm_x_shift);
        pp.query("windfarm_y_shift",windfarm_y_shift);
        // Test if time averaged data is to be output
        pp.query("time_avg_vel",time_avg_vel);
 
        pp.query("hindcast_lateral_forcing", hindcast_lateral_forcing);
 
        if (hindcast_lateral_forcing) {
            pp.query("hindcast_boundary_data_dir", hindcast_boundary_data_dir);
 
            if(hindcast_boundary_data_dir.empty()) {
                amrex::Error("ERROR: Missing input parameter 'erf.hindcast_boundary_data_dir' for boundary data for lateral forcing");
            }
            pp.query("hindcast_data_interval_in_hrs", hindcast_data_interval_in_hrs);
            if(hindcast_data_interval_in_hrs < zero) {
                amrex::Error("ERROR: Input parameter 'erf.hindcast_data_interval_in_hrs' which is the time interval between the "
                             "data files is either missing or set to less than zero");
            }
            pp.query("hindcast_lateral_sponge_strength", hindcast_lateral_sponge_strength);
            pp.query("hindcast_lateral_sponge_length", hindcast_lateral_sponge_length);
 
            pp.query("hindcast_zhi_sponge_length", hindcast_zhi_sponge_length);
            pp.query("hindcast_zhi_sponge_strength", hindcast_zhi_sponge_strength);
 
            pp.query("hindcast_zhi_sponge_damping", hindcast_zhi_sponge_damping);
 
            if (hindcast_lateral_forcing and hindcast_lateral_sponge_strength < zero) {
                amrex::Error("ERROR: Missing input parameter 'erf.hindcast_lateral_sponge_strength' or it is specified to be less than zero");
            }
 
            if (hindcast_lateral_forcing and hindcast_lateral_sponge_length < zero) {
                amrex::Error("ERROR: Missing input parameter 'erf.hindcast_lateral_sponge_length' or it is specified to be less than zero");
            }
 
            if (hindcast_zhi_sponge_damping and hindcast_zhi_sponge_length < zero) {
                amrex::Error("ERROR: Missing input parameter 'erf.hindcast_zhi_sponge_length' or it is specified to be less than zero");
            }
 
            if (hindcast_zhi_sponge_damping and hindcast_zhi_sponge_strength < zero) {
                amrex::Error("ERROR: Missing input parameter 'erf.hindcast_zhi_sponge_strength' or it is specified to be less than zero");
            }
        }
 
        pp.query("hindcast_surface_bcs", hindcast_surface_bcs);
        if(hindcast_surface_bcs) {
            pp.query("hindcast_surface_data_dir", hindcast_surface_data_dir);
        }
 
        pp.query("io_hurricane_eye_tracker", io_hurricane_eye_tracker);
        if (io_hurricane_eye_tracker) {
            pp.query("hurricane_eye_latitude", hurricane_eye_latitude);
            pp.query("hurricane_eye_longitude", hurricane_eye_longitude);
            if(hurricane_eye_latitude == amrex::Real(-1e10) or hurricane_eye_longitude == amrex::Real(-1e10)) {
                amrex::Error("ERROR: You are using 'erf.io_hurricane_eye_tracker' to write out the files that track the eye of the hurricane"
                              " but have not provided the initial location of the eye of the hurricane to be tracked. There has to be two"
                              " options in the inputs - erf.hurricane_eye_latitude and erf.hurricane_eye_longitude that gives an approximate"
                              " location of the eye in the initial condition");
            }
        }
 
        pp.query("is_init_for_ensemble", is_init_for_ensemble);
        if(is_init_for_ensemble) {
            amrex::ParmParse pp_ens("ensemble");
            pp_ens.query("n_members", n_ensemble);
            if(n_ensemble < 2) {
                amrex::Abort("You are using an ensemble run. There needs to be at least 2 ensemble members. "
                             "erf.n_ensemble must be >=2.");
            }
            pp_ens.query("coarse_bckgnd_data_file", coarse_bckgnd_data_file);
            if (coarse_bckgnd_data_file.empty()) {
                amrex::Abort("coarse_bckgnd_data_file is empty! For ensmeble simulations, there needs to be a coarse background file which "
                             "contains the data which will be interpolated onto the fine mesh. There has to a entry ensemble.coarse_bckgnd_data_file "
                             "which contains the filename in the inputs.");
            }
            pp_ens.query("ens_pert_amplitude", ens_pert_amplitude);
            if(ens_pert_amplitude <= 0.0) {
                amrex::Error("You are using initialization for ensemble simulations using the inputs option "
                             "ensemble.is_init_for_ensemble=true. In this case, there has to be an option "
                             "ensemble.ens_pert_amplitude which is the value of the amplitude of the perturbation  "
                             "to be added to the background state and has to be greater than 0.0");
            }
            pp_ens.query("ens_pert_correlated_radius", ens_pert_correlated_radius);
            if(ens_pert_correlated_radius <= 0.0) {
                amrex::Error("You are using initialization with spatially correlated perturbations using the inputs option "
                             "ensemble.is_init_for_ensemble=true. In this case, there has to be an option "
                             "ensemble.ens_pert_correlated_radius which is the value of the the spatial correlation radius, "
                             "and has to be greater than 0.0");
            }
        }
    }

Here is the call graph for this function:

pbl_suppresses_microphysics_condensation()

bool SolverChoice::pbl_suppresses_microphysics_condensation ( ) const

inlinenoexcept

Query whether the active PBL scheme suppresses microphysics condensation.

Returns

True when the active PBL scheme owns condensation handling.

    {
        return uses_shoc_family();
    }

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

Read one integer value or one value per AMR level.

Parameters

max_level	Maximum AMR level configured for the run.
string_to_read	ParmParse key to read.
vec_to_fill	Destination vector with one entry per level.
default_int	Default value used when the key is absent.

    {
        amrex::ParmParse pp("erf");
        int nvals = pp.countval(string_to_read);
        AMREX_ALWAYS_ASSERT(nvals == 0 || nvals == 1 || nvals >= max_level+1);
        amrex::Vector<int> temp; temp.resize(nvals);
        pp.queryarr(string_to_read,temp);
 
        if (vec_to_fill.size() < max_level+1) {
            vec_to_fill.resize(max_level+1);
        }
 
        if (nvals == 0) {
            for (int i = 0; i <= max_level; ++i) vec_to_fill[i] = default_int;
        } else if (nvals == 1) {
            for (int i = 0; i <= max_level; ++i) vec_to_fill[i] = temp[0];
        } else {
            for (int i = 0; i <= max_level; ++i) vec_to_fill[i] = temp[i];
        }
    }

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

Override the globally selected mesh type.

Parameters

new_mesh_type

Mesh type to store.

    {
        mesh_type = new_mesh_type;
    }

Referenced by ERF::check_mesh_type(), and ProblemBase::init_custom_terrain().

Here is the caller graph for this function:

use_direct_perturbation()

bool SolverChoice::use_direct_perturbation ( int  lev ) const

inline

Query whether direct turbulent perturbations are enabled on a level.

Parameters

lev	AMR level index.

Returns

True if direct, CPM, or CPM_W perturbations are enabled.

    {
        return pert_type[lev] == PerturbationType::Direct ||
               pert_type[lev] == PerturbationType::CPM ||
               pert_type[lev] == PerturbationType::CPM_W;
    }

use_perturbation()

bool SolverChoice::use_perturbation ( int  lev ) const

inline

Query whether any turbulent perturbation mode is enabled on a level.

Parameters

lev	AMR level index.

Returns

True if source, direct, CPM, or CPM_W perturbations are enabled.

    {
        return pert_type[lev] == PerturbationType::Source ||
               pert_type[lev] == PerturbationType::Direct ||
               pert_type[lev] == PerturbationType::CPM ||
               pert_type[lev] == PerturbationType::CPM_W;
    }

use_source_perturbation()

bool SolverChoice::use_source_perturbation ( int  lev ) const

inline

Query whether source-term turbulent perturbations are enabled on a level.

Parameters

lev	AMR level index.

Returns

True if source perturbations are enabled.

    {
        return pert_type[lev] == PerturbationType::Source;
    }

Referenced by make_sources().

Here is the caller graph for this function:

use_wvel_perturbation()

bool SolverChoice::use_wvel_perturbation ( int  lev ) const

inline

Query whether vertical-velocity CPM perturbations are enabled on a level.

Parameters

lev	AMR level index.

Returns

True if CPM_W perturbations are enabled.

    {
        return pert_type[lev] == PerturbationType::CPM_W;
    }

uses_shoc_family()

bool SolverChoice::uses_shoc_family ( ) const

inlinenoexcept

Query whether any SHOC-family PBL scheme is active.

Returns

True if native or EAMxx SHOC is active.

    {
        return use_eamxx_shoc || use_native_shoc;
    }

Referenced by Kessler::Define(), Morrison::Define(), SAM::Define(), SatAdj::Define(), WSM6::Define(), init_params(), and pbl_suppresses_microphysics_condensation().

Here is the caller graph for this function:

Member Data Documentation

abl_driver_type

SolverChoice::abl_driver_type

Atmospheric boundary-layer driver type.

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

abl_geo_forcing

SolverChoice::abl_geo_forcing

Applied geostrophic-wind forcing vector.

Referenced by build_coriolis_forcings_const_lat(), display(), init_params(), and make_mom_sources().

abl_geo_wind_table

SolverChoice::abl_geo_wind_table

Path to a time-varying geostrophic wind table.

Referenced by build_coriolis_forcings_const_lat(), and init_params().

abl_pressure_grad

SolverChoice::abl_pressure_grad

Applied ABL pressure-gradient forcing vector.

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

advChoice

SolverChoice::advChoice

Advection-related options.

Referenced by ERF::ComputeGhostCells(), display(), erf_slow_rhs_post(), erf_slow_rhs_pre(), and init_params().

anelastic

SolverChoice::anelastic

Per-level flag selecting anelastic dynamics.

Referenced by display(), ERF::ERF_shared(), erf_slow_rhs_post(), erf_slow_rhs_pre(), init_params(), and make_gradp_pert().

ave_plane

SolverChoice::ave_plane {2}

Averaging plane index used by diagnostics.

Referenced by SAM::Define(), WSM6::Define(), init_params(), make_mom_sources(), and make_sources().

bdy_moist_nudge_type

SolverChoice::bdy_moist_nudge_type = 0

Moist-variable nudging strategy in boundary regions.

Referenced by init_params().

bdy_nudge_factor

SolverChoice::bdy_nudge_factor = amrex::Real(10.0)

Boundary sponge nudging factor.

Referenced by init_params().

bdy_rho_nudge_factor

amrex::Real SolverChoice::bdy_rho_nudge_factor = amrex::Real(-1.0)

Referenced by init_params().

beta_s

SolverChoice::beta_s = amrex::Real(0.1)

Time off-centering coefficient for forward weighting.

Referenced by init_params().

buildings_type

SolverChoice::buildings_type = BuildingsType::None

inlinestatic

Building representation.

Referenced by display(), ERF::ERF_shared(), init_params(), make_mom_sources(), and make_sources().

buoyancy_type

SolverChoice::buoyancy_type

Per-level buoyancy formulation selector.

Referenced by check_params(), display(), init_params(), and make_buoyancy().

c_p

SolverChoice::c_p = Cp_d

Specific heat at constant pressure for dry air [J/(kg-K)].

Referenced by Kessler::Define(), SAM::Define(), SatAdj::Define(), and init_params().

coarse_bckgnd_data_file

SolverChoice::coarse_bckgnd_data_file

Coarse background data file used for ensemble initialization.

Referenced by init_params().

const_massflux_layer_hi

SolverChoice::const_massflux_layer_hi = amrex::Real( bogus_large_value)

Upper height of the constant-mass-flux forcing layer.

Referenced by ERF::ERF_shared(), and init_params().

const_massflux_layer_lo

SolverChoice::const_massflux_layer_lo = amrex::Real(-bogus_large_value)

Lower height of the constant-mass-flux forcing layer.

Referenced by ERF::ERF_shared(), and init_params().

const_massflux_tau

SolverChoice::const_massflux_tau = one

Relaxation time scale for constant-mass-flux forcing.

Referenced by init_params(), and make_mom_sources().

const_massflux_u

SolverChoice::const_massflux_u = zero

Target constant mass flux in the x direction.

Referenced by check_params(), ERF::ERF_shared(), init_params(), and make_mom_sources().

const_massflux_v

SolverChoice::const_massflux_v = zero

Target constant mass flux in the y direction.

Referenced by check_params(), ERF::ERF_shared(), init_params(), and make_mom_sources().

coriolis_3d

SolverChoice::coriolis_3d = true

Whether the three-dimensional Coriolis terms are included.

Referenced by build_coriolis_forcings_const_lat().

coriolis_factor

SolverChoice::coriolis_factor = zero

Twice the planetary rotation rate used for Coriolis forcing.

Referenced by build_coriolis_forcings_const_lat(), init_params(), and make_mom_sources().

cosphi

SolverChoice::cosphi = zero

Cosine of the latitude used for Coriolis forcing.

Referenced by build_coriolis_forcings_const_lat(), and make_mom_sources().

coupling_type

SolverChoice::coupling_type

Multilevel coupling strategy.

Referenced by display(), erf_slow_rhs_post(), erf_slow_rhs_pre(), and init_params().

custom_forcing_prim_vars

SolverChoice::custom_forcing_prim_vars = false

Whether custom forcing operates on primitive variables.

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

custom_geostrophic_profile

SolverChoice::custom_geostrophic_profile = false

Whether a custom geostrophic wind profile is used.

Referenced by init_params().

custom_moisture_forcing

SolverChoice::custom_moisture_forcing = false

Whether custom moisture forcing is enabled.

Referenced by init_params(), and make_sources().

custom_rhotheta_forcing

SolverChoice::custom_rhotheta_forcing = false

Whether custom rho-theta forcing is enabled.

Referenced by init_params(), and make_sources().

custom_w_subsidence

SolverChoice::custom_w_subsidence = false

Whether custom vertical subsidence is enabled.

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

dampingChoice

SolverChoice::dampingChoice

Damping-related options.

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

diffChoice

SolverChoice::diffChoice

Diffusion-related options.

Referenced by check_params(), DiffusionSrcForMom_EB(), display(), erf_make_tau_terms(), erf_slow_rhs_post(), erf_slow_rhs_pre(), ImplicitDiffForMomLU_N(), ImplicitDiffForMomLU_S(), ImplicitDiffForMomLU_T(), and init_params().

do_forest_drag

SolverChoice::do_forest_drag {false}

Whether forest canopy drag is enabled.

Referenced by make_mom_sources().

do_mom_advection

SolverChoice::do_mom_advection = true

Whether custom vertical subsidence is applied to momentum.

Referenced by init_params(), and make_mom_sources().

do_theta_advection

SolverChoice::do_theta_advection = true

Whether custom vertical subsidence is applied to rho-theta.

Referenced by init_params(), and make_sources().

dz0

SolverChoice::dz0

Initial vertical grid spacing for stretched-grid setup.

Referenced by ERF::ERF_shared(), and init_params().

ebChoice

SolverChoice::ebChoice

Embedded-boundary options.

Referenced by DiffusionSrcForMom_EB(), DiffusionSrcForState_EB(), display(), erf_slow_rhs_pre(), and init_params().

ens_pert_amplitude

SolverChoice::ens_pert_amplitude = -1.0

Amplitude of ensemble initialization perturbations.

Referenced by init_params().

ens_pert_correlated_radius

SolverChoice::ens_pert_correlated_radius = -1.0

Spatial correlation radius for ensemble perturbations.

Referenced by init_params().

fixed_density

SolverChoice::fixed_density

Per-level flag selecting fixed-density treatment.

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

force_stage1_single_substep

SolverChoice::force_stage1_single_substep = 1

Flag forcing a single substep in the first RK stage.

Referenced by init_params().

forest_substep

SolverChoice::forest_substep = false

Whether canopy source terms are applied only during substeps.

Referenced by init_params(), and make_mom_sources().

four_stream_radiation

SolverChoice::four_stream_radiation = false

Whether the four-stream radiation approximation is enabled.

Referenced by init_params(), and make_sources().

gradp_type

SolverChoice::gradp_type = 0

Terrain-fitted horizontal pressure-gradient formulation.

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

gravity

SolverChoice::gravity

Effective gravitational acceleration.

Referenced by ComputeTurbulentViscosity(), erf_slow_rhs_post(), erf_slow_rhs_pre(), init_params(), and make_buoyancy().

grid_stretching_ratio

SolverChoice::grid_stretching_ratio = 0

Vertical grid stretching ratio.

Referenced by ERF::ERF_shared(), and init_params().

have_geo_wind_profile

SolverChoice::have_geo_wind_profile {false}

Whether a geostrophic wind profile has been configured.

Referenced by init_params(), and make_mom_sources().

hindcast_boundary_data_dir

SolverChoice::hindcast_boundary_data_dir

Directory containing hindcast lateral boundary data.

Referenced by init_params().

hindcast_data_interval_in_hrs

SolverChoice::hindcast_data_interval_in_hrs = -one

Time interval between hindcast data files [hr].

Referenced by init_params().

hindcast_lateral_forcing

SolverChoice::hindcast_lateral_forcing = false

Whether hindcast lateral forcing is enabled.

Referenced by init_params(), and make_mom_sources().

hindcast_lateral_sponge_length

SolverChoice::hindcast_lateral_sponge_length = -one

Length of the hindcast lateral sponge layer.

Referenced by ApplyBndryForcing_Forecast(), and init_params().

hindcast_lateral_sponge_strength

SolverChoice::hindcast_lateral_sponge_strength = -one

Strength of the hindcast lateral sponge layer.

Referenced by ApplyBndryForcing_Forecast(), and init_params().

hindcast_surface_bcs

SolverChoice::hindcast_surface_bcs = false

Whether hindcast surface boundary conditions are enabled.

Referenced by init_params().

hindcast_surface_data_dir

SolverChoice::hindcast_surface_data_dir

Directory containing hindcast surface boundary data.

Referenced by init_params().

hindcast_zhi_sponge_damping

SolverChoice::hindcast_zhi_sponge_damping = false

Whether upper-boundary hindcast sponge damping is enabled.

Referenced by ApplyBndryForcing_Forecast(), and init_params().

hindcast_zhi_sponge_length

SolverChoice::hindcast_zhi_sponge_length = -one

Length of the upper hindcast sponge layer.

Referenced by ApplyBndryForcing_Forecast(), and init_params().

hindcast_zhi_sponge_strength

SolverChoice::hindcast_zhi_sponge_strength = -one

Strength of the upper hindcast sponge layer.

Referenced by ApplyBndryForcing_Forecast(), and init_params().

hurricane_eye_latitude

SolverChoice::hurricane_eye_latitude = -1e10

Initial hurricane-eye latitude.

Referenced by ERF::HurricaneEyeTracker(), and init_params().

hurricane_eye_longitude

SolverChoice::hurricane_eye_longitude = -1e10

Initial hurricane-eye longitude.

Referenced by ERF::HurricaneEyeTracker(), and init_params().

if_Cd_momentum

SolverChoice::if_Cd_momentum = amrex::Real(50.0)

Immersed-forcing drag coefficient for momentum.

Referenced by init_params(), and make_mom_sources().

if_Cd_scalar

SolverChoice::if_Cd_scalar = amrex::Real(10.0)

Immersed-forcing drag coefficient for scalars.

Referenced by init_params(), and make_sources().

if_damp_alpha

SolverChoice::if_damp_alpha = 0.5

Immersed-forcing damping coefficient.

Referenced by init_params(), and make_mom_sources().

if_implicit_drag

bool SolverChoice::if_implicit_drag = false

Referenced by init_params(), and make_mom_sources().

if_init_surf_temp

SolverChoice::if_init_surf_temp = zero

Initial immersed-forcing surface temperature [K].

Referenced by init_params(), and make_sources().

if_Olen_in

SolverChoice::if_Olen_in = amrex::Real(1e-8)

Input Obukhov length for immersed-forcing MOST [m].

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

if_stability_correction

SolverChoice::if_stability_correction = false

Whether immersed-forcing stability corrections are enabled.

Referenced by init_params(), and make_mom_sources().

if_surf_heating_rate

SolverChoice::if_surf_heating_rate = zero

Immersed-forcing surface heating rate [K/hr].

Referenced by init_params(), and make_sources().

if_surf_temp_flux

SolverChoice::if_surf_temp_flux = amrex::Real(1e-8)

Immersed-forcing surface temperature flux [K m/s].

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

if_use_most

SolverChoice::if_use_most = false

Whether immersed-forcing MOST is enabled.

Referenced by init_params(), and make_mom_sources().

if_ws_floor

SolverChoice::if_ws_floor = 0.001

Wind-speed floor for immersed-forcing MOST [m/s].

Referenced by init_params(), and make_mom_sources().

if_z0

SolverChoice::if_z0 = amrex::Real(0.1)

Immersed-forcing roughness length [m].

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

immersed_forcing_substep

SolverChoice::immersed_forcing_substep = false

Whether immersed-forcing source terms are applied only during substeps.

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

implicit_before_substep

SolverChoice::implicit_before_substep = true

Whether implicit diffusion is applied before acoustic substepping.

Referenced by init_params().

implicit_ke_diffusion

SolverChoice::implicit_ke_diffusion = true

Whether implicit vertical TKE diffusion is included.

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

implicit_moisture_diffusion

SolverChoice::implicit_moisture_diffusion = true

Whether implicit vertical moisture diffusion is included.

Referenced by check_params(), display(), erf_slow_rhs_post(), and init_params().

implicit_momentum_diffusion

SolverChoice::implicit_momentum_diffusion = true

Whether implicit vertical momentum diffusion is included.

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

implicit_thermal_diffusion

SolverChoice::implicit_thermal_diffusion = true

Whether implicit vertical thermal diffusion is included.

Referenced by check_params(), display(), erf_slow_rhs_pre(), and init_params().

init_type

SolverChoice::init_type = InitType::None

inlinestatic

Initial-condition source selected for the run.

Referenced by ERF::ComputeGlobalMinLocation(), ERF::HurricaneEyeTrackerInitial(), init_params(), and make_mom_sources().

io_hurricane_eye_tracker

SolverChoice::io_hurricane_eye_tracker = false

Whether hurricane-eye tracking output is enabled.

Referenced by init_params().

is_init_for_ensemble

SolverChoice::is_init_for_ensemble = false

Whether initialization is for an ensemble simulation.

Referenced by init_params().

is_land

SolverChoice::is_land

Per-level land/water selector.

Referenced by init_params().

lsm_type

SolverChoice::lsm_type

Land-surface model.

Referenced by ERF::ApplyOceanSurfaceState(), init_params(), and Radiation::Radiation().

massflux_khi

SolverChoice::massflux_khi {0}

Upper vertical index for constant-mass-flux forcing.

Referenced by ERF::ERF_shared(), and make_mom_sources().

massflux_klo

SolverChoice::massflux_klo {0}

Lower vertical index for constant-mass-flux forcing.

Referenced by ERF::ERF_shared(), and make_mom_sources().

mesh_type

SolverChoice::mesh_type = MeshType::ConstantDz

inlinestatic

Vertical mesh representation.

Referenced by ERF::AverageDownTo(), ERF::check_mesh_type(), ERF::compute_divergence(), compute_gradp_interpz(), compute_gradp_xy(), compute_gradp_z(), display(), erf_make_tau_terms(), ERF::ERF_shared(), erf_slow_rhs_post(), erf_slow_rhs_pre(), plotfile2d::fill_condensed_water_paths(), ProblemBase::init_custom_terrain(), init_params(), ERF::init_zphys(), ERF::InitData_post(), make_mom_sources(), ERF::make_physbcs(), make_sources(), ERF::MakeNewLevelFromCoarse(), ERF::post_timestep(), ERF::read_box_for_refinement(), ERF::ReadCheckpointFile(), ERF::RemakeLevel(), set_mesh_type(), ERF::sum_derived_quantities(), ERF::sum_energy_quantities(), ERF::update_terrain_arrays(), ERF::volWgtColumnSum(), ERF::volWgtSumMF(), ERF::Write3DPlotFile(), ERF::WriteCheckpointFile(), and writeNCPlotFile().

moisture_indices

SolverChoice::moisture_indices

Conserved-state component indices for active moisture species.

Referenced by plotfile2d::active_condensed_water_path_descriptors(), plotfile2d::available_diagnostic_names(), ComputeTurbulentViscosity(), init_params(), ERF::PackAtmosphericStates(), Radiation::Radiation(), and plotfile2d::selected_condensed_water_path_components().

moisture_tight_coupling

SolverChoice::moisture_tight_coupling {false}

Whether moisture updates use tight coupling.

Referenced by init_params().

moisture_type

SolverChoice::moisture_type

Moisture or microphysics model.

Referenced by Morrison::Advance(), Kessler::AdvanceKessler(), plotfile2d::available_diagnostic_names(), check_params(), SAM::Cloud(), Kessler::Define(), Morrison::Define(), SAM::Define(), WSM6::Define(), display(), ERF::ERF_shared(), erf_slow_rhs_post(), erf_slow_rhs_pre(), ERF::HurricaneEyeTracker(), SAM::IceFall(), init_params(), make_buoyancy(), make_gradp_pert(), make_sources(), ERF::PackAtmosphericStates(), SAM::Precip(), SAM::PrecipFall(), and Radiation::Radiation().

n_ensemble

SolverChoice::n_ensemble = -1

Number of ensemble members.

Referenced by init_params().

ncorr

SolverChoice::ncorr = 1

Number of projection correction iterations.

Referenced by init_params().

nudging_from_input_sounding

SolverChoice::nudging_from_input_sounding = false

Whether solution fields are nudged toward input sounding data.

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

num_diff_coeff

SolverChoice::num_diff_coeff {zero}

Numerical diffusion coefficient after input scaling.

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

pert_type

SolverChoice::pert_type

Turbulent perturbation type for each AMR level.

Referenced by any_perturbation(), init_params(), use_direct_perturbation(), use_perturbation(), use_source_perturbation(), and use_wvel_perturbation().

poisson_abstol

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

Absolute tolerance for the Poisson solve.

Referenced by init_params().

poisson_reltol

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

Relative tolerance for the Poisson solve.

Referenced by init_params().

project_initial_velocity

SolverChoice::project_initial_velocity

Per-level flag for projecting the initial velocity.

Referenced by ERF::ERF_shared(), and init_params().

rad_type

SolverChoice::rad_type

Radiation model.

Referenced by display(), ERF::ERF_shared(), init_params(), and make_sources().

rdOcp

SolverChoice::rdOcp

Ratio of dry-air gas constant to c_p.

Referenced by Morrison::Define(), SAM::Define(), SatAdj::Define(), erf_slow_rhs_post(), erf_slow_rhs_pre(), init_params(), and make_buoyancy().

rebalance_wrf_input

SolverChoice::rebalance_wrf_input = true

Whether to rebalance states from wrfinput and wrfbdy data.

Referenced by init_params().

sampling_distance_by_D

SolverChoice::sampling_distance_by_D = -one

Turbine inflow sampling distance normalized by rotor diameter.

Referenced by check_params(), and init_params().

sinphi

SolverChoice::sinphi = zero

Sine of the latitude used for Coriolis forcing.

Referenced by build_coriolis_forcings_const_lat(), init_params(), and make_mom_sources().

sounding_type

SolverChoice::sounding_type = SoundingType::Ideal

inlinestatic

Interpretation used for input sounding profiles.

Referenced by init_params().

spatial_moisture_forcing

SolverChoice::spatial_moisture_forcing = false

Whether spatially varying moisture forcing is enabled.

Referenced by init_params(), and make_sources().

spatial_rhotheta_forcing

SolverChoice::spatial_rhotheta_forcing = false

Whether spatially varying rho-theta forcing is enabled.

Referenced by init_params(), and make_sources().

spongeChoice

SolverChoice::spongeChoice

Sponge-layer options.

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

substepping_diag

SolverChoice::substepping_diag = false

Whether to emit extra CFL diagnostics for compressible substepping.

Referenced by init_params().

substepping_type

SolverChoice::substepping_type

Acoustic substepping type for each AMR level.

Referenced by display(), and init_params().

terrain_type

SolverChoice::terrain_type = TerrainType::None

inlinestatic

Terrain or immersed-boundary representation.

Referenced by ERF::AverageDownTo(), check_params(), compute_gradp_xy(), compute_gradp_z(), ERF::ComputeGhostCells(), ComputeTurbulentViscosity(), display(), erf_make_tau_terms(), ERF::ERF_shared(), erf_slow_rhs_post(), erf_slow_rhs_pre(), ERF::ErrorEst(), init_params(), ERF::InitData_post(), make_buoyancy(), make_gradp_pert(), make_mom_sources(), make_sources(), ERF::setPlotVariables(), ERF::setSubVolVariables(), ERF::update_diffusive_arrays(), ERF::update_terrain_arrays(), and ERF::volWgtSumMF().

test_mapfactor

SolverChoice::test_mapfactor = false

Whether to use test map scale factors.

Referenced by init_params().

time_avg_vel

SolverChoice::time_avg_vel = false

Whether time-averaged velocity fields are output.

Referenced by init_params().

transport_scalar

SolverChoice::transport_scalar = true

Whether the passive scalar component is transported.

Referenced by erf_slow_rhs_post(), and init_params().

turb_disk_angle

SolverChoice::turb_disk_angle = -one

Turbine disk angle from the x axis [deg].

Referenced by check_params(), and init_params().

turbChoice

SolverChoice::turbChoice

Turbulence options for each AMR level.

Referenced by check_params(), ComputeTurbulentViscosity(), display(), erf_make_tau_terms(), ERF::ERF_shared(), erf_slow_rhs_post(), erf_slow_rhs_pre(), ImplicitDiffForMomLU_N(), ImplicitDiffForMomLU_S(), ImplicitDiffForMomLU_T(), init_params(), and make_sources().

use_coriolis

SolverChoice::use_coriolis = false

Whether Coriolis forcing is enabled.

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

use_eamxx_shoc

SolverChoice::use_eamxx_shoc = false

Whether any level uses the EAMxx SHOC PBL scheme.

Referenced by init_params(), and uses_shoc_family().

use_gravity

SolverChoice::use_gravity = false

Whether gravitational forcing is enabled.

Referenced by display(), and init_params().

use_lagged_delta_rt

SolverChoice::use_lagged_delta_rt = true

Whether to use lagged delta terms for moving terrain.

Referenced by check_params(), and init_params().

use_native_shoc

SolverChoice::use_native_shoc = false

Whether any level uses the native SHOC PBL scheme.

Referenced by init_params(), and uses_shoc_family().

use_num_diff

SolverChoice::use_num_diff {false}

Whether sixth-order numerical diffusion is enabled.

Referenced by ERF::ComputeGhostCells(), init_params(), and make_sources().

use_pert_pres_gradient

SolverChoice::use_pert_pres_gradient = true

Whether momentum equations use perturbational pressure gradients.

Referenced by init_params(), and make_gradp_pert().

use_real_bcs

SolverChoice::use_real_bcs = false

inlinestatic

Whether real-data lateral boundary conditions are used.

Referenced by init_params().

use_rotate_surface_flux

SolverChoice::use_rotate_surface_flux = false

Whether MOST surface fluxes are rotated with terrain.

Referenced by erf_slow_rhs_post(), erf_slow_rhs_pre(), and init_params().

use_wrf_bdy_density

bool SolverChoice::use_wrf_bdy_density = false

Referenced by init_params().

use_wrf_height_grid

bool SolverChoice::use_wrf_height_grid {true}

Referenced by init_params().

variable_coriolis

SolverChoice::variable_coriolis {false}

Whether spatially varying Coriolis forcing is enabled.

Referenced by init_params(), and make_mom_sources().

vert_implicit_fac

SolverChoice::vert_implicit_fac

Per-level, per-stage implicit vertical diffusion factors.

Referenced by check_params(), display(), erf_make_tau_terms(), erf_slow_rhs_post(), erf_slow_rhs_pre(), and init_params().

windfarm_airfoil_tables

SolverChoice::windfarm_airfoil_tables

Wind-farm airfoil table paths.

Referenced by init_params().

windfarm_blade_table

SolverChoice::windfarm_blade_table

Wind-farm blade table path.

Referenced by init_params().

windfarm_loc_table

SolverChoice::windfarm_loc_table

Wind-farm location table path.

Referenced by init_params().

windfarm_loc_type

SolverChoice::windfarm_loc_type

Coordinate system for wind-farm turbine locations.

Referenced by check_params(), and init_params().

windfarm_spec_table

SolverChoice::windfarm_spec_table

Wind-farm turbine specification table path.

Referenced by init_params().

windfarm_spec_table_extra

SolverChoice::windfarm_spec_table_extra

Additional wind-farm turbine specification table path.

Referenced by init_params().

windfarm_type

SolverChoice::windfarm_type

Wind-farm model.

Referenced by check_params(), and init_params().

windfarm_x_shift

SolverChoice::windfarm_x_shift = -one

Wind-farm x-coordinate shift.

Referenced by check_params(), and init_params().

windfarm_y_shift

SolverChoice::windfarm_y_shift = -one

Wind-farm y-coordinate shift.

Referenced by check_params(), and init_params().

zsurf

SolverChoice::zsurf = zero

Nominal surface height for stretched-grid setup.

Referenced by ERF::ERF_shared(), and init_params().

---

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

• Source/DataStructs/ERF_DataStruct.H