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	host_owns_vertical_momentum_diffusion () const noexcept
	Test whether the host owns momentum diffusion. More...
bool	host_owns_vertical_scalar_diffusion () const noexcept
	Test whether the host owns scalar diffusion. 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...
bool	rad_uses_interface () const
	True for the models that run through the IRadiation interface (RRTMGP, Simple); the two-stream model has its own class. 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...
RadChoice	radChoice
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< AnelasticType >	anelastic_type
	Per-level two-stage scheme used by the anelastic integrator. 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...
std::string	wall_dist_type = "poisson"
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_snap_partial_cells = false
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...
amrex::Real	nudging_u_z1 = amrex::Real(-1.0e36)
amrex::Real	nudging_u_z2 = amrex::Real(1.0e36)
amrex::Real	nudging_t_z1 = zero
amrex::Real	nudging_t_z2 = amrex::Real(10000.0)
amrex::Real	nudging_q_z1 = zero
amrex::Real	nudging_q_z2 = amrex::Real(10000.0)
bool	nudging_u = true
bool	nudging_t = true
bool	nudging_q = true
bool	large_scale_forcing = false
std::string	lsf_file = ""
amrex::Real	lsf_timescale = zero
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...
ShocTransportMode	shoc_transport_mode = ShocTransportMode::StateUpdate
ShocMomentumTransport	shoc_momentum_transport = ShocMomentumTransport::StateUpdate
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...
bool	compute_mean_vars = false
std::string	mean_vars_reset_mode = "plotfile"
amrex::Real	mean_vars_reset_time = -one
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...
bool	use_coupled_sst = false
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
	Index map of the moisture data carried by the active scheme: conserved-state components for the species and qmoist slots for the moist diagnostics. 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 = true
bool	use_wrf_bdy_qc_qi = false
	Whether WRF cloud water and active cloud ice are ingested at real boundaries. More...
amrex::Real	bdy_rho_nudge_factor = amrex::Real(-1.0)
int	bdy_moist_nudge_type = 1
	Moist-variable nudging strategy in boundary regions. More...
bool	avg_grid_faces_to_nodes {false}
bool	interp_atmos_from_coarse {false}
bool	do_forest_drag {false}
	Whether forest canopy drag is enabled. More...
bool	forest_biophysics {false}
bool	forest_biophysics_heat {false}
amrex::Real	forest_leaf_theta_fixed {-one}
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.queryAdd("rotational_time_period", rot_time_period);
 
        coriolis_factor = static_cast<amrex::Real>(4.0 * PI / rot_time_period);
 
        pp.queryAdd("coriolis_3d", coriolis_3d);
 
        // Convert to radians
        amrex::Real latitude_for_coriolis = amrex::Real(90.0);
        pp.queryAdd("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.queryAdd("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, using the "
                               << ((anelastic_type[lev] == AnelasticType::MidPoint) ? "MidPoint" : "RK2")
                               << " integrator" << 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::WDM6) {
            amrex::Print() << "Moisture Model: WDM6" << 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::SuperDroplets) {
            amrex::Print() << "Moisture Model: SuperDroplets" << 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 if (rad_type == RadiationType::Simple) {
            amrex::Print() << "Radiation Model: Simple" << std::endl;
        } else if (rad_type == RadiationType::TwoStream) {
            amrex::Print() << "Radiation Model: TwoStream" << 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:

host_owns_vertical_momentum_diffusion()

bool SolverChoice::host_owns_vertical_momentum_diffusion ( ) const

inlinenoexcept

Test whether the host owns momentum diffusion.

Returns

True if ERF dycore does vertical diffusion of momentum.

    {
        if (use_eamxx_shoc)   { return false; }
        if (!use_native_shoc) { return true;  }
        return shoc_disables_momentum_transport(shoc_momentum_transport);
    }

Referenced by init_params().

Here is the call graph for this function:

Here is the caller graph for this function:

host_owns_vertical_scalar_diffusion()

bool SolverChoice::host_owns_vertical_scalar_diffusion ( ) const

inlinenoexcept

Test whether the host owns scalar diffusion.

Returns

True if ERF dycore does vertical diffusion of scalars.

    {
        if (use_eamxx_shoc)   { return false; }
        if (!use_native_shoc) { return true;  }
        return false;
    }

Referenced by init_params().

Here is the caller 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.queryAdd("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.queryAdd("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.queryAdd("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);
 
        // Register the moisture data this scheme carries: conserved-state
        // components and qmoist diagnostic slots alike.  MoistureComponentIndices
        // is the one place that mapping lives, and every consumer -- source terms,
        // turbulence closures, and the plotfile/subvolume writers -- queries it
        // instead of testing moisture_type.
        moisture_indices = MoistureComponentIndices::from_moisture_model(moisture_type);
 
        // Set a default for both dry and moist
        buoyancy_type.resize(max_level+1);
        for (int i = 0; i <= max_level; ++i) {
            buoyancy_type[i] = 1; // uses Rhoprime
        }
 
        if (moisture_type != MoistureType::None) {
            pp.queryAdd("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);
 
        // Will an external ocean coupler supply SST for part or all of the water
        // cells this run? The surface layer needs to know this it in time to select
        // ThetaCalcType::SURFACE_TEMPERATURE, which is long before the first
        // ApplyOceanSurfaceState call.
        pp.queryAdd("use_coupled_sst", use_coupled_sst);
 
        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.queryAdd("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.queryAdd("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.queryAdd("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.queryAdd("nc_bdy_file", nc_bdy_file_temp_string);
            if (!has_bdy) use_real_bcs = false;
 
            bool use_real_bcs_temp = use_real_bcs;
            pp.queryAdd("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.queryAdd("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.queryAdd("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.queryAdd("use_lagged_delta_rt", use_lagged_delta_rt);
 
        // Average the input z-face heights onto the nodes, or reconstruct our own
        pp.queryAdd("avg_grid_faces_to_nodes",avg_grid_faces_to_nodes);
 
        // Catch the old name for the flag above so the error says what to do
        // rather than silently ignoring the setting.
        if (pp.contains("use_wrf_height_grid")) {
            amrex::Abort("erf.use_wrf_height_grid has been renamed. "
                         "Set erf.avg_grid_faces_to_nodes instead; it carries "
                         "the same meaning (average the input z-face heights "
                         "onto the nodes rather than reconstructing them).");
        }
 
        // Interpolate atmospheric state from coarse level instead of reading from wrfinput
        // when creating a finer level from coarse at a later time?
        pp.queryAdd("interp_atmos_from_coarse", interp_atmos_from_coarse);
 
        // Rebalance wrf state?
        pp.queryAdd("rebalance_wrf_input", rebalance_wrf_input);
 
        // Must rebalance if the nodal heights were reconstructed rather than averaged
        if (!avg_grid_faces_to_nodes && !rebalance_wrf_input) {
            amrex::Print() << "Must rebalance when not averaging the input height grid. Setting rebalance_wrf_input to true \n";
            rebalance_wrf_input = true;
        }
 
        // These default to true but are used for unit testing
        pp.queryAdd("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.queryAdd("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;
            }
        }
 
        if (anelastic_superdroplets_configuration_invalid(moisture_type, any_anelastic)) {
            amrex::Error("erf.moisture_model = SuperDroplets is not supported with "
                         "erf.anelastic = 1: the Super-Droplet path currently uses "
                         "the compressible equation of state. Use compressible "
                         "dynamics or a supported Eulerian moisture model.");
        }
 
        // 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 anelastic_type and allow for different values at each level
        // *******************************************************************************
        anelastic_type.resize(max_level+1);
 
        for (int i = 0; i <= max_level; i++) {
            anelastic_type[i] = AnelasticType::RK2;
        }
 
        for (int i = 0; i <= max_level; i++) {
            query_one_or_per_level_enum_case_insensitive(
                pp, "anelastic_type", anelastic_type[i], i, max_level);
        }
 
        if (pp.contains("anelastic_type") && !any_anelastic) {
            amrex::Print() << "Ignoring erf.anelastic_type because no level is anelastic" << std::endl;
            for (int i = 0; i <= max_level; i++) { anelastic_type[i] = AnelasticType::RK2; }
        }
 
        // *******************************************************************************
        // 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.queryAdd("substepping_diag", substepping_diag);
 
        pp.queryAdd("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.queryAdd("ncorr", ncorr);
        // Wall distance on a terrain-fitted mesh (RANS): "poisson" (Tucker 2003
        // differential-equation distance) or "terrain_height" (height above the
        // local surface projected on its normal, no linear solve)
        pp.queryAdd("wall_dist_type", wall_dist_type);
        if (wall_dist_type != "poisson" && wall_dist_type != "terrain_height") {
            amrex::Error("erf.wall_dist_type must be poisson or terrain_height");
        }
        pp.queryAdd("poisson_abstol", poisson_abstol);
        pp.queryAdd("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.queryAdd("force_stage1_single_substep", force_stage1_single_substep);
 
        // Include Coriolis forcing?
        pp.queryAdd("use_coriolis", use_coriolis);
        pp.queryAdd("variable_coriolis", variable_coriolis);
 
        // Include four stream radiation approximation
        pp.queryAdd("four_stream_radiation", four_stream_radiation);
 
        // flags for whether to apply other source terms in substep only
        pp.queryAdd("immersed_forcing_substep", immersed_forcing_substep); // apply immersed forcing source terms in substep only
        pp.queryAdd("forest_substep", forest_substep);                     // apply canopy-related source terms in substep only
 
        // Fixed-leaf-temperature canopy heat exchange
        pp.query("forest_biophysics",       forest_biophysics);
        pp.query("forest_biophysics_heat",  forest_biophysics_heat);
        pp.query("forest_leaf_theta_fixed", forest_leaf_theta_fixed);
 
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
            !forest_biophysics_heat || forest_biophysics,
            "forest_biophysics_heat requires forest_biophysics = true");
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
            !(forest_biophysics && forest_biophysics_heat) ||
                forest_leaf_theta_fixed > zero,
            "forest_biophysics_heat requires a positive forest_leaf_theta_fixed");
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
            forest_leaf_theta_fixed <= zero || forest_biophysics_heat,
            "forest_leaf_theta_fixed requires forest_biophysics_heat = true");
 
        // immersed forcing parameters
        pp.queryAdd("if_Cd_momentum", if_Cd_momentum);
        pp.queryAdd("if_Cd_scalar", if_Cd_scalar);
        pp.queryAdd("if_implicit_drag", if_implicit_drag); // flag for implicit vs. explicit drag formulation
        pp.queryAdd("if_z0", if_z0);
        pp.queryAdd("if_surf_temp_flux", if_surf_temp_flux);
        pp.queryAdd("if_init_surf_temp", if_init_surf_temp);
 
        pp.queryAdd("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.queryAdd("if_Olen", if_Olen_in);
        pp.queryAdd("if_use_most",if_use_most);
        pp.queryAdd("if_snap_partial_cells",if_snap_partial_cells);
        // The snapped staircase puts full-strength forcing on every wall face,
        // whose explicit relaxation rate (Cd / dx per substep) sits at the
        // stability limit and fails where faces stack at rims and corners; the
        // point-implicit form holds at any rate, so the snap uses it.
        if (if_snap_partial_cells && !if_implicit_drag) {
            amrex::Print() << "erf.if_snap_partial_cells: using the point-implicit drag (erf.if_implicit_drag = true)\n";
            if_implicit_drag = true;
        }
        pp.queryAdd("if_stability_correction",if_stability_correction);
        pp.queryAdd("if_ws_floor",if_ws_floor);
        pp.queryAdd("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.queryAdd("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.queryAdd("const_massflux_u", const_massflux_u);
        pp.queryAdd("const_massflux_v", const_massflux_v);
        pp.queryAdd("const_massflux_tau", const_massflux_tau);
        pp.queryAdd("const_massflux_layer_lo", const_massflux_layer_lo);
        pp.queryAdd("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.queryAdd("add_custom_rhotheta_forcing", custom_rhotheta_forcing);
        pp.queryAdd("add_custom_moisture_forcing", custom_moisture_forcing);
        pp.queryAdd("add_custom_w_subsidence", custom_w_subsidence);
        pp.queryAdd("add_do_theta_advection", do_theta_advection);  // If true, apply custom subsidence to (rho*theta) when add_custom_w_subsidence is used
        pp.queryAdd("add_do_mom_advection", do_mom_advection);      // If true, apply custom subsidence to momentum when add_custom_w_subsidence is used
        pp.queryAdd("add_custom_geostrophic_profile", custom_geostrophic_profile);
        pp.queryAdd("custom_forcing_uses_primitive_vars", custom_forcing_prim_vars);
        pp.queryAdd("spatial_rhotheta_forcing", spatial_rhotheta_forcing);
        pp.queryAdd("spatial_moisture_forcing", spatial_moisture_forcing);
 
        pp.queryAdd("nudging_from_input_sounding", nudging_from_input_sounding);
 
        int nudging_u_z1_set = pp.queryAdd("nudging_u_z1", nudging_u_z1);
        int nudging_u_z2_set = pp.queryAdd("nudging_u_z2", nudging_u_z2);
        pp.queryAdd("nudging_t_z1", nudging_t_z1);
        pp.queryAdd("nudging_t_z2", nudging_t_z2);
        pp.queryAdd("nudging_q_z1", nudging_q_z1);
        pp.queryAdd("nudging_q_z2", nudging_q_z2);
 
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(nudging_u_z1 <= nudging_u_z2,
            "nudging_u_z1 must be less than or equal to nudging_u_z2");
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(nudging_t_z1 <= nudging_t_z2,
            "nudging_t_z1 must be less than or equal to nudging_t_z2");
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(nudging_q_z1 <= nudging_q_z2,
            "nudging_q_z1 must be less than or equal to nudging_q_z2");
 
        pp.queryAdd("nudging_u", nudging_u);
        pp.queryAdd("nudging_t", nudging_t);
        pp.queryAdd("nudging_q", nudging_q);
 
        pp.queryAdd("large_scale_forcing", large_scale_forcing);
 
        if (nudging_from_input_sounding && large_scale_forcing) {
            if (!nudging_u) {
                amrex::Print() << "WARNING: erf.nudging_u = false has no effect when erf.large_scale_forcing "
                                  "= true; momentum nudging is then controlled solely by large_scale_forcing.\n";
            }
            if (nudging_u_z1_set || nudging_u_z2_set) {
                amrex::Print() << "WARNING: erf.nudging_u_z1/erf.nudging_u_z2 are ignored when "
                                  "erf.large_scale_forcing = true; momentum nudging is then applied "
                                  "at all heights.\n";
            }
        }
 
        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.queryAdd("Ave_Plane", ave_plane);
 
        // Use numerical diffusion?
        pp.queryAdd("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);
        }
 
        // erf.radiation_model = TwoStream selects the two-stream model; its
        // erf.radiation.* sub-options are read only then.
        radChoice.init_params(rad_type == RadiationType::TwoStream, 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.queryAdd("bdy_nudge_factor",bdy_nudge_factor);
 
        // Optionally use the dry-air density reconstructed from wrfbdy.
        pp.queryAdd("use_wrf_bdy_density", use_wrf_bdy_density);
 
        // Optionally ingest cloud water and cloud ice from wrfinput/wrfbdy.
        pp.queryAdd("use_wrf_bdy_qc_qi", use_wrf_bdy_qc_qi);
 
        if (!use_real_bcs || init_type != InitType::WRFInput) {
            use_wrf_bdy_density = false;
        }
 
        pp.queryAdd("bdy_rho_nudge_factor", bdy_rho_nudge_factor);
 
        // Which approach to nudging the moist variables in the boundary region?
        pp.queryAdd("bdy_moist_nudge_type",bdy_moist_nudge_type);
        if (bdy_moist_nudge_type < 0 || bdy_moist_nudge_type > 3) {
            amrex::Error("erf.bdy_moist_nudge_type must be one of 0, 1, 2, or 3");
        }
        if (bdy_moist_nudge_type == 3 && !use_wrf_bdy_qc_qi) {
            amrex::Error("erf.bdy_moist_nudge_type = 3 requires erf.use_wrf_bdy_qc_qi = true");
        }
        if (use_wrf_bdy_qc_qi) {
            if (moisture_type == MoistureType::None) {
                amrex::Error("erf.use_wrf_bdy_qc_qi requires an active moisture model");
            }
            if (!use_real_bcs || init_type != InitType::WRFInput) {
                amrex::Error("erf.use_wrf_bdy_qc_qi requires WRFInput real boundary conditions");
            }
            if (moisture_indices.qv < RhoQ1_comp || moisture_indices.qv > RhoQ11_comp ||
                moisture_indices.qc < RhoQ1_comp || moisture_indices.qc > RhoQ11_comp) {
                amrex::Error("erf.use_wrf_bdy_qc_qi requires active qv and qc component indices");
            }
            const int optional_moisture_comps[] = {moisture_indices.qi,
                                                   moisture_indices.qr,
                                                   moisture_indices.qs,
                                                   moisture_indices.qg};
            for (const int comp : optional_moisture_comps) {
                if (comp != -1 && (comp < RhoQ1_comp || comp > RhoQ11_comp)) {
                    amrex::Error("erf.use_wrf_bdy_qc_qi found an invalid active moisture component index");
                }
            }
        }
 
        // Are me transporting the scalar component?
        pp.queryAdd("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;
                read_shoc_transport_modes(shoc_transport_mode, shoc_momentum_transport);
            }
        }
 
        // Set up the vertical implicit diffusion solve
        int n_impfac = pp.countval("vert_implicit_fac");
        AMREX_ALWAYS_ASSERT(n_impfac == 0 || n_impfac == 1 || n_impfac==3);
        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]);
            }
        }
 
        // Record whether the user explicitly requested these
        const bool user_set_imp_thermal  = pp.contains("implicit_thermal_diffusion");
        const bool user_set_imp_moisture = pp.contains("implicit_moisture_diffusion");
        const bool user_set_imp_ke       = pp.contains("implicit_ke_diffusion");
        const bool user_set_imp_momentum = pp.contains("implicit_momentum_diffusion");
 
        // If true (default), include implicit contributions to vertical thermal diffusion
        pp.queryAdd("implicit_thermal_diffusion", implicit_thermal_diffusion);
 
        // If true (default), include implicit contributions to vertical moisture diffusion
        pp.queryAdd("implicit_moisture_diffusion", implicit_moisture_diffusion);
 
        // If true (default), include implicit contributions to vertical KE diffusion
        pp.queryAdd("implicit_ke_diffusion", implicit_ke_diffusion);
 
        // If true (default), include implicit contributions in tau13, tau23,
        pp.queryAdd("implicit_momentum_diffusion", implicit_momentum_diffusion);
 
        // The default is true (i.e. that it happens before the acoustic substepping).
        pp.queryAdd("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;
            }
        }
 
        // Handle shoc case -- SHOC owns whatever vertical diffusion the host does not
        if (uses_shoc_family()) {
            const bool host_owns_scalars  = host_owns_vertical_scalar_diffusion();
            const bool host_owns_momentum = host_owns_vertical_momentum_diffusion();
            if (!host_owns_scalars &&
                ( (user_set_imp_thermal  && implicit_thermal_diffusion ) ||
                  (user_set_imp_moisture && implicit_moisture_diffusion) ||
                  (user_set_imp_ke       && implicit_ke_diffusion      ) ) ) {
                amrex::Print() << "Ignoring erf.implicit_{thermal,moisture,ke}_diffusion = true; "
                               << "SHOC owns vertical scalar diffusion." << "\n";
            }
            if (!host_owns_momentum && user_set_imp_momentum && implicit_momentum_diffusion) {
                amrex::Print() << "Ignoring erf.implicit_momentum_diffusion = true; "
                               << "SHOC owns vertical momentum diffusion." << "\n";
            }
 
            implicit_thermal_diffusion  = (implicit_thermal_diffusion  && host_owns_scalars);
            implicit_moisture_diffusion = (implicit_moisture_diffusion && host_owns_scalars);
            implicit_ke_diffusion       = (implicit_ke_diffusion       && host_owns_scalars);
            implicit_momentum_diffusion = (implicit_momentum_diffusion && host_owns_momentum);
 
            // Make the resulting configuration visible in the run log
            if (!host_owns_scalars && !host_owns_momentum) {
                amrex::Print() << "Turning off vertical implicit solve for all components since SHOC owns diffusion." << "\n";
            } else {
                amrex::Print() << "SHOC hands vertical diffusion of"
                               << (host_owns_scalars  ? " scalars"  : "")
                               << (host_owns_momentum ? " momentum" : "")
                               << " to the host; keeping the vertical implicit solve on (theta = "
                               << implicit_thermal_diffusion
                               << ", moisture = " << implicit_moisture_diffusion
                               << ", tke = "      << implicit_ke_diffusion
                               << ", momenta = "  << implicit_momentum_diffusion << ")." << "\n";
            }
        } // uses_shoc_family
 
        // Do not allow implicit vertical diff if user turns it off
        bool do_vert_implicit = true;
        pp.queryAdd("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;
            }
        }
 
        // The implicit vertical diffusion is only second order in an anelastic run when
        // the two stages are the midpoint method and the solve is done in the first stage
        // alone: S^* = S^n + (dt/2) F(S^*) and S^{n+1} = S^n + dt F(S^*) give
        // S^* = (S^n + S^{n+1})/2, i.e. the implicit midpoint rule.  Solving again in the
        // second stage would reduce the pair to backward Euler, and with the RK2 (Heun)
        // stages there is no stage that plays the role of the midpoint at all.
        for (int lev = 0; lev <= max_level; lev++) {
            if (anelastic[lev]) {
                if (anelastic_type[lev] == AnelasticType::RK2) {
                    amrex::Print() << "Turning off native vertical implicit solve flag because anelastic at level " << lev
                                   << " with RK2 scheme." << std::endl;
                    vert_implicit_fac[lev][0] = zero;
                    vert_implicit_fac[lev][1] = zero;
                    vert_implicit_fac[lev][2] = zero;
                } else if (anelastic_type[lev] == AnelasticType::MidPoint) {
                    if (do_vert_implicit && vert_implicit_fac[lev][0] != one) {
                        amrex::Print() << "Forcing implicit factor 1 in first stage of MidPoint to ensure second-order accuracy." << std::endl;
                        vert_implicit_fac[lev][0] = one;
                    }
                    if (vert_implicit_fac[lev][1] > zero) {
                        amrex::Print() << "Turning off the second-stage vertical implicit solve at level " << lev
                                       << " because anelastic with MidPoint solves in the first stage only."
                                       << std::endl;
                    }
                    // The anelastic integrator only takes two stages, so [2] is never used
                    vert_implicit_fac[lev][1] = zero;
                    vert_implicit_fac[lev][2] = zero;
                }
            }
        }
 
        // 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;
                }
            }
        }
 
        // The EB diffusion path adds no buoyancy, shear or dissipation source for
        // a prognostic TKE closure
        if (terrain_type == TerrainType::EB) {
            for (int lev = 0; lev <= max_level; lev++) {
                if (turbChoice[lev].use_keqn) {
                    amrex::Error("erf.terrain_type = EB cannot be used with erf.les_type = Deardorff "
                                 "or erf.rans_type = kEqn: the EB diffusion path has no TKE sources");
                }
            }
        }
 
        // Do not allow implicit vertical diff when all the components are false
        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;
            }
        }
 
        // 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.queryAdd("windfarm_loc_table",  windfarm_loc_table);
        pp.queryAdd("windfarm_spec_table", windfarm_spec_table);
        pp.queryAdd("windfarm_blade_table", windfarm_blade_table);
        pp.queryAdd("windfarm_airfoil_tables", windfarm_airfoil_tables);
        pp.queryAdd("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.queryAdd("sampling_distance_by_D", sampling_distance_by_D);
        pp.queryAdd("turb_disk_angle_from_x", turb_disk_angle);
 
        pp.queryAdd("windfarm_x_shift",windfarm_x_shift);
        pp.queryAdd("windfarm_y_shift",windfarm_y_shift);
        // Test if time averaged data is to be output
        pp.queryAdd("time_avg_vel",time_avg_vel);
 
        // Interval means and resolved turbulent moments for plotfile output
        pp.queryAdd("compute_mean_vars", compute_mean_vars);
        pp.queryAdd("mean_vars_reset_mode", mean_vars_reset_mode);
        pp.queryAdd("mean_vars_reset_time", mean_vars_reset_time);
 
        if (compute_mean_vars &&
            mean_vars_reset_mode != "plotfile" && mean_vars_reset_mode != "time") {
            amrex::Error("erf.mean_vars_reset_mode must be either 'plotfile' or 'time'");
        }
        if (compute_mean_vars && mean_vars_reset_mode == "time" &&
            mean_vars_reset_time < zero) {
            amrex::Error("erf.mean_vars_reset_time must be non-negative when "
                         "erf.mean_vars_reset_mode = 'time'");
        }
 
        pp.queryAdd("hindcast_lateral_forcing", hindcast_lateral_forcing);
 
        if (hindcast_lateral_forcing) {
            pp.queryAdd("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.queryAdd("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.queryAdd("hindcast_lateral_sponge_strength", hindcast_lateral_sponge_strength);
            pp.queryAdd("hindcast_lateral_sponge_length", hindcast_lateral_sponge_length);
 
            pp.queryAdd("hindcast_zhi_sponge_length", hindcast_zhi_sponge_length);
            pp.queryAdd("hindcast_zhi_sponge_strength", hindcast_zhi_sponge_strength);
 
            pp.queryAdd("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.queryAdd("hindcast_surface_bcs", hindcast_surface_bcs);
        if(hindcast_surface_bcs) {
            pp.queryAdd("hindcast_surface_data_dir", hindcast_surface_data_dir);
        }
 
        pp.queryAdd("io_hurricane_eye_tracker", io_hurricane_eye_tracker);
        if (io_hurricane_eye_tracker) {
            pp.queryAdd("hurricane_eye_latitude", hurricane_eye_latitude);
            pp.queryAdd("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.queryAdd("is_init_for_ensemble", is_init_for_ensemble);
        if(is_init_for_ensemble) {
            amrex::ParmParse pp_ens("ensemble");
            pp_ens.queryAdd("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.queryAdd("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.queryAdd("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.queryAdd("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:

rad_uses_interface()

bool SolverChoice::rad_uses_interface ( ) const

inline

True for the models that run through the IRadiation interface (RRTMGP, Simple); the two-stream model has its own class.

                                                   {
        return (rad_type == RadiationType::RRTMGP) || (rad_type == RadiationType::Simple);
    }

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(), WDM6::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_slow_rhs_post(), erf_slow_rhs_pre(), init_params(), make_gradp_pert(), and NullMoist::set_anelastic_reference_pressure_mode().

anelastic_type

SolverChoice::anelastic_type

Per-level two-stage scheme used by the anelastic integrator.

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

ave_plane

SolverChoice::ave_plane {2}

Averaging plane index used by diagnostics.

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

avg_grid_faces_to_nodes

bool SolverChoice::avg_grid_faces_to_nodes {false}

Referenced by init_params().

bdy_moist_nudge_type

SolverChoice::bdy_moist_nudge_type = 1

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(), 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().

compute_mean_vars

bool SolverChoice::compute_mean_vars = false

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_biophysics

bool SolverChoice::forest_biophysics {false}

Referenced by init_params().

forest_biophysics_heat

bool SolverChoice::forest_biophysics_heat {false}

Referenced by AddCanopyBiophysicsHeatSources(), and init_params().

forest_leaf_theta_fixed

amrex::Real SolverChoice::forest_leaf_theta_fixed {-one}

Referenced by AddCanopyBiophysicsHeatSources(), and 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 ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), ImmersedForcingTerrain_Xmom(), ImmersedForcingTerrain_Ymom(), ImmersedForcingTerrain_Zmom(), and init_params().

if_Cd_scalar

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

Immersed-forcing drag coefficient for scalars.

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingTerrain_Scalar(), and init_params().

if_damp_alpha

SolverChoice::if_damp_alpha = 0.5

Immersed-forcing damping coefficient.

Referenced by ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), and init_params().

if_implicit_drag

bool SolverChoice::if_implicit_drag = false

Referenced by ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), ImmersedForcingTerrain_Xmom(), ImmersedForcingTerrain_Ymom(), ImmersedForcingTerrain_Zmom(), and init_params().

if_init_surf_temp

SolverChoice::if_init_surf_temp = zero

Initial immersed-forcing surface temperature [K].

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingTerrain_Scalar(), and init_params().

if_Olen_in

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

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

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), ImmersedForcingTerrain_Scalar(), ImmersedForcingTerrain_Xmom(), ImmersedForcingTerrain_Ymom(), and init_params().

if_snap_partial_cells

SolverChoice::if_snap_partial_cells = false

When true, the immersed forcing reads the blanking snapped to solid (1) or fluid (0) at half, so a building from a height map becomes the same staircase of whole cells an exact box is: the wall law (and the thermal conditions) sit on the boundary solid cells, roofs included, the drag on the interior cells, and nothing on the sliver cells of the reader's one-cell ramp (1-20 percent solid at the corners), on which the raw fractions make the wall law and the drag disagree and grow a vertical checkerboard over hours. The staircase puts full-strength forcing on every wall face, so the switch also selects the point-implicit drag form (if_implicit_drag), without which the explicit rate at rims and corners drives the density negative within seconds. The momentum kernels take the blanking of a face from the two cells it joins (solid if either is), so the staircase is the same with and without the face-centred blanking of the build; a face between a solid and a fluid cell is wall-normal and gets the interior drag toward zero (no penetration) whichever row it lies in, and a face between two solid cells the roof or wall law of its row (with the full log-law target; the partial-cell weight of the target is not applied) or the interior drag. Buildings only (erf.buildings_type = ImmersedForcing): the terrain kernels keep the raw fractions, whose wall law is weighted by the fluid fraction of the face. Default false, the raw fractions, for backward compatibility (on an exact box a boundary cell then carries the wall law and the interior drag together, and the roof only the drag); set it for height-map buildings.

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), and init_params().

if_stability_correction

SolverChoice::if_stability_correction = false

Whether immersed-forcing stability corrections are enabled.

Referenced by ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), and init_params().

if_surf_heating_rate

SolverChoice::if_surf_heating_rate = zero

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

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingTerrain_Scalar(), and init_params().

if_surf_temp_flux

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

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

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), ImmersedForcingTerrain_Scalar(), ImmersedForcingTerrain_Xmom(), ImmersedForcingTerrain_Ymom(), and init_params().

if_use_most

SolverChoice::if_use_most = false

Whether immersed-forcing MOST is enabled.

Referenced by ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), ImmersedForcingTerrain_Xmom(), ImmersedForcingTerrain_Ymom(), and init_params().

if_ws_floor

SolverChoice::if_ws_floor = 0.001

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

Referenced by ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), and init_params().

if_z0

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

Immersed-forcing roughness length [m].

Referenced by ImmersedForcingBuildings_Scalar(), ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), ImmersedForcingTerrain_Scalar(), ImmersedForcingTerrain_Xmom(), ImmersedForcingTerrain_Ymom(), and init_params().

immersed_forcing_substep

SolverChoice::immersed_forcing_substep = false

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

Referenced by ImmersedForcingBuildings_Xmom(), ImmersedForcingBuildings_Ymom(), ImmersedForcingBuildings_Zmom(), 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().

interp_atmos_from_coarse

bool SolverChoice::interp_atmos_from_coarse {false}

Referenced by init_params().

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().

large_scale_forcing

bool SolverChoice::large_scale_forcing = false

Referenced by init_params(), and make_mom_sources().

lsf_file

std::string SolverChoice::lsf_file = ""

lsf_timescale

amrex::Real SolverChoice::lsf_timescale = zero

lsm_type

SolverChoice::lsm_type

Land-surface model.

Referenced by 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().

mean_vars_reset_mode

std::string SolverChoice::mean_vars_reset_mode = "plotfile"

Referenced by init_params().

mean_vars_reset_time

amrex::Real SolverChoice::mean_vars_reset_time = -one

Referenced by init_params().

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(), ERF::FillPlot3DVars(), 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

Index map of the moisture data carried by the active scheme: conserved-state components for the species and qmoist slots for the moist diagnostics.

Referenced by plotfile2d::active_condensed_water_path_descriptors(), plotfile2d::available_diagnostic_names(), ComputeTurbulentViscosity(), ERF::GetFillableAtmosToOceanLanes(), ERF::HasCloudWater(), init_params(), ERF::PackAtmosphericStates(), Radiation::Radiation(), RadiationSimple::RadiationSimple(), 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 AddCanopyBiophysicsHeatSources(), Morrison::Advance(), Kessler::AdvanceKessler(), plotfile2d::available_diagnostic_names(), check_params(), SAM::Cloud(), Kessler::Define(), Morrison::Define(), SAM::Define(), WDM6::Define(), WSM6::Define(), display(), ERF::ERF_shared(), erf_slow_rhs_post(), erf_slow_rhs_pre(), ERF::GetFillableAtmosToOceanLanes(), ERF::HasCloudWater(), 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(), and make_mom_sources().

nudging_q

bool SolverChoice::nudging_q = true

Referenced by init_params().

nudging_q_z1

amrex::Real SolverChoice::nudging_q_z1 = zero

Referenced by init_params().

nudging_q_z2

amrex::Real SolverChoice::nudging_q_z2 = amrex::Real(10000.0)

Referenced by init_params().

nudging_t

bool SolverChoice::nudging_t = true

Referenced by init_params().

nudging_t_z1

amrex::Real SolverChoice::nudging_t_z1 = zero

Referenced by init_params().

nudging_t_z2

amrex::Real SolverChoice::nudging_t_z2 = amrex::Real(10000.0)

Referenced by init_params().

nudging_u

bool SolverChoice::nudging_u = true

Referenced by init_params(), and make_mom_sources().

nudging_u_z1

amrex::Real SolverChoice::nudging_u_z1 = amrex::Real(-1.0e36)

Referenced by init_params(), and make_mom_sources().

nudging_u_z2

amrex::Real SolverChoice::nudging_u_z2 = amrex::Real(1.0e36)

Referenced by init_params(), and make_mom_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 init_params().

rad_type

SolverChoice::rad_type

Radiation model.

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

radChoice

RadChoice SolverChoice::radChoice

Referenced by init_params().

rdOcp

SolverChoice::rdOcp

Ratio of dry-air gas constant to c_p.

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

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().

shoc_momentum_transport

ShocMomentumTransport SolverChoice::shoc_momentum_transport = ShocMomentumTransport::StateUpdate

Referenced by host_owns_vertical_momentum_diffusion(), init_params(), and ShocDriver::ShocDriver().

shoc_transport_mode

ShocTransportMode SolverChoice::shoc_transport_mode = ShocTransportMode::StateUpdate

Referenced by init_params(), and ShocDriver::ShocDriver().

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(), ERF::canonicalizePlot3DVariables(), check_params(), compute_gradp_xy(), compute_gradp_z(), ERF::ComputeGhostCells(), ComputeTurbulentViscosity(), display(), erf_make_tau_terms(), 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::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(), ImplicitDiffForStateLU_N(), ImplicitDiffForStateLU_S(), ImplicitDiffForStateLU_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_coupled_sst

bool SolverChoice::use_coupled_sst = false

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

use_eamxx_shoc

SolverChoice::use_eamxx_shoc = false

Whether any level uses the EAMxx SHOC PBL scheme.

Referenced by host_owns_vertical_momentum_diffusion(), host_owns_vertical_scalar_diffusion(), 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 host_owns_vertical_momentum_diffusion(), host_owns_vertical_scalar_diffusion(), 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 = true

Referenced by init_params().

use_wrf_bdy_qc_qi

SolverChoice::use_wrf_bdy_qc_qi = false

Whether WRF cloud water and active cloud ice are ingested at real boundaries.

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().

wall_dist_type

std::string SolverChoice::wall_dist_type = "poisson"

Referenced by 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