#include <ERF_DataStruct.H>

Collaboration diagram for SolverChoice:

[legend]

Public Member Functions
void	init_params (int max_level)

void	check_params (int max_level)

void	display (int max_level)

void	build_coriolis_forcings ()

void	read_int_string (int max_level, const char *string_to_read, amrex::Vector< int > &vec_to_fill, int default_int)

Static Public Member Functions
static void	set_flat_terrain_flag ()

Public Attributes
AdvChoice	advChoice

DiffChoice	diffChoice

SpongeChoice	spongeChoice

amrex::Vector< TurbChoice >	turbChoice

std::string	pp_prefix {"erf"}

int	force_stage1_single_substep = 1

amrex::Vector< SubsteppingType >	substepping_type

amrex::Vector< int >	anelastic

int	constant_density = 0

int	ncorr = 1

amrex::Real	poisson_abstol = 1e-10

amrex::Real	poisson_reltol = 1e-10

bool	test_mapfactor = false

int	buoyancy_type = 1

bool	use_gravity = false

bool	use_coriolis = false

bool	coriolis_3d = true

bool	rayleigh_damp_U = false

bool	rayleigh_damp_V = false

bool	rayleigh_damp_W = false

bool	rayleigh_damp_T = false

amrex::Real	rayleigh_dampcoef = 0.2

amrex::Real	rayleigh_zdamp = 500.0

amrex::Real	rayleigh_ztop

bool	use_lagged_delta_rt = true

amrex::Real	gravity

amrex::Real	c_p = Cp_d

amrex::Real	rdOcp

amrex::Real	grid_stretching_ratio = 0

amrex::Real	zsurf = 0.0

amrex::Real	dz0

bool	project_initial_velocity = false

amrex::Real	coriolis_factor = 0.0

amrex::Real	cosphi = 0.0

amrex::Real	sinphi = 0.0

bool	custom_rhotheta_forcing = false

bool	custom_moisture_forcing = false

bool	custom_w_subsidence = false

bool	custom_geostrophic_profile = false

bool	custom_forcing_prim_vars = false

bool	nudging_from_input_sounding = false

bool	use_explicit_most = false

bool	use_rotate_most = false

bool	time_avg_vel = false

PerturbationType	pert_type

bool	use_num_diff {false}

amrex::Real	num_diff_coeff {0.}

bool	use_mono_adv {false}

CouplingType	coupling_type

MoistureType	moisture_type

WindFarmType	windfarm_type

WindFarmLocType	windfarm_loc_type

LandSurfaceType	lsm_type

ABLDriverType	abl_driver_type

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

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

std::string	abl_geo_wind_table

bool	have_geo_wind_profile {false}

int	ave_plane {2}

bool	do_cloud {true}

bool	do_precip {true}

bool	use_moist_background {false}

int	RhoQv_comp {-1}

int	RhoQc_comp {-1}

int	RhoQr_comp {-1}

std::string	windfarm_loc_table

std::string	windfarm_spec_table

std::string	windfarm_spec_table_extra

std::string	windfarm_blade_table

std::string	windfarm_airfoil_tables

amrex::Real	sampling_distance_by_D = -1.0

amrex::Real	turb_disk_angle = -1.0

amrex::Real	windfarm_x_shift = -1.0

amrex::Real	windfarm_y_shift = -1.0

bool	do_forest_drag {false}

Static Public Attributes
static bool	terrain_is_flat = false

static TerrainType	terrain_type = TerrainType::None

static MeshType	mesh_type = MeshType::ConstantDz

Detailed Description

Container holding many of the algorithmic options and parameters

Member Function Documentation

◆ build_coriolis_forcings()

void SolverChoice::build_coriolis_forcings ( )

inline

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

Referenced by init_params().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_params()

void SolverChoice::check_params ( int max_level )

inline

     {
         // 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 ***");
             }
         }
         //
         // Buoyancy type check
         //
         if (buoyancy_type != 1 && buoyancy_type != 2 && buoyancy_type != 3 && buoyancy_type != 4) {
             amrex::Abort("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 < 0.0) {
              amrex::Abort("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 < 0.0) {
             amrex::Abort("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 < 0.0 or windfarm_y_shift < 0.0)) {
             amrex::Abort("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.");
         }
     }

Referenced by init_params().

Here is the caller graph for this function:

◆ display()

void SolverChoice::display ( int max_level )

inline

     {
         amrex::Print() << "SOLVER CHOICE: " << std::endl;
         amrex::Print() << "force_stage1_single_substep : "  << force_stage1_single_substep << std::endl;
         for (int lev = 0; lev <= max_level; lev++) {
             amrex::Print() << "anelastic      at level : " << lev << " is " <<     anelastic[lev] << std::endl;
             if (substepping_type[lev] == SubsteppingType::None) {
                 amrex::Print() << "No substepping at level " << lev << std::endl;
             } else if (substepping_type[lev] == SubsteppingType::Explicit) {
                 amrex::Print() << "Explicit substepping at level " << lev << std::endl;
             } else if (substepping_type[lev] == SubsteppingType::Implicit) {
                 amrex::Print() << "Implicit substepping at level " << lev << std::endl;
             }
         }
         amrex::Print() << "use_coriolis                : " << use_coriolis << std::endl;
         amrex::Print() << "use_gravity                 : " << use_gravity << 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;
         } else if (terrain_type == TerrainType::ImmersedForcing) {
             amrex::Print() << "Terrain Type: ImmersedForcing" << std::endl;
         } else {
             amrex::Print() << "Terrain 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::Abort("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;
             }
         }
  
         amrex::Print() << "Buoyancy_type               : " << buoyancy_type << std::endl;
  
            advChoice.display();
           diffChoice.display();
         spongeChoice.display();
  
         for (int lev = 0; lev <= max_level; lev++) {
             turbChoice[lev].display(lev);
         }
     }

Here is the call graph for this function:

◆ init_params()

void SolverChoice::init_params ( int max_level )

inline

     {
         amrex::ParmParse pp(pp_prefix);
  
         pp.query("grid_stretching_ratio", grid_stretching_ratio);
         if (grid_stretching_ratio != 0) {
             AMREX_ASSERT_WITH_MESSAGE((grid_stretching_ratio >= 1.),
                                       "The grid stretching ratio must be greater than 1");
         }
         if (grid_stretching_ratio >= 1) {
             if (mesh_type == MeshType::ConstantDz) {
                 mesh_type    = MeshType::StretchedDz;
             }
             if (terrain_type != TerrainType::StaticFittedMesh) {
                 amrex::Print() << "Turning terrain on to enable grid stretching" << std::endl;
                 terrain_type = TerrainType::StaticFittedMesh;
             }
             pp.query("zsurface", zsurf);
             if (zsurf != 0.0) {
                 amrex::Print() << "Nominal zsurface height != 0, may result in unexpected behavior"
                     << std::endl;
             }
             pp.get("initial_dz", dz0);
         }
  
         // Do we set map scale factors to 0.5 instead of 1 for testing?
         pp.query("test_mapfactor", test_mapfactor);
  
         // What type of moisture model to use?
         moisture_type = MoistureType::None; // Default
         pp.query_enum_case_insensitive("moisture_model",moisture_type);
         if (moisture_type == MoistureType::SAM) {
             RhoQv_comp = RhoQ1_comp;
             RhoQc_comp = RhoQ2_comp;
             RhoQr_comp = RhoQ4_comp;
         } else if (moisture_type == MoistureType::SAM_NoIce) {
             RhoQv_comp = RhoQ1_comp;
             RhoQc_comp = RhoQ2_comp;
             RhoQr_comp = RhoQ4_comp;
         } else if (moisture_type == MoistureType::SAM_NoPrecip_NoIce) {
             RhoQv_comp = RhoQ1_comp;
             RhoQc_comp = RhoQ2_comp;
         } else if (moisture_type == MoistureType::Kessler) {
             RhoQv_comp = RhoQ1_comp;
             RhoQc_comp = RhoQ2_comp;
             RhoQr_comp = RhoQ3_comp;
         } else if (moisture_type == MoistureType::Kessler_NoRain) {
             RhoQv_comp = RhoQ1_comp;
             RhoQc_comp = RhoQ2_comp;
         } else if (moisture_type == MoistureType::SatAdj) {
             RhoQv_comp = RhoQ1_comp;
             RhoQc_comp = RhoQ2_comp;
         }
  
         // TODO: should we set default for dry??
         // Set a different default for moist vs dry
         if (moisture_type != MoistureType::None) {
             if (moisture_type == MoistureType::Kessler_NoRain     ||
                 moisture_type == MoistureType::SAM                ||
                 moisture_type == MoistureType::SAM_NoIce          ||
                 moisture_type == MoistureType::SAM_NoPrecip_NoIce ||
                 moisture_type == MoistureType::SatAdj)
             {
                 buoyancy_type = 1; // uses Rhoprime
             } else {
                 buoyancy_type = 2; // uses Tprime
             }
         }
  
         // Which expression (1,2/3 or 4) to use for buoyancy
         pp.query("buoyancy_type", 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);
  
         // Is the terrain none, static or moving?
         std::string terrain_type_temp = "";
         pp.query("terrain_type", terrain_type_temp);
         if (terrain_type_temp == "Moving") {
             amrex::Warning("erf.terrain_type = Moving is deprecated; please replace Moving by MovingFittedMesh");
             terrain_type = TerrainType::MovingFittedMesh;
         } else if (terrain_type_temp == "Static") {
             amrex::Warning("erf.terrain_type = Static is deprecated; please replace Static by StaticFittedMesh");
             terrain_type = TerrainType::StaticFittedMesh;
         } else {
             pp.query_enum_case_insensitive("terrain_type",terrain_type);
         }
  
         if (terrain_type == TerrainType::StaticFittedMesh ||
             terrain_type == TerrainType::MovingFittedMesh) {
             mesh_type = MeshType::VariableDz;
         }
  
         int n_zlevels = pp.countval("terrain_z_levels");
         if (n_zlevels > 0)
         {
             if (terrain_type == TerrainType::None) {
                 terrain_type = TerrainType::StaticFittedMesh;
             }
             if (mesh_type == MeshType::ConstantDz) {
                 mesh_type    = MeshType::StretchedDz;
             }
         }
  
         // Use lagged_delta_rt in the fast integrator?
         pp.query("use_lagged_delta_rt", use_lagged_delta_rt);
  
         // These default to true but are used for unit testing
         pp.query("use_gravity", use_gravity);
         gravity = use_gravity? CONST_GRAV: 0.0;
  
         pp.query("c_p", c_p);
         rdOcp = R_d / c_p;
  
         read_int_string(max_level, "anelastic", anelastic, 0);
  
         // *******************************************************************************
         // Read substepping_type and allow for different values at each level
         // *******************************************************************************
         substepping_type.resize(max_level+1);
  
         for (int i = 0; i <= max_level; i++) {
             substepping_type[i] = SubsteppingType::Implicit;
         }
  
         int nvals = pp.countval("substepping_type");
         AMREX_ALWAYS_ASSERT(nvals == 0 || nvals == 1 || nvals >= max_level+1);
  
         if (nvals == 1) {
             pp.query_enum_case_insensitive("substepping_type",substepping_type[0]);
             for (int i = 1; i <= max_level; i++) {
                 substepping_type[i] = substepping_type[0];
             }
         } else if (nvals > 1) { // in this case we have asserted nvals >= max_level+1
             for (int i = 0; i <= max_level; i++) {
                 pp.query_enum_case_insensitive("substepping_type",substepping_type[i],i);
             }
         }
  
         // *******************************************************************************
         // Error check on deprecated input
         // *******************************************************************************
         int nvals_old = pp.countval("no_substepping");
         if (nvals_old > 0) {
             amrex::Abort("The no_substepping flag is deprecated -- set substepping_type instead");
         }
         // *******************************************************************************
  
         bool any_anelastic = false;
         for (int i = 0; i <= max_level; ++i) {
             if (anelastic[i] == 1) any_anelastic = true;
         }
  
         // If anelastic at all, we do not advect rho -- it is always == rho0
         if (any_anelastic == 1) {
             constant_density = true;
             project_initial_velocity = true;
             buoyancy_type = 3; // (This isn't actually used when anelastic is set)
         } else {
             pp.query("project_initial_velocity", project_initial_velocity);
  
             constant_density = false;  // We default to false but allow the user to set it
             pp.query("constant_density", constant_density);
         }
  
         // *******************************************************************************
  
         pp.query("ncorr", ncorr);
         pp.query("poisson_abstol", poisson_abstol);
         pp.query("poisson_reltol", poisson_reltol);
  
         for (int lev = 0; lev <= max_level; lev++) {
             if (anelastic[lev] != 0)
             {
                 substepping_type[lev] = SubsteppingType::None;
             }
         }
  
         pp.query("force_stage1_single_substep", force_stage1_single_substep);
  
         // Include Coriolis forcing?
         pp.query("use_coriolis", use_coriolis);
  
         // Include Rayleigh damping (separate flags for each variable)
         pp.query("rayleigh_damp_U", rayleigh_damp_U);
         pp.query("rayleigh_damp_V", rayleigh_damp_V);
         pp.query("rayleigh_damp_W", rayleigh_damp_W);
         pp.query("rayleigh_damp_T", rayleigh_damp_T);
         pp.query("rayleigh_dampcoef", rayleigh_dampcoef);
         pp.query("rayleigh_zdamp", rayleigh_zdamp);
  
         // Flag to do explicit MOST formulation
         pp.query("use_explicit_most",use_explicit_most);
  
         // Flag to do MOST rotations with terrain
         pp.query("use_rotate_most",use_rotate_most);
         if (use_rotate_most) {
             AMREX_ASSERT_WITH_MESSAGE(terrain_type != TerrainType::None,"MOST stress rotations are only valid with terrain!");
             AMREX_ASSERT_WITH_MESSAGE(use_explicit_most, "MOST Stress rotations are only valid with explicit MOST!");
         }
  
         // 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);
  
         // Which type of inflow turbulent generation
         pert_type = PerturbationType::None; // Default
         pp.query_enum_case_insensitive("perturbation_type",pert_type);
  
         amrex::Vector<amrex::Real> abl_pressure_grad_in = {0.0, 0.0, 0.0};
         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 = {0.0, 0.0, 0.0};
         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();
         }
  
         pp.query("add_custom_rhotheta_forcing", custom_rhotheta_forcing);
         pp.query("add_custom_moisture_forcing", custom_moisture_forcing);
         pp.query("add_custom_w_subsidence", custom_w_subsidence);
         pp.query("add_custom_geostrophic_profile", custom_geostrophic_profile);
         pp.query("custom_forcing_uses_primitive_vars", custom_forcing_prim_vars);
  
         pp.query("nudging_from_input_sounding", nudging_from_input_sounding);
  
         have_geo_wind_profile = (!abl_geo_wind_table.empty() || custom_geostrophic_profile);
         AMREX_ALWAYS_ASSERT_WITH_MESSAGE(!(!abl_geo_wind_table.empty() && custom_geostrophic_profile),
             "Should not have both abl_geo_wind_table and custom_geostrophic_profile set.");
  
         pp.query("Ave_Plane", ave_plane);
  
         pp.query("mp_clouds", do_cloud);
         pp.query("mp_precip", do_precip);
         pp.query("use_moist_background", use_moist_background);
  
         // Use numerical diffusion?
         pp.query("num_diff_coeff",num_diff_coeff);
         AMREX_ASSERT_WITH_MESSAGE(( (num_diff_coeff >= 0.) && (num_diff_coeff <= 1.) ),
                                   "Numerical diffusion coefficient must be between 0 & 1.");
         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 *= std::pow(2.0,-6);
         }
  
         // Use monotonic advection?
         pp.query("use_mono_adv",use_mono_adv);
  
            advChoice.init_params();
           diffChoice.init_params();
         spongeChoice.init_params();
  
         turbChoice.resize(max_level+1);
         for (int lev = 0; lev <= max_level; lev++) {
             turbChoice[lev].init_params(lev,max_level);
         }
  
         // 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::Abort("YSU cannot use ERF coriolis frequency if not using coriolis");
                 }
             }
         }
  
  
         // Which type of multilevel coupling
         coupling_type = CouplingType::TwoWay; // Default
         pp.query_enum_case_insensitive("coupling_type",coupling_type);
  
         // Which type of windfarm model
         windfarm_type = WindFarmType::None; // Default
         pp.query_enum_case_insensitive("windfarm_type",windfarm_type);
  
         static std::string windfarm_loc_type_string = "None";
         windfarm_loc_type = WindFarmLocType::None;
         pp.query_enum_case_insensitive("windfarm_loc_type",windfarm_loc_type);
  
         pp.query("windfarm_loc_table",  windfarm_loc_table);
         pp.query("windfarm_spec_table", windfarm_spec_table);
         pp.query("windfarm_blade_table", windfarm_blade_table);
         pp.query("windfarm_airfoil_tables", windfarm_airfoil_tables);
         pp.query("windfarm_spec_table_extra", windfarm_spec_table_extra);
  
         // Sampling distance upstream of the turbine to find the
         // incoming free stream velocity as a factor of the diameter of the
         // turbine. ie. the sampling distance will be this number multiplied
         // by the diameter of the turbine
         pp.query("sampling_distance_by_D", sampling_distance_by_D);
         pp.query("turb_disk_angle_from_x", turb_disk_angle);
  
         pp.query("windfarm_x_shift",windfarm_x_shift);
         pp.query("windfarm_y_shift",windfarm_y_shift);
         // Test if time averaged data is to be output
         pp.query("time_avg_vel",time_avg_vel);
  
         check_params(max_level);
     }

Here is the call graph for this function:

◆ read_int_string()

void SolverChoice::read_int_string	(	int	max_level,
		const char *	string_to_read,
		amrex::Vector< int > &	vec_to_fill,
		int	default_int
	)

inline

     {
         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 (nvals == 0) {
             for (int i = 0; i <= max_level; ++i) vec_to_fill.push_back(default_int);
         } else if (nvals == 1) {
             for (int i = 0; i <= max_level; ++i) vec_to_fill.push_back(temp[0]);
         } else {
             for (int i = 0; i <= max_level; ++i) vec_to_fill.push_back(temp[i]);
         }
     }

Referenced by init_params().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_flat_terrain_flag()

static void SolverChoice::set_flat_terrain_flag ( )

inlinestatic

     {
         terrain_is_flat = true;
     }

Referenced by ProblemBase::init_custom_terrain().

Here is the caller graph for this function:

Member Data Documentation

◆ abl_driver_type

ABLDriverType SolverChoice::abl_driver_type

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

◆ abl_geo_forcing

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

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

◆ abl_geo_wind_table

std::string SolverChoice::abl_geo_wind_table

Referenced by build_coriolis_forcings(), and init_params().

◆ abl_pressure_grad

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

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

◆ advChoice

AdvChoice SolverChoice::advChoice

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

◆ anelastic

amrex::Vector<int> SolverChoice::anelastic

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

◆ ave_plane

int SolverChoice::ave_plane {2}

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

◆ buoyancy_type

int SolverChoice::buoyancy_type = 1

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

◆ c_p

amrex::Real SolverChoice::c_p = Cp_d

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

◆ constant_density

int SolverChoice::constant_density = 0

Referenced by erf_slow_rhs_pre(), and init_params().

◆ coriolis_3d

bool SolverChoice::coriolis_3d = true

Referenced by build_coriolis_forcings().

◆ coriolis_factor

amrex::Real SolverChoice::coriolis_factor = 0.0

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

◆ cosphi

amrex::Real SolverChoice::cosphi = 0.0

Referenced by build_coriolis_forcings(), and make_mom_sources().

◆ coupling_type

CouplingType SolverChoice::coupling_type

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

◆ custom_forcing_prim_vars

bool SolverChoice::custom_forcing_prim_vars = false

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

◆ custom_geostrophic_profile

bool SolverChoice::custom_geostrophic_profile = false

Referenced by init_params().

◆ custom_moisture_forcing

bool SolverChoice::custom_moisture_forcing = false

Referenced by init_params(), and make_sources().

◆ custom_rhotheta_forcing

bool SolverChoice::custom_rhotheta_forcing = false

Referenced by init_params(), and make_sources().

◆ custom_w_subsidence

bool SolverChoice::custom_w_subsidence = false

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

◆ diffChoice

DiffChoice SolverChoice::diffChoice

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

◆ do_cloud

bool SolverChoice::do_cloud {true}

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

◆ do_forest_drag

bool SolverChoice::do_forest_drag {false}

Referenced by make_mom_sources().

◆ do_precip

bool SolverChoice::do_precip {true}

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

◆ dz0

amrex::Real SolverChoice::dz0

Referenced by init_params().

◆ force_stage1_single_substep

int SolverChoice::force_stage1_single_substep = 1

Referenced by display(), and init_params().

◆ gravity

amrex::Real SolverChoice::gravity

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

◆ grid_stretching_ratio

amrex::Real SolverChoice::grid_stretching_ratio = 0

Referenced by init_params().

◆ have_geo_wind_profile

bool SolverChoice::have_geo_wind_profile {false}

Referenced by init_params(), and make_mom_sources().

◆ lsm_type

LandSurfaceType SolverChoice::lsm_type

Referenced by init_params().

◆ mesh_type

MeshType SolverChoice::mesh_type = MeshType::ConstantDz

inlinestatic

◆ moisture_type

MoistureType SolverChoice::moisture_type

Referenced by Kessler::AdvanceKessler(), check_params(), SAM::Cloud(), erf_slow_rhs_post(), erf_slow_rhs_pre(), SAM::IceFall(), init_params(), make_buoyancy(), make_sources(), SAM::Precip(), SAM::PrecipFall(), Kessler::Qmoist_Restart_Vars(), SAM::Qmoist_Restart_Vars(), and Radiation::Radiation().

◆ ncorr

int SolverChoice::ncorr = 1

Referenced by init_params().

◆ nudging_from_input_sounding

bool SolverChoice::nudging_from_input_sounding = false

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

◆ num_diff_coeff

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

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

◆ pert_type

PerturbationType SolverChoice::pert_type

Referenced by init_params(), and make_sources().

◆ poisson_abstol

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

Referenced by init_params().

◆ poisson_reltol

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

Referenced by init_params().

◆ pp_prefix

std::string SolverChoice::pp_prefix {"erf"}

Referenced by build_coriolis_forcings(), and init_params().

◆ project_initial_velocity

bool SolverChoice::project_initial_velocity = false

Referenced by init_params().

◆ rayleigh_damp_T

bool SolverChoice::rayleigh_damp_T = false

Referenced by init_params(), and make_sources().

◆ rayleigh_damp_U

bool SolverChoice::rayleigh_damp_U = false

Referenced by init_params(), and make_mom_sources().

◆ rayleigh_damp_V

bool SolverChoice::rayleigh_damp_V = false

Referenced by init_params(), and make_mom_sources().

◆ rayleigh_damp_W

bool SolverChoice::rayleigh_damp_W = false

Referenced by init_params(), and make_mom_sources().

◆ rayleigh_dampcoef

amrex::Real SolverChoice::rayleigh_dampcoef = 0.2

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

◆ rayleigh_zdamp

amrex::Real SolverChoice::rayleigh_zdamp = 500.0

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

◆ rayleigh_ztop

amrex::Real SolverChoice::rayleigh_ztop

Referenced by make_mom_sources(), and make_sources().

◆ rdOcp

amrex::Real SolverChoice::rdOcp

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

◆ RhoQc_comp

int SolverChoice::RhoQc_comp {-1}

Referenced by ComputeTurbulentViscosity(), DiffusionSrcForState_N(), DiffusionSrcForState_T(), and init_params().

◆ RhoQr_comp

int SolverChoice::RhoQr_comp {-1}

Referenced by ComputeTurbulentViscosity(), DiffusionSrcForState_N(), DiffusionSrcForState_T(), and init_params().

◆ RhoQv_comp

int SolverChoice::RhoQv_comp {-1}

Referenced by ComputeTurbulentViscosity(), DiffusionSrcForState_N(), DiffusionSrcForState_T(), and init_params().

◆ sampling_distance_by_D

amrex::Real SolverChoice::sampling_distance_by_D = -1.0

Referenced by check_params(), and init_params().

◆ sinphi

amrex::Real SolverChoice::sinphi = 0.0

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

◆ spongeChoice

SpongeChoice SolverChoice::spongeChoice

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

◆ substepping_type

amrex::Vector<SubsteppingType> SolverChoice::substepping_type

Referenced by display(), and init_params().

◆ terrain_is_flat

bool SolverChoice::terrain_is_flat = false

inlinestatic

Referenced by set_flat_terrain_flag().

◆ terrain_type

TerrainType SolverChoice::terrain_type = TerrainType::None

inlinestatic

Referenced by check_params(), display(), erf_make_tau_terms(), erf_slow_rhs_post(), erf_slow_rhs_pre(), init_params(), ERF::init_stuff(), make_mom_sources(), make_sources(), and ERF::update_diffusive_arrays().

◆ test_mapfactor

bool SolverChoice::test_mapfactor = false

Referenced by init_params().

◆ time_avg_vel

bool SolverChoice::time_avg_vel = false

Referenced by init_params().

◆ turb_disk_angle

amrex::Real SolverChoice::turb_disk_angle = -1.0

Referenced by check_params(), and init_params().

◆ turbChoice

amrex::Vector<TurbChoice> SolverChoice::turbChoice

Referenced by check_params(), ComputeTurbulentViscosity(), DiffusionSrcForState_N(), DiffusionSrcForState_T(), display(), erf_make_tau_terms(), erf_slow_rhs_post(), erf_slow_rhs_pre(), init_params(), and make_sources().

◆ use_coriolis

bool SolverChoice::use_coriolis = false

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

◆ use_explicit_most

bool SolverChoice::use_explicit_most = false

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

◆ use_gravity

bool SolverChoice::use_gravity = false

Referenced by display(), and init_params().

◆ use_lagged_delta_rt

bool SolverChoice::use_lagged_delta_rt = true

Referenced by check_params(), and init_params().

◆ use_moist_background

bool SolverChoice::use_moist_background {false}

Referenced by init_params().

◆ use_mono_adv

bool SolverChoice::use_mono_adv {false}

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

◆ use_num_diff

bool SolverChoice::use_num_diff {false}

Referenced by init_params(), and make_sources().

◆ use_rotate_most

bool SolverChoice::use_rotate_most = false

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

◆ windfarm_airfoil_tables

std::string SolverChoice::windfarm_airfoil_tables

Referenced by init_params().

◆ windfarm_blade_table

std::string SolverChoice::windfarm_blade_table

Referenced by init_params().

◆ windfarm_loc_table

std::string SolverChoice::windfarm_loc_table

Referenced by init_params().

◆ windfarm_loc_type

WindFarmLocType SolverChoice::windfarm_loc_type

Referenced by check_params(), and init_params().

◆ windfarm_spec_table

std::string SolverChoice::windfarm_spec_table

Referenced by init_params().

◆ windfarm_spec_table_extra

std::string SolverChoice::windfarm_spec_table_extra

Referenced by init_params().

◆ windfarm_type

WindFarmType SolverChoice::windfarm_type

Referenced by check_params(), and init_params().

◆ windfarm_x_shift

amrex::Real SolverChoice::windfarm_x_shift = -1.0

Referenced by check_params(), and init_params().

◆ windfarm_y_shift

amrex::Real SolverChoice::windfarm_y_shift = -1.0

Referenced by check_params(), and init_params().

◆ zsurf

amrex::Real SolverChoice::zsurf = 0.0

Referenced by init_params().

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

Source/DataStructs/ERF_DataStruct.H

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

◆ build_coriolis_forcings()

◆ check_params()

◆ display()

◆ init_params()

◆ read_int_string()

◆ set_flat_terrain_flag()

Member Data Documentation

◆ abl_driver_type

◆ abl_geo_forcing

◆ abl_geo_wind_table

◆ abl_pressure_grad

◆ advChoice

◆ anelastic

◆ ave_plane

◆ buoyancy_type

◆ c_p

◆ constant_density

◆ coriolis_3d

◆ coriolis_factor

◆ cosphi

◆ coupling_type

◆ custom_forcing_prim_vars

◆ custom_geostrophic_profile

◆ custom_moisture_forcing

◆ custom_rhotheta_forcing

◆ custom_w_subsidence

◆ diffChoice

◆ do_cloud

◆ do_forest_drag

◆ do_precip

◆ dz0

◆ force_stage1_single_substep

◆ gravity

◆ grid_stretching_ratio

◆ have_geo_wind_profile

◆ lsm_type

◆ mesh_type

◆ moisture_type

◆ ncorr

◆ nudging_from_input_sounding

◆ num_diff_coeff

◆ pert_type

◆ poisson_abstol

◆ poisson_reltol

◆ pp_prefix

◆ project_initial_velocity

◆ rayleigh_damp_T

◆ rayleigh_damp_U

◆ rayleigh_damp_V

◆ rayleigh_damp_W

◆ rayleigh_dampcoef

◆ rayleigh_zdamp

◆ rayleigh_ztop

◆ rdOcp

◆ RhoQc_comp

◆ RhoQr_comp

◆ RhoQv_comp

◆ sampling_distance_by_D

◆ sinphi

◆ spongeChoice

◆ substepping_type

◆ terrain_is_flat

◆ terrain_type

◆ test_mapfactor

◆ time_avg_vel

◆ turb_disk_angle

◆ turbChoice

◆ use_coriolis

◆ use_explicit_most

◆ use_gravity

◆ use_lagged_delta_rt

◆ use_moist_background

◆ use_mono_adv

◆ use_num_diff