all_parameters.cpp

#include <deal.II/base/mpi.h>
#include <deal.II/base/utilities.h>
#include <deal.II/base/patterns.h>

#include "parameters/all_parameters.h"

//for checking output directories
#include <sys/types.h>
#include <sys/stat.h>

namespace PHiLiP {
namespace Parameters {

AllParameters::AllParameters ()
    : manufactured_convergence_study_param(ManufacturedConvergenceStudyParam())
    , ode_solver_param(ODESolverParam())
    , linear_solver_param(LinearSolverParam())
    , euler_param(EulerParam())
    , navier_stokes_param(NavierStokesParam())
    , reduced_order_param(ReducedOrderModelParam())
    , hyper_reduction_param(HyperReductionParam())
    , burgers_param(BurgersParam())
    , physics_model_param(PhysicsModelParam())
    , grid_refinement_study_param(GridRefinementStudyParam())
    , artificial_dissipation_param(ArtificialDissipationParam())
    , limiter_param(LimiterParam())
    , flow_solver_param(FlowSolverParam())
    , mesh_adaptation_param(MeshAdaptationParam())
    , functional_param(FunctionalParam())
    , time_refinement_study_param(TimeRefinementStudyParam())
    , pcout(std::cout, dealii::Utilities::MPI::this_mpi_process(MPI_COMM_WORLD)==0)
{ }

void AllParameters::declare_parameters (dealii::ParameterHandler &prm)
{
    const int mpi_rank = dealii::Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
    dealii::ConditionalOStream pcout(std::cout, mpi_rank==0);
    pcout << "Declaring inputs." << std::endl;
    prm.declare_entry("dimension", "-1",
                      dealii::Patterns::Integer(),
                      "Number of dimensions");

    prm.declare_entry("number_of_species", "1",
                      dealii::Patterns::Integer(1, dealii::Patterns::Integer::max_int_value),
                      "Number of species. "
                      "Default number of species is 1. For number_of_species > 1, only real_gas pde_type can be used.");

    prm.declare_entry("run_type", "integration_test",
                      dealii::Patterns::Selection(
                      " integration_test | "
                      " flow_simulation"),
                      "Type of run (default is integration_test). "
                      "Choices are  <integration_test | flow_simulation>.");

    prm.declare_entry("mesh_type", "default_triangulation",
                      dealii::Patterns::Selection(
                      " default_triangulation | "
                      " triangulation | "
                      " parallel_shared_triangulation | "
                      " parallel_distributed_triangulation"),
                      "Type of triangulation to be used."
                      "Note: parralel_distributed_triangulation not availible int 1D."
                      " <default_triangulation | "
                      "  triangulation | "
                      "  parallel_shared_triangulation |"
                      "  parallel_distributed_triangulation>.");
                      
    prm.declare_entry("overintegration", "0",
                      dealii::Patterns::Integer(),
                      "Number of extra quadrature points to use."
                      "If overintegration=0, then we use n_quad = soln_degree + 1.");

    prm.declare_entry("use_weak_form", "true",
                      dealii::Patterns::Bool(),
                      "Use weak form by default. If false, use strong form.");

    prm.declare_entry("flux_nodes_type", "GL",
                      dealii::Patterns::Selection(
                      "GL | GLL"),
                      "Flux nodes type, default is GL for uncollocated. NOTE: Solution nodes are type GLL."
                      "Choices are <GL | GLL>.");

    prm.declare_entry("use_split_form", "false",
                      dealii::Patterns::Bool(),
                      "Use original form by defualt. Otherwise, split the fluxes.");

    prm.declare_entry("two_point_num_flux_type", "KG",
                      dealii::Patterns::Selection(
                      "KG | IR | CH | Ra"),
                      "Two point flux type. "
                      "Choices for single species are <KG | IR | CH | Ra>."
                      "Multi-species only supports <KG>.");

    prm.declare_entry("use_curvilinear_split_form", "false",
                      dealii::Patterns::Bool(),
                      "Use original form by defualt. Otherwise, split the curvilinear fluxes.");

    prm.declare_entry("store_residual_cpu_time", "false",
                      dealii::Patterns::Bool(),
                      "Do not store the residual local processor cpu time by default. Store the residual cpu time if true.");

    prm.declare_entry("use_weight_adjusted_mass", "false",
                      dealii::Patterns::Bool(),
                      "Use original form by defualt. Otherwise, use the weight adjusted low storage mass matrix for curvilinear.");

    prm.declare_entry("all_boundaries_are_periodic", "false",
                      dealii::Patterns::Bool(),
                      "Flag to signal that all boundaries are periodic; if true surface flux nodes will not be stored for efficiency. "
                      "Default is false; hence surface flux nodes are indeed stored by default.");

    prm.declare_entry("check_same_coords_in_weak_dg", "true",
                      dealii::Patterns::Bool(),
                      "Flag to check if the coordinates of two points are same where expected in weak DG."
                      "Default is true; set to false if you have periodic boundaries in your domain since it currently does not consider that case and will print large warning messages.");

    prm.declare_entry("use_curvilinear_grid", "false",
                      dealii::Patterns::Bool(),
                      "Use straight grid by default. Curvilinear is true. Only used in taylor_green_scaling test.");

    prm.declare_entry("use_energy", "false",
                      dealii::Patterns::Bool(),
                      "Not calculate energy by default. Otherwise, get energy per iteration.");

    prm.declare_entry("use_L2_norm", "false",
                      dealii::Patterns::Bool(),
                      "Not calculate L2 norm by default (M+K). Otherwise, get L2 norm per iteration.");

    prm.declare_entry("flux_reconstruction", "cDG",
                      dealii::Patterns::Selection(
                      "cDG | cSD | cHU | cNegative | cNegative2 | cPlus | c10Thousand | cHULumped | user_specified_value"),
                      "Flux Reconstruction. "
                      "Choices are "
                      " <cDG | cSD | cHU | cNegative | cNegative2 | cPlus | c10Thousand | cHULumped | user_specified_value>.");

    prm.declare_entry("FR_user_specified_correction_parameter_value", "0.0",
                      dealii::Patterns::Double(-dealii::Patterns::Double::max_double_value, dealii::Patterns::Double::max_double_value),
                      "User specified flux recontruction correction parameter value. "
                      "Enter a 1D correction parameter. "
                      "Internally, the input c value is divided by 2 to account for the basis and adjusted for the deal.ii reference element. "
                      "Default value is 0.0. ");

    prm.declare_entry("flux_reconstruction_aux", "kDG",
                      dealii::Patterns::Selection(
                      "kDG | kSD | kHU | kNegative | kNegative2 | kPlus | k10Thousand"),
                      "Flux Reconstruction for Auxiliary Equation. "
                      "Choices are <kDG | kSD | kHU | kNegative | kNegative2 | kPlus | k10Thousand>.");

    prm.declare_entry("sipg_penalty_factor", "1.0",
                      dealii::Patterns::Double(1.0,1e200),
                      "Scaling of Symmetric Interior Penalty term to ensure coercivity.");

    prm.declare_entry("use_invariant_curl_form", "false",
                      dealii::Patterns::Bool(),
                      "Use conservative curl form for metric cofactor by default. If true, then use invariant curl form.");

    prm.declare_entry("use_inverse_mass_on_the_fly", "false",
                      dealii::Patterns::Bool(),
                      "Build global mass inverse matrix and apply it. Otherwise, use inverse mass on-the-fly by default for explicit timestepping.");

    prm.declare_entry("check_valid_metric_Jacobian", "true",
                      dealii::Patterns::Bool(),
                      "Check validty of metric Jacobian when high-order grid is constructed by default. Do not check if false. Not checking is useful if the metric terms are built on the fly with operators, it reduces the memory cost for high polynomial grids. The metric Jacobian is never checked for strong form, regardless of the user input.");

    prm.declare_entry("energy_file", "energy_file",
                      dealii::Patterns::FileName(dealii::Patterns::FileName::FileType::input),
                      "Input file for energy test.");

    prm.declare_entry("test_type", "run_control",
                      dealii::Patterns::Selection(
                      " run_control | "
                      " grid_refinement_study | "
                      " stability_fr_parameter_range | "
                      " advection_limiter | "
                      " burgers_limiter | "
                      " burgers_energy_stability | "
                      " diffusion_exact_adjoint | "
                      " optimization_inverse_manufactured | "
                      " euler_gaussian_bump | "
                      " euler_gaussian_bump_enthalpy | "
                      " euler_gaussian_bump_adjoint | "
                      " euler_cylinder | "
                      " euler_cylinder_adjoint | "
                      " euler_vortex | "
                      " euler_entropy_waves | "
                      " euler_split_taylor_green | "
                      " taylor_green_scaling | "
                      " euler_bump_optimization | "
                      " euler_naca_optimization | "
                      " shock_1d | "
                      " euler_naca0012 | "
                      " reduced_order | "
                      " unsteady_reduced_order |"
                      " convection_diffusion_periodicity |"
                      " POD_adaptation | "
                      " POD_adaptive_sampling_run | "
                      " adaptive_sampling_testing | "
                      " finite_difference_sensitivity | "
                      " advection_periodicity | "
                      " dual_weighted_residual_mesh_adaptation | "
                      " anisotropic_mesh_adaptation | "
                      " taylor_green_vortex_energy_check | "
                      " taylor_green_vortex_restart_check | "
                      " homogeneous_isotropic_turbulence_initialization_check | "
                      " turbulent_channel_flow_skin_friction_check | "
                      " dipole_wall_collision_quantity_check | "
                      " turbulent_channel_flow_quantity_check | "
                      " time_refinement_study | "
                      " time_refinement_study_reference | "
                      " rrk_numerical_entropy_conservation_check | "
                      " euler_entropy_conserving_split_forms_check | "
                      " h_refinement_study_isentropic_vortex | "
                      " build_NNLS_problem |"
                      " hyper_reduction_comparison |"
                      " hyper_adaptive_sampling_run |"
                      " hyper_reduction_post_sampling |"
                      " ROM_error_post_sampling |"
                      " HROM_error_post_sampling | "
                      " hyper_adaptive_sampling_new_error |"
                      " halton_sampling_run |"
                      " naca0012_unsteady_check_quick | "
                      " khi_robustness | "
                      " low_density | "
                      " multi_species_vortex_advection | "
                      " real_gas_split_taylor_green"),
                      "The type of test we want to solve. "
                      "Choices are " 
                      " <run_control | " 
                      "  grid_refinement_study | "
                      "  stability_fr_parameter_range | "
                      "  advection_limiter | "
                      "  burgers_limiter | "
                      "  burgers_energy_stability | "
                      "  diffusion_exact_adjoint | "
                      "  optimization_inverse_manufactured | "
                      "  euler_gaussian_bump | "
                      "  euler_gaussian_bump_enthalpy | "
                      "  euler_gaussian_bump_adjoint | "
                      "  euler_cylinder | "
                      "  euler_cylinder_adjoint | "
                      "  euler_vortex | "
                      "  euler_entropy_waves | "
                      "  euler_split_taylor_green |"
                      "  taylor_green_scaling | "
                      "  euler_bump_optimization | "
                      "  euler_naca_optimization | "
                      "  shock_1d | "
                      "  euler_naca0012 | "
                      "  convection_diffusion_periodicity |"
                      "  reduced_order | "
                      "  unsteady_reduced_order | "
                      "  POD_adaptation | "
                      "  POD_adaptive_sampling_run | "
                      "  adaptive_sampling_testing | "
                      "  finite_difference_sensitivity | "
                      "  advection_periodicity | "
                      "  dual_weighted_residual_mesh_adaptation | "
                      "  anisotropic_mesh_adaptation | "
                      "  taylor_green_vortex_energy_check | "
                      "  taylor_green_vortex_restart_check | "
                      "  homogeneous_isotropic_turbulence_initialization_check | "
                      "  turbulent_channel_flow_skin_friction_check | "
                      "  dipole_wall_collision_quantity_check | "
                      "  turbulent_channel_flow_quantity_check | "
                      "  time_refinement_study | "
                      "  time_refinement_study_reference | "
                      "  rrk_numerical_entropy_conservation_check | "
                      "  euler_entropy_conserving_split_forms_check | "
                      "  h_refinement_study_isentropic_vortex | "
                      "  build_NNLS_problem |"
                      "  hyper_reduction_comparison |"
                      "  hyper_adaptive_sampling_run |"
                      "  hyper_reduction_post_sampling |"
                      "  ROM_error_post_sampling |"
                      "  HROM_error_post_sampling | "
                      "  hyper_adaptive_sampling_new_error |"
                      "  halton_sampling_run |"
                      "  naca0012_unsteady_check_quick | "
                      "  khi_robustness | "
                      "  low_density | " 
                      "  multi_species_vortex_advection | "
                      "  real_gas_split_taylor_green>.");

    prm.declare_entry("pde_type", "advection",
                      dealii::Patterns::Selection(
                      " advection | "
                      " diffusion | "
                      " convection_diffusion | "
                      " advection_vector | "
                      " burgers_inviscid | "
                      " burgers_viscous | "
                      " burgers_rewienski | "
                      " euler |"
                      " mhd |"
                      " navier_stokes |"
                      " navier_stokes_channel_flow_constant_source_term | "
                      " navier_stokes_channel_flow_constant_source_term_wall_model | "
                      " physics_model_filtered |"
                      " physics_model |"
                      " real_gas"),
                      "The PDE we want to solve. "
                      "Choices are " 
                      " <advection | " 
                      "  diffusion | "
                      "  convection_diffusion | "
                      "  advection_vector | "
                      "  burgers_inviscid | "
                      "  burgers_viscous | "
                      "  burgers_rewienski | "
                      "  euler | "
                      "  mhd |"
                      "  navier_stokes |"
                      "  navier_stokes_channel_flow_constant_source_term | "
                      "  navier_stokes_channel_flow_constant_source_term_wall_model | "
                      "  physics_model_filtered |"
                      "  physics_model |"
                      "  real_gas>.");

    prm.declare_entry("model_type", "large_eddy_simulation",
                      dealii::Patterns::Selection(
                      " large_eddy_simulation |"
                      " reynolds_averaged_navier_stokes |"
                      " navier_stokes_model"),
                      "Enum of physics models "
                      "(i.e. model equations and/or terms additional to Navier-Stokes or a chosen underlying baseline physics)."
                      "Choices are "
                      " <large_eddy_simulation | reynolds_averaged_navier_stokes | navier_stokes_model>.");

    prm.declare_entry("conv_num_flux", "lax_friedrichs",
                      dealii::Patterns::Selection(
                      " lax_friedrichs | "
                      " roe | "
                      " l2roe | "
                      " central_flux | "
                      " two_point_flux | "
                      " two_point_flux_with_lax_friedrichs_dissipation | "
                      " two_point_flux_with_roe_dissipation | "
                      " two_point_flux_with_l2roe_dissipation"),
                      "Convective numerical flux. "
                      "Choices are "
                      " <lax_friedrichs | "
                      " roe | "
                      " l2roe | "
                      " central_flux | "
                      " two_point_flux | "
                      " two_point_flux_with_lax_friedrichs_dissipation | "
                      " two_point_flux_with_roe_dissipation | "
                      " two_point_flux_with_l2roe_dissipation>.");

    prm.declare_entry("diss_num_flux", "symm_internal_penalty",
                      dealii::Patterns::Selection("symm_internal_penalty | bassi_rebay_2 | central_visc_flux"),
                      "Dissipative numerical flux. "
                      "Choices are <symm_internal_penalty | bassi_rebay_2 | central_visc_flux>.");

    prm.declare_entry("non_physical_behavior", "return_big_number",
                      dealii::Patterns::Selection("return_big_number | abort_run | print_warning"),
                      "Behavior when a nonphysical result is detected in physics, "
                      "For example negative density or NaN. "
                      "return_big_number will set the quantity to BIG_NUMBER without any warnings "
                      "abort_run will std::abort() "
                      "print_warning will return BIG_NUMBER and print a warning to console. "
                      "Choices are <return_big_number | abort_run | print_warning>.");

    prm.declare_entry("solution_vtk_files_directory_name", ".",
                      dealii::Patterns::FileName(dealii::Patterns::FileName::FileType::input),
                      "Name of directory for writing solution vtk files. Current directory by default.");

    prm.declare_entry("output_high_order_grid", "false",
                      dealii::Patterns::Bool(),
                      "Outputs the high-order mesh vtu files. False by default");

    prm.declare_entry("enable_higher_order_vtk_output", "true",
                      dealii::Patterns::Bool(),
                      "Enable writing of higher-order vtk files. True by default; "
                      "number of subdivisions is chosen according to the max of grid_degree and poly_degree.");

    prm.declare_entry("output_face_results_vtk", "false",
                      dealii::Patterns::Bool(),
                      "Outputs the surface solution vtk files. False by default");

    prm.declare_entry("do_renumber_dofs", "true",
                      dealii::Patterns::Bool(),
                      "Flag for renumbering DOFs using Cuthill-McKee renumbering. True by default. Set to false if doing 3D unsteady flow simulations.");

    prm.declare_entry("renumber_dofs_type", "CuthillMckee",
                      dealii::Patterns::Selection(
                      "CuthillMckee"),
                      "Renumber the dof handler type. Currently the only choice is Cuthill-Mckee.");

    prm.declare_entry("matching_surface_jac_det_tolerance", "1.3e-11",
                      dealii::Patterns::Double(0, dealii::Patterns::Double::max_double_value),
                      "Tolerance for checking that the determinant of surface jacobians at element faces matches. "
                      "Note: Currently only used in weak dg.");

    prm.declare_entry("chemistry_input_file", "",
                      dealii::Patterns::FileName(dealii::Patterns::FileName::FileType::input),
                      "Filename of the chemistry data file that contains the properties of the species used in simulation. (ex. H2_O2.kinetics");

    prm.declare_entry("wall_model_input_from_second_element", "true",
                      dealii::Patterns::Bool(),
                      "Flag for using second element as wall model input. If false, uses buffer (i.e. wall-adjacent) element.");

    prm.declare_entry("use_projected_entropy_variables_for_nsfr_boundary_term", "false",
                      dealii::Patterns::Bool(),
                      "Flag for using projected entropy variables for NSFR boundary term. "
                      "Default is false since boundary condition was verified using conservative solution.");

    Parameters::LinearSolverParam::declare_parameters (prm);
    Parameters::ManufacturedConvergenceStudyParam::declare_parameters (prm);
    Parameters::ODESolverParam::declare_parameters (prm);
    Parameters::EulerParam::declare_parameters (prm);
    Parameters::NavierStokesParam::declare_parameters (prm);
    Parameters::PhysicsModelParam::declare_parameters (prm);
    Parameters::ReducedOrderModelParam::declare_parameters (prm);
    Parameters::HyperReductionParam::declare_parameters (prm);
    Parameters::BurgersParam::declare_parameters (prm);
    Parameters::GridRefinementStudyParam::declare_parameters (prm);
    Parameters::ArtificialDissipationParam::declare_parameters (prm);
    Parameters::LimiterParam::declare_parameters(prm);
    Parameters::MeshAdaptationParam::declare_parameters (prm);
    Parameters::FlowSolverParam::declare_parameters (prm);
    Parameters::FunctionalParam::declare_parameters (prm);
    Parameters::TimeRefinementStudyParam::declare_parameters (prm);

    pcout << "Done declaring inputs." << std::endl;
}

void AllParameters::parse_parameters (dealii::ParameterHandler &prm)
{
    pcout << "Parsing main input..." << std::endl;

    dimension = prm.get_integer("dimension");
    number_of_species = prm.get_integer("number_of_species");

    const std::string run_type_string = prm.get("run_type");
    if      (run_type_string == "integration_test") { run_type = integration_test; }
    else if (run_type_string == "flow_simulation")  { run_type = flow_simulation; }

    const std::string mesh_type_string = prm.get("mesh_type");
    if      (mesh_type_string == "default_triangulation")              { mesh_type = default_triangulation; }
    else if (mesh_type_string == "triangulation")                      { mesh_type = triangulation; }
    else if (mesh_type_string == "parallel_shared_triangulation")      { mesh_type = parallel_shared_triangulation; }
    else if (mesh_type_string == "parallel_distributed_triangulation") { mesh_type = parallel_distributed_triangulation; }

const std::string test_string = prm.get("test_type");
    if      (test_string == "run_control")                              { test_type = run_control; }
    else if (test_string == "grid_refinement_study")                    { test_type = grid_refinement_study; }
    else if (test_string == "stability_fr_parameter_range")             { test_type = stability_fr_parameter_range; }
    else if (test_string == "advection_limiter")                        { test_type = advection_limiter; }
    else if (test_string == "burgers_limiter")                          { test_type = burgers_limiter; }
    else if (test_string == "burgers_energy_stability")                 { test_type = burgers_energy_stability; }
    else if (test_string == "diffusion_exact_adjoint")                  { test_type = diffusion_exact_adjoint; }
    else if (test_string == "euler_gaussian_bump")                      { test_type = euler_gaussian_bump; }
    else if (test_string == "euler_gaussian_bump_enthalpy")             { test_type = euler_gaussian_bump_enthalpy; }
    else if (test_string == "euler_gaussian_bump_adjoint")              { test_type = euler_gaussian_bump_adjoint; }
    else if (test_string == "euler_cylinder")                           { test_type = euler_cylinder; }
    else if (test_string == "euler_cylinder_adjoint")                   { test_type = euler_cylinder_adjoint; }
    else if (test_string == "euler_vortex")                             { test_type = euler_vortex; }
    else if (test_string == "euler_entropy_waves")                      { test_type = euler_entropy_waves; }
    else if (test_string == "advection_periodicity")                    { test_type = advection_periodicity; }
    else if (test_string == "convection_diffusion_periodicity")         { test_type = convection_diffusion_periodicity; }
    else if (test_string == "euler_split_taylor_green")                 { test_type = euler_split_taylor_green; }
    else if (test_string == "taylor_green_scaling")                     { test_type = taylor_green_scaling; }
    else if (test_string == "euler_bump_optimization")                  { test_type = euler_bump_optimization; }
    else if (test_string == "euler_naca_optimization")                  { test_type = euler_naca_optimization; }
    else if (test_string == "shock_1d")                                 { test_type = shock_1d; }
    else if (test_string == "reduced_order")                            { test_type = reduced_order; }
    else if (test_string == "unsteady_reduced_order")                   { test_type = unsteady_reduced_order; }
    else if (test_string == "POD_adaptation")                           { test_type = POD_adaptation; }
    else if (test_string == "POD_adaptive_sampling_run")                { test_type = POD_adaptive_sampling_run; }
    else if (test_string == "adaptive_sampling_testing")                { test_type = adaptive_sampling_testing; }
    else if (test_string == "finite_difference_sensitivity")            { test_type = finite_difference_sensitivity; }
    else if (test_string == "euler_naca0012")                           { test_type = euler_naca0012; }
    else if (test_string == "optimization_inverse_manufactured")        { test_type = optimization_inverse_manufactured; }
    else if (test_string == "dual_weighted_residual_mesh_adaptation")   { test_type = dual_weighted_residual_mesh_adaptation; }
    else if (test_string == "anisotropic_mesh_adaptation")              { test_type = anisotropic_mesh_adaptation; }
    else if (test_string == "taylor_green_vortex_energy_check")         { test_type = taylor_green_vortex_energy_check; }
    else if (test_string == "taylor_green_vortex_restart_check")        { test_type = taylor_green_vortex_restart_check; }
    else if (test_string == "homogeneous_isotropic_turbulence_initialization_check")
                                                                        { test_type = homogeneous_isotropic_turbulence_initialization_check; }
    else if (test_string == "turbulent_channel_flow_skin_friction_check")
                                                                        { test_type = turbulent_channel_flow_skin_friction_check; }
    else if (test_string == "dipole_wall_collision_quantity_check")     { test_type = dipole_wall_collision_quantity_check; }
    else if (test_string == "turbulent_channel_flow_quantity_check")    { test_type = turbulent_channel_flow_quantity_check; }
    else if (test_string == "time_refinement_study")                    { test_type = time_refinement_study; }
    else if (test_string == "time_refinement_study_reference")          { test_type = time_refinement_study_reference; }
    else if (test_string == "h_refinement_study_isentropic_vortex")     { test_type = h_refinement_study_isentropic_vortex; }
    else if (test_string == "rrk_numerical_entropy_conservation_check") { test_type = rrk_numerical_entropy_conservation_check; }
    else if (test_string == "euler_entropy_conserving_split_forms_check") 
                                                                        { test_type = euler_entropy_conserving_split_forms_check; }
    else if (test_string == "h_refinement_study_isentropic_vortex")     { test_type = h_refinement_study_isentropic_vortex; }
    else if (test_string == "khi_robustness")                           { test_type = khi_robustness; }
    else if (test_string == "build_NNLS_problem")                       { test_type = build_NNLS_problem; }
    else if (test_string == "hyper_reduction_comparison")               { test_type = hyper_reduction_comparison; }
    else if (test_string == "hyper_adaptive_sampling_run")              { test_type = hyper_adaptive_sampling_run; }
    else if (test_string == "hyper_reduction_post_sampling")            { test_type = hyper_reduction_post_sampling; }
    else if (test_string == "ROM_error_post_sampling")                  { test_type = ROM_error_post_sampling; }
    else if (test_string == "HROM_error_post_sampling")                 { test_type = HROM_error_post_sampling; }
    else if (test_string == "hyper_adaptive_sampling_new_error")        { test_type = hyper_adaptive_sampling_new_error; }
    else if (test_string == "halton_sampling_run")                      { test_type = halton_sampling_run; }
    else if (test_string == "low_density")                              { test_type = low_density; }
    else if (test_string == "naca0012_unsteady_check_quick")            { test_type = naca0012_unsteady_check_quick; }
    else if (test_string == "multi_species_vortex_advection")           { test_type = multi_species_vortex_advection; }
    else if (test_string == "real_gas_split_taylor_green")              { test_type = real_gas_split_taylor_green; }
    
    // WARNING: Must assign model_type before pde_type
    const std::string model_string = prm.get("model_type");
    if (model_string == "large_eddy_simulation") { model_type = large_eddy_simulation; }
    else if (model_string == "navier_stokes_model") { model_type = navier_stokes_model; }
    else if (model_string == "reynolds_averaged_navier_stokes") { model_type = reynolds_averaged_navier_stokes; }

    const std::string pde_string = prm.get("pde_type");
    if (pde_string == "advection") {
        pde_type = advection;
        nstate = 1;
    } else if (pde_string == "advection_vector") {
        pde_type = advection_vector;
        nstate = 2;
    } else if (pde_string == "diffusion") {
        pde_type = diffusion;
        nstate = 1;
    } else if (pde_string == "convection_diffusion") {
        pde_type = convection_diffusion;
        nstate = 1;
    } else if (pde_string == "burgers_inviscid") {
        pde_type = burgers_inviscid;
        nstate = dimension;
    } else if (pde_string == "burgers_viscous") {
        pde_type = burgers_viscous;
        nstate = dimension;
    } else if (pde_string == "burgers_rewienski") {
        pde_type = burgers_rewienski;
        nstate = dimension;
    } else if (pde_string == "euler") {
        pde_type = euler;
        nstate = dimension+2;
    }
    else if (pde_string == "navier_stokes") {
        pde_type = navier_stokes;
        nstate = dimension+2;
    }
    else if (pde_string == "navier_stokes_channel_flow_constant_source_term") {
        pde_type = navier_stokes_channel_flow_constant_source_term;
        nstate = dimension+2; 
    }
    else if (pde_string == "navier_stokes_channel_flow_constant_source_term_wall_model") {
        pde_type = navier_stokes_channel_flow_constant_source_term_wall_model;
        nstate = dimension+2; 
        using_wall_model = true;
    }
    else if (pde_string == "physics_model") {
        pde_type = physics_model;
        if (model_type == large_eddy_simulation || model_type == navier_stokes_model) {
            nstate = dimension+2;
        } else if (model_type == reynolds_averaged_navier_stokes) {
            nstate = dimension+3;
        }
    } else if (pde_string == "physics_model_filtered") {
        pde_type = physics_model_filtered;
        if (model_type == large_eddy_simulation || model_type == navier_stokes_model) {
            nstate = dimension+2;
        }
    } else if (pde_string == "real_gas") {
        pde_type = real_gas;
        nstate = dimension+number_of_species+1;
    }
    
    overintegration = prm.get_integer("overintegration");

    use_weak_form = prm.get_bool("use_weak_form");
    
    const std::string flux_nodes_string = prm.get("flux_nodes_type");
    if (flux_nodes_string == "GL") { flux_nodes_type = FluxNodes::GL; }
    if (flux_nodes_string == "GLL") { flux_nodes_type = FluxNodes::GLL; }

    use_collocated_nodes = (flux_nodes_type==FluxNodes::GLL) && (overintegration==0);

    use_split_form = prm.get_bool("use_split_form");

    const std::string two_point_num_flux_string = prm.get("two_point_num_flux_type");
    if (two_point_num_flux_string == "KG") { two_point_num_flux_type = TwoPointNumericalFlux::KG; }
    if (two_point_num_flux_string == "IR") { two_point_num_flux_type = TwoPointNumericalFlux::IR; }
    if (two_point_num_flux_string == "CH") { two_point_num_flux_type = TwoPointNumericalFlux::CH; }
    if (two_point_num_flux_string == "Ra") { two_point_num_flux_type = TwoPointNumericalFlux::Ra; }

    use_curvilinear_split_form = prm.get_bool("use_curvilinear_split_form");
    use_curvilinear_grid = prm.get_bool("use_curvilinear_grid");
    store_residual_cpu_time = prm.get_bool("store_residual_cpu_time");
    use_weight_adjusted_mass = prm.get_bool("use_weight_adjusted_mass");
    all_boundaries_are_periodic = prm.get_bool("all_boundaries_are_periodic");
    check_same_coords_in_weak_dg = prm.get_bool("check_same_coords_in_weak_dg");
    use_energy = prm.get_bool("use_energy");
    use_L2_norm = prm.get_bool("use_L2_norm");
    sipg_penalty_factor = prm.get_double("sipg_penalty_factor");
    use_invariant_curl_form = prm.get_bool("use_invariant_curl_form");
    use_inverse_mass_on_the_fly = prm.get_bool("use_inverse_mass_on_the_fly");
    check_valid_metric_Jacobian = prm.get_bool("check_valid_metric_Jacobian");
    if(!use_weak_form){
        check_valid_metric_Jacobian = false;
    }

    energy_file = prm.get("energy_file");

    const std::string conv_num_flux_string = prm.get("conv_num_flux");
    if (conv_num_flux_string == "lax_friedrichs")                                 { conv_num_flux_type = ConvectiveNumericalFlux::lax_friedrichs; }
    if (conv_num_flux_string == "roe")                                            { conv_num_flux_type = ConvectiveNumericalFlux::roe; }
    if (conv_num_flux_string == "l2roe")                                          { conv_num_flux_type = ConvectiveNumericalFlux::l2roe; }
    if (conv_num_flux_string == "central_flux")                                   { conv_num_flux_type = ConvectiveNumericalFlux::central_flux; }
    if (conv_num_flux_string == "two_point_flux")                                 { conv_num_flux_type = ConvectiveNumericalFlux::two_point_flux; }
    if (conv_num_flux_string == "two_point_flux_with_lax_friedrichs_dissipation") { conv_num_flux_type = ConvectiveNumericalFlux::two_point_flux_with_lax_friedrichs_dissipation; }
    if (conv_num_flux_string == "two_point_flux_with_roe_dissipation")            { conv_num_flux_type = ConvectiveNumericalFlux::two_point_flux_with_roe_dissipation; }
    if (conv_num_flux_string == "two_point_flux_with_l2roe_dissipation")          { conv_num_flux_type = ConvectiveNumericalFlux::two_point_flux_with_l2roe_dissipation; }

    const std::string diss_num_flux_string = prm.get("diss_num_flux");
    if (diss_num_flux_string == "symm_internal_penalty") { diss_num_flux_type = symm_internal_penalty; }
    if (diss_num_flux_string == "bassi_rebay_2") {
        diss_num_flux_type = bassi_rebay_2;
        sipg_penalty_factor = 0.0;
    }
    if (diss_num_flux_string == "central_visc_flux") diss_num_flux_type = central_visc_flux;

    const std::string flux_reconstruction_string = prm.get("flux_reconstruction");
    if (flux_reconstruction_string == "cDG")         { flux_reconstruction_type = cDG; }
    if (flux_reconstruction_string == "cSD")         { flux_reconstruction_type = cSD; }
    if (flux_reconstruction_string == "cHU")         { flux_reconstruction_type = cHU; }
    if (flux_reconstruction_string == "cNegative")   { flux_reconstruction_type = cNegative; }
    if (flux_reconstruction_string == "cNegative2")  { flux_reconstruction_type = cNegative2; }
    if (flux_reconstruction_string == "cPlus")       { flux_reconstruction_type = cPlus; }
    if (flux_reconstruction_string == "c10Thousand") { flux_reconstruction_type = c10Thousand; }
    if (flux_reconstruction_string == "cHULumped")   { flux_reconstruction_type = cHULumped; }
    if (flux_reconstruction_string == "user_specified_value") 
                                                     { flux_reconstruction_type = user_specified_value; }

    FR_user_specified_correction_parameter_value = prm.get_double("FR_user_specified_correction_parameter_value");
    if ( abs(FR_user_specified_correction_parameter_value ) >1E-13 && flux_reconstruction_type != user_specified_value){
        pcout << "Warning: User-specified FR parameter has been set, but flux_reconstruction_type is " << std::endl
              << "not chosen as user_specified_value. This may be unintended." << std::endl;
    }

    const std::string flux_reconstruction_aux_string = prm.get("flux_reconstruction_aux");
    if (flux_reconstruction_aux_string == "kDG")         { flux_reconstruction_aux_type = kDG; }
    if (flux_reconstruction_aux_string == "kSD")         { flux_reconstruction_aux_type = kSD; }
    if (flux_reconstruction_aux_string == "kHU")         { flux_reconstruction_aux_type = kHU; }
    if (flux_reconstruction_aux_string == "kNegative")   { flux_reconstruction_aux_type = kNegative; }
    if (flux_reconstruction_aux_string == "kNegative2")  { flux_reconstruction_aux_type = kNegative2; }
    if (flux_reconstruction_aux_string == "kPlus")       { flux_reconstruction_aux_type = kPlus; }
    if (flux_reconstruction_aux_string == "k10Thousand") { flux_reconstruction_aux_type = k10Thousand; }

    const std::string non_physical_behavior_string = prm.get("non_physical_behavior");
    if (non_physical_behavior_string == "return_big_number") { non_physical_behavior_type = NonPhysicalBehaviorEnum::return_big_number;}
    if (non_physical_behavior_string == "abort_run")         { non_physical_behavior_type = NonPhysicalBehaviorEnum::abort_run;}
    if (non_physical_behavior_string == "print_warning")     { non_physical_behavior_type = NonPhysicalBehaviorEnum::print_warning;}

    solution_vtk_files_directory_name = prm.get("solution_vtk_files_directory_name");
    // Check if directory exists - see https://stackoverflow.com/a/18101042
    struct stat info_vtk;
    if( stat( solution_vtk_files_directory_name.c_str(), &info_vtk ) != 0 ){
        pcout << "Error: No solution vtk files directory named " << solution_vtk_files_directory_name << " exists." << std::endl
                  << "Please create the directory and restart. Aborting..." << std::endl;
        std::abort();
    }
    output_high_order_grid = prm.get_bool("output_high_order_grid");
    enable_higher_order_vtk_output = prm.get_bool("enable_higher_order_vtk_output");
    output_face_results_vtk = prm.get_bool("output_face_results_vtk");
    do_renumber_dofs = prm.get_bool("do_renumber_dofs");

    const std::string renumber_dofs_type_string = prm.get("renumber_dofs_type");
    if (renumber_dofs_type_string == "CuthillMckee") { renumber_dofs_type = RenumberDofsType::CuthillMckee; }

    matching_surface_jac_det_tolerance = prm.get_double("matching_surface_jac_det_tolerance");
    wall_model_input_from_second_element = prm.get_bool("wall_model_input_from_second_element");
    use_projected_entropy_variables_for_nsfr_boundary_term = prm.get_bool("use_projected_entropy_variables_for_nsfr_boundary_term");

    chemistry_input_file = prm.get("chemistry_input_file");

    pcout << "Parsing linear solver subsection..." << std::endl;
    linear_solver_param.parse_parameters (prm);

    pcout << "Parsing ODE solver subsection..." << std::endl;
    ode_solver_param.parse_parameters (prm);

    pcout << "Parsing manufactured convergence study subsection..." << std::endl;
    manufactured_convergence_study_param.parse_parameters (prm);

    pcout << "Parsing euler subsection..." << std::endl;
    euler_param.parse_parameters (prm);

    pcout << "Parsing navier stokes subsection..." << std::endl;
    navier_stokes_param.parse_parameters (prm);

    pcout << "Parsing reduced order subsection..." << std::endl;
    reduced_order_param.parse_parameters (prm);

    pcout << "Parsing hyperreduction subsection..." << std::endl;
    hyper_reduction_param.parse_parameters (prm);

    pcout << "Parsing Burgers subsection..." << std::endl;
    burgers_param.parse_parameters (prm);

    pcout << "Parsing physics model subsection..." << std::endl;
    physics_model_param.parse_parameters (prm);

    pcout << "Parsing grid refinement study subsection..." << std::endl;
    grid_refinement_study_param.parse_parameters (prm);

    pcout << "Parsing artificial dissipation subsection..." << std::endl;
    artificial_dissipation_param.parse_parameters (prm);

    pcout << "Parsing limiter subsection..." << std::endl;
    limiter_param.parse_parameters(prm);
    
    pcout << "Parsing flow solver subsection..." << std::endl;
    flow_solver_param.parse_parameters (prm);

    pcout << "Parsing mesh adaptation subsection..." << std::endl;
    mesh_adaptation_param.parse_parameters (prm);
    
    pcout << "Parsing functional subsection..." << std::endl;
    functional_param.parse_parameters (prm);
    
    pcout << "Parsing time refinement study subsection..." << std::endl;
    time_refinement_study_param.parse_parameters (prm);

    pcout << "Done parsing." << std::endl;

    modify_parameters();
}

void AllParameters::modify_parameters () {
    if(flow_solver_param.flow_case_type == flow_solver_param.FlowCaseType::channel_flow) {
      pcout << "Setting freestream parameters for channel flow case to be based on bulk velocity Reynolds number... " << std::flush;
      const double channel_bulk_velocity_reynolds_number = pow(0.073, -4.0/7.0)*pow(2.0, 5.0/7.0)*pow(flow_solver_param.turbulent_channel_friction_velocity_reynolds_number, 8.0/7.0);
      // - Freestream Reynolds number
      navier_stokes_param.reynolds_number_inf = channel_bulk_velocity_reynolds_number;
      // - Reference length
      euler_param.ref_length = flow_solver_param.turbulent_channel_domain_length_y_direction/2.0; // corresponds to half channel height
      
      pcout << "done." << std::endl;
    } 
    if((pde_type == PartialDifferentialEquation::navier_stokes || (pde_type == PartialDifferentialEquation::navier_stokes_channel_flow_constant_source_term || 
                (pde_type == PartialDifferentialEquation::navier_stokes_channel_flow_constant_source_term_wall_model ||
                 (pde_type == PartialDifferentialEquation::physics_model || pde_type == PartialDifferentialEquation::physics_model_filtered)))) && 
              (flow_solver_param.flow_case_type == flow_solver_param.FlowCaseType::taylor_green_vortex || 
                (flow_solver_param.flow_case_type == flow_solver_param.FlowCaseType::channel_flow || 
                  (flow_solver_param.flow_case_type == flow_solver_param.FlowCaseType::dipole_wall_collision_normal || 
                    (flow_solver_param.flow_case_type == flow_solver_param.FlowCaseType::dipole_wall_collision_oblique ||
                  flow_solver_param.flow_case_type == flow_solver_param.FlowCaseType::decaying_homogeneous_isotropic_turbulence))))) 
    {
      pcout << "Setting non_physical_behavior_type = NonPhysicalBehaviorEnum::abort_run... " << std::flush;
      non_physical_behavior_type = NonPhysicalBehaviorEnum::abort_run;
      pcout << "done." << std::endl;
    }
}

} // Parameters namespace
} // PHiLiP namespace