input_keys.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2022-2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_INPUT_KEYS_H_
#define SRC_INCLUDE_SMASH_INPUT_KEYS_H_
 
#include <array>
#include <functional>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include "einhard.hpp"
 
#include "forwarddeclarations.h"
#include "key.h"
#include "pdgcode.h"
 
namespace smash {
 
struct InputSections {
  using Section = KeyLabels;
 
  inline static const Section collisionTerm{"Collision_Term"};
  inline static const Section c_dileptons =
      InputSections::collisionTerm + "Dileptons";
  inline static const Section c_pauliBlocking =
      InputSections::collisionTerm + "Pauli_Blocking";
  inline static const Section c_photons =
      InputSections::collisionTerm + "Photons";
  inline static const Section c_heavyFlavor =
      InputSections::collisionTerm + "Heavy_Flavor";
  inline static const Section c_stringParameters =
      InputSections::collisionTerm + "String_Parameters";
  inline static const Section c_stringTransition =
      InputSections::collisionTerm + "String_Transition";
 
  inline static const Section forcedThermalization{"Forced_Thermalization"};
 
  inline static const Section general{"General"};
  inline static const Section g_minEnsembles =
      InputSections::general + "Minimum_Nonempty_Ensembles";
 
  inline static const Section lattice{"Lattice"};
 
  inline static const Section logging{"Logging"};
 
  inline static const Section modi{"Modi"};
  inline static const Section m_box = InputSections::modi + "Box";
  inline static const Section m_b_jet = InputSections::m_box + "Jet";
  inline static const Section m_collider = InputSections::modi + "Collider";
  inline static const Section m_c_impact = InputSections::m_collider + "Impact";
  inline static const Section m_c_initialConditions =
      InputSections::m_collider + "Initial_Conditions";
  inline static const Section m_c_projectile =
      InputSections::m_collider + "Projectile";
  inline static const Section m_c_p_alphaClustered =
      InputSections::m_c_projectile + "Alpha_Clustered";
  inline static const Section m_c_p_custom =
      InputSections::m_c_projectile + "Custom";
  inline static const Section m_c_p_deformed =
      InputSections::m_c_projectile + "Deformed";
  inline static const Section m_c_p_orientation =
      InputSections::m_c_projectile + "Orientation";
  inline static const Section m_c_target = InputSections::m_collider + "Target";
  inline static const Section m_c_t_alphaClustered =
      InputSections::m_c_target + "Alpha_Clustered";
  inline static const Section m_c_t_custom =
      InputSections::m_c_target + "Custom";
  inline static const Section m_c_t_deformed =
      InputSections::m_c_target + "Deformed";
  inline static const Section m_c_t_orientation =
      InputSections::m_c_target + "Orientation";
  inline static const Section m_list = InputSections::modi + "List";
  inline static const Section m_listBox = InputSections::modi + "ListBox";
  inline static const Section m_sphere = InputSections::modi + "Sphere";
  inline static const Section m_s_jet = InputSections::m_sphere + "Jet";
 
  inline static const Section output{"Output"};
  inline static const Section o_collisions =
      InputSections::output + "Collisions";
  inline static const Section o_coulomb = InputSections::output + "Coulomb";
  inline static const Section o_dileptons = InputSections::output + "Dileptons";
  inline static const Section o_initialConditions =
      InputSections::output + "Initial_Conditions";
  inline static const Section o_particles = InputSections::output + "Particles";
  inline static const Section o_photons = InputSections::output + "Photons";
  inline static const Section o_rivet = InputSections::output + "Rivet";
  inline static const Section o_r_weights = InputSections::o_rivet + "Weights";
  inline static const Section o_thermodynamics =
      InputSections::output + "Thermodynamics";
 
  inline static const Section potentials{"Potentials"};
  inline static const Section p_coulomb = InputSections::potentials + "Coulomb";
  inline static const Section p_momentumDependence =
      InputSections::potentials + "Momentum_Dependence";
  inline static const Section p_skyrme = InputSections::potentials + "Skyrme";
  inline static const Section p_symmetry =
      InputSections::potentials + "Symmetry";
  inline static const Section p_vdf = InputSections::potentials + "VDF";
};
 
struct InputKeys {
  inline static const Key<std::string> particles{{"particles"}, {"0.30"}};
  inline static const Key<std::string> decaymodes{{"decaymodes"}, {"0.30"}};
 
  inline static const Key<double> gen_endTime{
      InputSections::general + "End_Time", {"0.50"}};
 
  inline static const Key<std::string> gen_modus{
      InputSections::general + "Modus", {"0.50"}};
 
  inline static const Key<int> gen_nevents{InputSections::general + "Nevents",
                                           {"0.50"}};
 
  inline static const Key<int64_t> gen_randomseed{
      InputSections::general + "Randomseed", {"0.50"}};
 
  inline static const Key<int> gen_minNonEmptyEnsembles_maximumEnsembles{
      InputSections::g_minEnsembles + "Maximum_Ensembles_Run", {"2.2"}};
 
  inline static const Key<int> gen_minNonEmptyEnsembles_number{
      InputSections::g_minEnsembles + "Number", {"1.3"}};
 
  inline static const Key<double> gen_deltaTime{
      InputSections::general + "Delta_Time", 1.0, {"0.50"}};
 
  inline static const Key<DerivativesMode> gen_derivativesMode{
      InputSections::general + "Derivatives_Mode",
      DerivativesMode::CovariantGaussian,
      {"2.1"}};
 
  inline static const Key<double> gen_smearingDiscreteWeight{
      InputSections::general + "Discrete_Weight", 1. / 3, {"2.1"}};
 
  inline static const Key<int> gen_ensembles{
      InputSections::general + "Ensembles", 1, {"2.1"}};
 
  inline static const Key<double> gen_expansionRate{
      InputSections::general + "Expansion_Rate", 0.1, {"1.1"}};
 
  inline static const Key<FieldDerivativesMode> gen_fieldDerivativesMode{
      InputSections::general + "Field_Derivatives_Mode",
      FieldDerivativesMode::ChainRule,
      {"2.1"}};
 
  inline static const Key<double> gen_smearingGaussCutoffInSigma{
      InputSections::general + "Gauss_Cutoff_In_Sigma", 4.0, {"0.80"}};
 
  inline static const Key<double> gen_smearingGaussianSigma{
      InputSections::general + "Gaussian_Sigma", 1.0, {"0.60"}};
 
  inline static const Key<ExpansionMode> gen_metricType{
      InputSections::general + "Metric_Type",
      ExpansionMode::NoExpansion,
      {"1.1"}};
 
  inline static const Key<RestFrameDensityDerivativesMode>
      gen_restFrameDensityDerivativeMode{
          InputSections::general + "Rest_Frame_Density_Derivatives_Mode",
          RestFrameDensityDerivativesMode::Off,
          {"2.1", "3.0", "3.0"}};
 
  inline static const Key<SmearingMode> gen_smearingMode{
      InputSections::general + "Smearing_Mode",
      SmearingMode::CovariantGaussian,
      {"2.1"}};
 
  inline static const Key<int> gen_testparticles{
      InputSections::general + "Testparticles", 1, {"0.50"}};
 
  inline static const Key<TimeStepMode> gen_timeStepMode{
      InputSections::general + "Time_Step_Mode", TimeStepMode::Fixed, {"0.85"}};
 
  inline static const Key<double> gen_smearingTriangularRange{
      InputSections::general + "Triangular_Range", 2.0, {"2.1"}};
 
  inline static const Key<bool> gen_useGrid{
      InputSections::general + "Use_Grid", true, {"0.80"}};
 
  inline static const Key<einhard::LogLevel> log_default{
      InputSections::logging + "default", einhard::ALL, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_box{
      InputSections::logging + "Box", DefaultType::Dependent, {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_collider{
      InputSections::logging + "Collider", DefaultType::Dependent, {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_yamlConfiguration{
      InputSections::logging + "Configuration",
      DefaultType::Dependent,
      {"3.0"}};
 
  inline static const Key<einhard::LogLevel> log_experiment{
      InputSections::logging + "Experiment", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_grandcanThermalizer{
      InputSections::logging + "GrandcanThermalizer",
      DefaultType::Dependent,
      {"1.2"}};
 
  inline static const Key<einhard::LogLevel> log_initialConditions{
      InputSections::logging + "InitialConditions",
      DefaultType::Dependent,
      {"1.8"}};
 
  inline static const Key<einhard::LogLevel> log_list{
      InputSections::logging + "List", DefaultType::Dependent, {"0.60"}};
 
  inline static const Key<einhard::LogLevel> log_main{
      InputSections::logging + "Main", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_output{
      InputSections::logging + "Output", DefaultType::Dependent, {"0.60"}};
 
  inline static const Key<einhard::LogLevel> log_potentials{
      InputSections::logging + "Potentials", DefaultType::Dependent, {"3.1"}};
 
  inline static const Key<einhard::LogLevel> log_rootsolver{
      InputSections::logging + "RootSolver", DefaultType::Dependent, {"3.1"}};
 
  inline static const Key<einhard::LogLevel> log_sphere{
      InputSections::logging + "Sphere", DefaultType::Dependent, {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_action{
      InputSections::logging + "Action", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_clock{
      InputSections::logging + "Clock", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_crossSections{
      InputSections::logging + "CrossSections",
      DefaultType::Dependent,
      {"1.3"}};
 
  inline static const Key<einhard::LogLevel> log_decayModes{
      InputSections::logging + "DecayModes", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_density{
      InputSections::logging + "Density", DefaultType::Dependent, {"0.60"}};
 
  inline static const Key<einhard::LogLevel> log_distributions{
      InputSections::logging + "Distributions",
      DefaultType::Dependent,
      {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_findScatter{
      InputSections::logging + "FindScatter", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_fpe{
      InputSections::logging + "Fpe", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<einhard::LogLevel> log_grid{
      InputSections::logging + "Grid", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_hyperSurfaceCrossing{
      InputSections::logging + "HyperSurfaceCrossing",
      DefaultType::Dependent,
      {"1.7"}};
 
  inline static const Key<einhard::LogLevel> log_inputParser{
      InputSections::logging + "InputParser", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_lattice{
      InputSections::logging + "Lattice", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<einhard::LogLevel> log_nucleus{
      InputSections::logging + "Nucleus", DefaultType::Dependent, {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_particleType{
      InputSections::logging + "ParticleType",
      DefaultType::Dependent,
      {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_pauliBlocking{
      InputSections::logging + "PauliBlocking",
      DefaultType::Dependent,
      {"0.7.1"}};
 
  inline static const Key<einhard::LogLevel> log_propagation{
      InputSections::logging + "Propagation",
      DefaultType::Dependent,
      {"0.7.1"}};
 
  inline static const Key<einhard::LogLevel> log_pythia{
      InputSections::logging + "Pythia", DefaultType::Dependent, {"1.0"}};
 
  inline static const Key<einhard::LogLevel> log_resonances{
      InputSections::logging + "Resonances", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_scatterAction{
      InputSections::logging + "ScatterAction",
      DefaultType::Dependent,
      {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_scatterActionMulti{
      InputSections::logging + "ScatterActionMulti",
      DefaultType::Dependent,
      {"2.0"}};
 
  inline static const Key<einhard::LogLevel> log_tmn{
      InputSections::logging + "Tmn", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<std::string> version{{"Version"},
                                               {"1.0", "3.0", "3.2"}};
 
  inline static const Key<double> collTerm_HF_AQMbSuppression{
      InputSections::c_heavyFlavor + "AQM_Bottom_Suppression", 0.93, {"3.2"}};
 
  inline static const Key<double> collTerm_HF_AQMcSuppression{
      InputSections::c_heavyFlavor + "AQM_Charm_Suppression", 0.8, {"3.2"}};
 
  inline static const Key<double> collTerm_additionalElasticCrossSection{
      InputSections::collisionTerm + "Additional_Elastic_Cross_Section",
      0.0,
      {"2.0"}};
 
  inline static const Key<CollisionCriterion> collTerm_collisionCriterion{
      InputSections::collisionTerm + "Collision_Criterion",
      CollisionCriterion::Covariant,
      {"1.7"}};
 
  inline static const Key<double> collTerm_crossSectionScaling{
      InputSections::collisionTerm + "Cross_Section_Scaling", 1.0, {"2.0"}};
 
  inline static const Key<double> collTerm_elasticCrossSection{
      InputSections::collisionTerm + "Elastic_Cross_Section", -1.0, {"1.2"}};
 
  inline static const Key<double> collTerm_elasticNNCutoffSqrts{
      InputSections::collisionTerm + "Elastic_NN_Cutoff_Sqrts", 1.98, {"1.0"}};
 
  inline static const Key<double> collTerm_fixedMinCellLength{
      InputSections::collisionTerm + "Fixed_Min_Cell_Length", 2.5, {"2.1"}};
 
  inline static const Key<bool> collTerm_forceDecaysAtEnd{
      InputSections::collisionTerm + "Force_Decays_At_End", true, {"0.60"}};
 
  inline static const Key<bool> collTerm_decayInitial{
      InputSections::collisionTerm + "Decay_Initial_Particles", true, {"3.0"}};
 
  inline static const Key<ReactionsBitSet> collTerm_includedTwoToTwo{
      InputSections::collisionTerm + "Included_2to2",
      ReactionsBitSet{}.set(),  // All interactions => all bit set
      {"1.3"}};
 
  inline static const Key<bool> collTerm_includeDecaysAtTheEnd{
      InputSections::collisionTerm + "Include_Weak_And_EM_Decays_At_The_End",
      false,
      {"2.2", "3.1", "3.2"}};
 
  inline static const Key<bool> collTerm_ignoreDecayWidthAtTheEnd{
      InputSections::collisionTerm +
          "Ignore_Minimum_Decay_Width_For_Decays_At_The_End",
      false,
      {"3.2"}};
 
  inline static const Key<bool> collTerm_isotropic{
      InputSections::collisionTerm + "Isotropic", false, {"0.7.1"}};
 
  inline static const Key<double> collTerm_maximumCrossSection{
      InputSections::collisionTerm + "Maximum_Cross_Section",
      DefaultType::Dependent,
      {"2.0"}};
 
  inline static const Key<MultiParticleReactionsBitSet>
      collTerm_multiParticleReactions{
          InputSections::collisionTerm + "Multi_Particle_Reactions",
          MultiParticleReactionsBitSet{}.reset(),  // Empty list => no bit set
          {"2.0"}};
 
  inline static const Key<NNbarTreatment> collTerm_nnbarTreatment{
      InputSections::collisionTerm + "NNbar_Treatment",
      NNbarTreatment::Strings,
      {"1.3"}};
 
  inline static const Key<bool> collTerm_noCollisions{
      InputSections::collisionTerm + "No_Collisions", false, {"1.3"}};
 
  inline static const Key<bool> collTerm_onlyWarnForHighProbability{
      InputSections::collisionTerm + "Only_Warn_For_High_Probability",
      false,
      {"3.0"}};
 
  inline static const Key<PseudoResonance> collTerm_pseudoresonance{
      InputSections::collisionTerm + "Pseudoresonance",
      PseudoResonance::LargestFromUnstable,
      {"3.1"}};
 
  inline static const Key<double> collTerm_resonanceLifetimeModifier{
      InputSections::collisionTerm + "Resonance_Lifetime_Modifier",
      1.0,
      {"1.8"}};
 
  inline static const Key<bool> collTerm_strings{
      InputSections::collisionTerm + "Strings",
      DefaultType::Dependent,
      {"1.0"}};
 
  inline static const Key<bool> collTerm_stringsWithProbability{
      InputSections::collisionTerm + "Strings_with_Probability", true, {"1.3"}};
 
  inline static const Key<TotalCrossSectionStrategy> collTerm_totXsStrategy{
      InputSections::collisionTerm + "Total_Cross_Section_Strategy",
      TotalCrossSectionStrategy::TopDownMeasured,
      {"3.1"}};
 
  inline static const Key<bool> collTerm_twoToOne{
      InputSections::collisionTerm + "Two_to_One", true, {"0.85"}};
 
  inline static const Key<bool> collTerm_useAQM{
      InputSections::collisionTerm + "Use_AQM", true, {"1.3"}};
 
  inline static const Key<double> collTerm_pauliBlocking_gaussianCutoff{
      InputSections::c_pauliBlocking + "Gaussian_Cutoff", 2.2, {"0.7.1"}};
 
  inline static const Key<double>
      collTerm_pauliBlocking_momentumAveragingRadius{
          InputSections::c_pauliBlocking + "Momentum_Averaging_Radius",
          0.08,
          {"0.7.1"}};
 
  inline static const Key<double> collTerm_pauliBlocking_spatialAveragingRadius{
      InputSections::c_pauliBlocking + "Spatial_Averaging_Radius",
      1.86,
      {"0.7.1"}};
 
  inline static const Key<double> collTerm_stringTrans_KNOffset{
      InputSections::c_stringTransition + "KN_Offset", 15.15, {"3.0"}};
 
  inline static const Key<double> collTerm_stringTrans_pipiOffset{
      InputSections::c_stringTransition + "PiPi_Offset", 1.12, {"3.0"}};
 
  inline static const Key<double> collTerm_stringTrans_lower{
      InputSections::c_stringTransition + "Sqrts_Lower", 0.9, {"3.0"}};
 
  inline static const Key<std::pair<double, double>>
      collTerm_stringTrans_rangeNN{
          InputSections::c_stringTransition + "Sqrts_Range_NN",
          std::make_pair(3.5, 4.5),
          {"3.0"}};
 
  inline static const Key<std::pair<double, double>>
      collTerm_stringTrans_rangeNpi{
          InputSections::c_stringTransition + "Sqrts_Range_Npi",
          std::make_pair(1.9, 2.2),
          {"3.0"}};
 
  inline static const Key<double> collTerm_stringTrans_range_width{
      InputSections::c_stringTransition + "Sqrts_Range_Width", 1.0, {"3.0"}};
 
  inline static const Key<double> collTerm_stringParam_diquarkSuppression{
      InputSections::c_stringParameters + "Diquark_Supp", 0.036, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_formTimeFactor{
      InputSections::c_stringParameters + "Form_Time_Factor", 1.0, {"1.4"}};
 
  inline static const Key<double> collTerm_stringParam_formationTime{
      InputSections::c_stringParameters + "Formation_Time", 1.0, {"1.0"}};
 
  inline static const Key<double> collTerm_stringParam_gluonBeta{
      InputSections::c_stringParameters + "Gluon_Beta", 0.5, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_gluonPMin{
      InputSections::c_stringParameters + "Gluon_Pmin", 0.001, {"1.3"}};
 
  inline static const Key<bool> collTerm_stringParam_mDependentFormationTimes{
      InputSections::c_stringParameters + "Mass_Dependent_Formation_Times",
      false,
      {"1.5.2"}};
 
  inline static const Key<double> collTerm_stringParam_quarkAlpha{
      InputSections::c_stringParameters + "Quark_Alpha", 2.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_quarkBeta{
      InputSections::c_stringParameters + "Quark_Beta", 7.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_popcornRate{
      InputSections::c_stringParameters + "Popcorn_Rate", 0.15, {"1.6"}};
 
  inline static const Key<double> collTerm_stringParam_powerParticleFormation{
      InputSections::c_stringParameters + "Power_Particle_Formation",
      DefaultType::Dependent,
      {"1.4"}};
 
  inline static const Key<double> collTerm_stringParam_probabilityPToDUU{
      InputSections::c_stringParameters + "Prob_proton_to_d_uu",
      1.0 / 3,
      {"1.5"}};
 
  inline static const Key<bool> collTerm_stringParam_separateFragmentBaryon{
      InputSections::c_stringParameters + "Separate_Fragment_Baryon",
      true,
      {"1.6"}};
 
  inline static const Key<double> collTerm_stringParam_sigmaPerp{
      InputSections::c_stringParameters + "Sigma_Perp", 0.42, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_strangeSuppression{
      InputSections::c_stringParameters + "Strange_Supp", 0.16, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringSigmaT{
      InputSections::c_stringParameters + "String_Sigma_T", 0.5, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringTension{
      InputSections::c_stringParameters + "String_Tension", 1.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringZA{
      InputSections::c_stringParameters + "StringZ_A", 2.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringZALeading{
      InputSections::c_stringParameters + "StringZ_A_Leading", 0.2, {"1.6"}};
 
  inline static const Key<double> collTerm_stringParam_stringZB{
      InputSections::c_stringParameters + "StringZ_B", 0.55, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringZBLeading{
      InputSections::c_stringParameters + "StringZ_B_Leading", 2.0, {"1.6"}};
 
  inline static const Key<bool> collTerm_stringParam_useMonashTune{
      InputSections::c_stringParameters + "Use_Monash_Tune",
      DefaultType::Dependent,
      {"3.0"}};
 
  inline static const Key<bool> collTerm_dileptons_decays{
      InputSections::c_dileptons + "Decays", false, {"0.50"}};
 
  inline static const Key<bool> collTerm_photons_twoToTwoScatterings{
      InputSections::c_photons + "2to2_Scatterings", false, {"1.8"}};
 
  inline static const Key<bool> collTerm_photons_bremsstrahlung{
      InputSections::c_photons + "Bremsstrahlung", false, {"1.8"}};
 
  inline static const Key<int> collTerm_photons_fractionalPhotons{
      InputSections::c_photons + "Fractional_Photons", {"1.8"}};
 
  inline static const Key<double> modi_collider_eKin{
      InputSections::m_collider + "E_Kin", {"0.50"}};
 
  inline static const Key<double> modi_collider_eTot{
      InputSections::m_collider + "E_Tot", {"2.0.2"}};
 
  inline static const Key<double> modi_collider_pLab{
      InputSections::m_collider + "P_Lab", {"0.50"}};
 
  inline static const Key<double> modi_collider_sqrtSNN{
      InputSections::m_collider + "Sqrtsnn", {"0.50"}};
 
  inline static const Key<CalculationFrame> modi_collider_calculationFrame{
      InputSections::m_collider + "Calculation_Frame",
      CalculationFrame::CenterOfVelocity,
      {"0.50"}};
 
  inline static const Key<bool> modi_collider_collisionWithinNucleus{
      InputSections::m_collider + "Collisions_Within_Nucleus", false, {"1.0"}};
 
  inline static const Key<FermiMotion> modi_collider_fermiMotion{
      InputSections::m_collider + "Fermi_Motion", FermiMotion::Off, {"0.60"}};
 
  inline static const Key<double> modi_collider_initialDistance{
      InputSections::m_collider + "Initial_Distance", 4.0, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_diffusiveness{
      InputSections::m_c_projectile + "Diffusiveness",
      DefaultType::Dependent,
      {"0.90"}};
  inline static const Key<double> modi_collider_target_diffusiveness{
      InputSections::m_c_target + "Diffusiveness",
      DefaultType::Dependent,
      {"0.90"}};
 
  inline static const Key<std::map<PdgCode, int>>
      modi_collider_projectile_particles{
          InputSections::m_c_projectile + "Particles", {"0.50"}};
  inline static const Key<std::map<PdgCode, int>>
      modi_collider_target_particles{InputSections::m_c_target + "Particles",
                                     {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_radius{
      InputSections::m_c_projectile + "Radius",
      DefaultType::Dependent,
      {"0.50"}};
  inline static const Key<double> modi_collider_target_radius{
      InputSections::m_c_target + "Radius", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_saturationDensity{
      InputSections::m_c_projectile + "Saturation_Density",
      DefaultType::Dependent,
      {"0.50"}};
  inline static const Key<double> modi_collider_target_saturationDensity{
      InputSections::m_c_target + "Saturation_Density",
      DefaultType::Dependent,
      {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_eKin{
      InputSections::m_c_projectile + "E_Kin", {"0.50"}};
  inline static const Key<double> modi_collider_target_eKin{
      InputSections::m_c_target + "E_Kin", {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_eTot{
      InputSections::m_c_projectile + "E_Tot", {"2.0.2"}};
  inline static const Key<double> modi_collider_target_eTot{
      InputSections::m_c_target + "E_Tot", {"2.0.2"}};
 
  inline static const Key<double> modi_collider_projectile_pLab{
      InputSections::m_c_projectile + "P_Lab", {"0.50"}};
  inline static const Key<double> modi_collider_target_pLab{
      InputSections::m_c_target + "P_Lab", {"0.50"}};
 
  inline static const Key<std::string>
      modi_collider_projectile_custom_fileDirectory{
          InputSections::m_c_p_custom + "File_Directory", {"1.6"}};
  inline static const Key<std::string>
      modi_collider_target_custom_fileDirectory{
          InputSections::m_c_t_custom + "File_Directory", {"1.6"}};
 
  inline static const Key<std::string> modi_collider_projectile_custom_fileName{
      InputSections::m_c_p_custom + "File_Name", {"1.6"}};
  inline static const Key<std::string> modi_collider_target_custom_fileName{
      InputSections::m_c_t_custom + "File_Name", {"1.6"}};
 
  inline static const Key<bool> modi_collider_projectile_deformed_automatic{
      InputSections::m_c_p_deformed + "Automatic", {"1.5"}};
  inline static const Key<bool> modi_collider_target_deformed_automatic{
      InputSections::m_c_t_deformed + "Automatic", {"1.5"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_beta2{
      InputSections::m_c_p_deformed + "Beta_2", 0.0, {"1.5"}};
  inline static const Key<double> modi_collider_target_deformed_beta2{
      InputSections::m_c_t_deformed + "Beta_2",
      InputKeys::modi_collider_projectile_deformed_beta2.default_value(),
      {"1.5"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_beta3{
      InputSections::m_c_p_deformed + "Beta_3", 0.0, {"3.0"}};
  inline static const Key<double> modi_collider_target_deformed_beta3{
      InputSections::m_c_t_deformed + "Beta_3",
      InputKeys::modi_collider_projectile_deformed_beta3.default_value(),
      {"3.0"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_beta4{
      InputSections::m_c_p_deformed + "Beta_4", 0.0, {"1.5"}};
  inline static const Key<double> modi_collider_target_deformed_beta4{
      InputSections::m_c_t_deformed + "Beta_4",
      InputKeys::modi_collider_projectile_deformed_beta4.default_value(),
      {"1.5"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_gamma{
      InputSections::m_c_p_deformed + "Gamma", 0.0, {"3.0"}};
  inline static const Key<double> modi_collider_target_deformed_gamma{
      InputSections::m_c_t_deformed + "Gamma",
      InputKeys::modi_collider_projectile_deformed_gamma.default_value(),
      {"3.0"}};
 
  inline static const Key<bool>
      modi_collider_projectile_alphaClustered_automatic{
          InputSections::m_c_p_alphaClustered + "Automatic", {"3.2"}};
  inline static const Key<bool> modi_collider_target_alphaClustered_automatic{
      InputSections::m_c_t_alphaClustered + "Automatic", {"3.2"}};
 
  inline static const Key<double>
      modi_collider_projectile_alphaClustered_sideLength{
          InputSections::m_c_p_alphaClustered + "Side_Length", 3.42, {"3.2"}};
  inline static const Key<double>
      modi_collider_target_alphaClustered_sideLength{
          InputSections::m_c_t_alphaClustered + "Side_Length",
          InputKeys::modi_collider_projectile_alphaClustered_sideLength
              .default_value(),
          {"3.2"}};
 
  inline static const Key<double> modi_collider_projectile_orientation_phi{
      InputSections::m_c_p_orientation + "Phi", 0.0, {"0.50"}};
  inline static const Key<double> modi_collider_target_orientation_phi{
      InputSections::m_c_t_orientation + "Phi",
      InputKeys::modi_collider_projectile_orientation_phi.default_value(),
      {"0.50"}};
  inline static const Key<double> modi_collider_projectile_orientation_theta{
      InputSections::m_c_p_orientation + "Theta", 0.0, {"0.50"}};
  inline static const Key<double> modi_collider_target_orientation_theta{
      InputSections::m_c_t_orientation + "Theta",
      InputKeys::modi_collider_projectile_orientation_theta.default_value(),
      {"0.50"}};
  inline static const Key<double> modi_collider_projectile_orientation_psi{
      InputSections::m_c_p_orientation + "Psi", 0.0, {"3.0"}};
  inline static const Key<double> modi_collider_target_orientation_psi{
      InputSections::m_c_t_orientation + "Psi",
      InputKeys::modi_collider_projectile_orientation_psi.default_value(),
      {"3.0"}};
 
  inline static const Key<bool> modi_collider_projectile_orientation_randRot{
      InputSections::m_c_p_orientation + "Random_Rotation", false, {"1.7"}};
  inline static const Key<bool> modi_collider_target_orientation_randRot{
      InputSections::m_c_t_orientation + "Random_Rotation",
      InputKeys::modi_collider_projectile_orientation_randRot.default_value(),
      {"1.7"}};
 
  inline static const Key<double> modi_collider_impact_max{
      InputSections::m_c_impact + "Max", 0.0, {"0.50"}};
 
  inline static const Key<bool> modi_collider_impact_randomReactionPlane{
      InputSections::m_c_impact + "Random_Reaction_Plane", false, {"1.8"}};
 
  inline static const Key<std::array<double, 2>> modi_collider_impact_range{
      InputSections::m_c_impact + "Range",
      std::array<double, 2>{{0.0, 0.0}},
      {"0.50"}};
 
  inline static const Key<Sampling> modi_collider_impact_sample{
      InputSections::m_c_impact + "Sample", Sampling::Quadratic, {"0.50"}};
 
  inline static const Key<double> modi_collider_impact_value{
      InputSections::m_c_impact + "Value", 0.0, {"0.50"}};
 
  inline static const Key<std::vector<double>> modi_collider_impact_values{
      InputSections::m_c_impact + "Values", {"0.80"}};
 
  inline static const Key<std::vector<double>> modi_collider_impact_yields{
      InputSections::m_c_impact + "Yields", {"0.80"}};
 
  inline static const Key<FluidizationType>
      modi_collider_initialConditions_type{
          InputSections::m_c_initialConditions + "Type", {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_lowerBound{
      InputSections::m_c_initialConditions + "Lower_Bound", 0.5, {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_properTime{
      InputSections::m_c_initialConditions + "Proper_Time",
      DefaultType::Dependent,
      {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_pTCut{
      InputSections::m_c_initialConditions + "pT_Cut",
      DefaultType::Dependent,
      {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_rapidityCut{
      InputSections::m_c_initialConditions + "Rapidity_Cut",
      DefaultType::Dependent,
      {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_eDenThreshold{
      InputSections::m_c_initialConditions + "Energy_Density_Threshold",
      0.5,
      {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_minTime{
      InputSections::m_c_initialConditions + "Minimum_Time", 0, {"3.2"}};
 
  inline static const Key<double> modi_collider_initialConditions_maxTime{
      InputSections::m_c_initialConditions + "Maximum_Time", 100, {"3.2"}};
 
  inline static const Key<int> modi_collider_initialConditions_fluidCells{
      InputSections::m_c_initialConditions + "Fluidization_Cells", 80, {"3.2"}};
 
  inline static const Key<FluidizableProcessesBitSet>
      modi_collider_initialConditions_fluidProcesses{
          InputSections::m_c_initialConditions + "Fluidizable_Processes",
          FluidizableProcessesBitSet{}.set(),  // all processes
          {"3.2"}};
  inline static const Key<double>
      modi_collider_initialConditions_formTimeFraction{
          InputSections::m_c_initialConditions + "Formation_Time_Fraction",
          1.0,
          {"3.2"}};
 
  inline static const Key<std::map<PdgCode, int>>
      modi_sphere_initialMultiplicities{
          InputSections::m_sphere + "Init_Multiplicities", {"0.50"}};
 
  inline static const Key<double> modi_sphere_radius{
      InputSections::m_sphere + "Radius", {"0.50"}};
 
  inline static const Key<double> modi_sphere_startTime{
      InputSections::m_sphere + "Start_Time", {"0.50"}};
 
  inline static const Key<double> modi_sphere_temperature{
      InputSections::m_sphere + "Temperature", {"1.5.2"}};
 
  inline static const Key<bool> modi_sphere_accountResonanceWidths{
      InputSections::m_sphere + "Account_Resonance_Widths", true, {"1.7"}};
 
  inline static const Key<double> modi_sphere_addRadialVelocity{
      InputSections::m_sphere + "Add_Radial_Velocity", -1.0, {"2.2"}};
 
  inline static const Key<double> modi_sphere_baryonChemicalPotential{
      InputSections::m_sphere + "Baryon_Chemical_Potential", 0.0, {"1.0"}};
 
  inline static const Key<double> modi_sphere_chargeChemicalPotential{
      InputSections::m_sphere + "Charge_Chemical_Potential", 0.0, {"2.1"}};
 
  inline static const Key<SphereInitialCondition> modi_sphere_initialCondition{
      InputSections::m_sphere + "Initial_Condition",
      SphereInitialCondition::ThermalMomentaBoltzmann,
      {"1.1"}};
 
  inline static const Key<double> modi_sphere_strangeChemicalPotential{
      InputSections::m_sphere + "Strange_Chemical_Potential", 0.0, {"1.0"}};
 
  inline static const Key<bool> modi_sphere_useThermalMultiplicities{
      InputSections::m_sphere + "Use_Thermal_Multiplicities", false, {"1.0"}};
 
  inline static const Key<double> modi_sphere_jet_jetMomentum{
      InputSections::m_s_jet + "Jet_Momentum", 20.0, {"1.5.2"}};
 
  inline static const Key<PdgCode> modi_sphere_jet_jetPdg{
      InputSections::m_s_jet + "Jet_PDG", {"1.5.2"}};
 
  inline static const Key<std::map<PdgCode, int>>
      modi_box_initialMultiplicities{
          InputSections::m_box + "Init_Multiplicities", {"0.50"}};
 
  inline static const Key<BoxInitialCondition> modi_box_initialCondition{
      InputSections::m_box + "Initial_Condition", {"0.50"}};
 
  inline static const Key<double> modi_box_length{
      InputSections::m_box + "Length", {"0.50"}};
 
  inline static const Key<double> modi_box_startTime{
      InputSections::m_box + "Start_Time", {"0.50"}};
 
  inline static const Key<double> modi_box_temperature{
      InputSections::m_box + "Temperature", {"0.50"}};
 
  inline static const Key<bool> modi_box_accountResonanceWidths{
      InputSections::m_box + "Account_Resonance_Widths", true, {"1.7"}};
 
  inline static const Key<double> modi_box_baryonChemicalPotential{
      InputSections::m_box + "Baryon_Chemical_Potential", 0.0, {"1.0"}};
 
  inline static const Key<double> modi_box_chargeChemicalPotential{
      InputSections::m_box + "Charge_Chemical_Potential", 0.0, {"2.0"}};
 
  inline static const Key<double> modi_box_equilibrationTime{
      InputSections::m_box + "Equilibration_Time", -1.0, {"1.8"}};
 
  inline static const Key<double> modi_box_strangeChemicalPotential{
      InputSections::m_box + "Strange_Chemical_Potential", 0.0, {"1.0"}};
 
  inline static const Key<bool> modi_box_useThermalMultiplicities{
      InputSections::m_box + "Use_Thermal_Multiplicities", false, {"1.0"}};
 
  inline static const Key<double> modi_box_jet_jetMomentum{
      InputSections::m_b_jet + "Jet_Momentum", 20.0, {"1.7"}};
 
  inline static const Key<PdgCode> modi_box_jet_jetPdg{
      InputSections::m_b_jet + "Jet_PDG", {"1.7"}};
 
  inline static const Key<std::string> modi_list_fileDirectory{
      InputSections::m_list + "File_Directory", {"0.60"}};
 
  inline static const Key<std::string> modi_list_filename{
      InputSections::m_list + "Filename", {"3.1"}};
 
  inline static const Key<std::string> modi_list_filePrefix{
      InputSections::m_list + "File_Prefix", {"0.60"}};
 
  inline static const Key<int> modi_list_shiftId{
      InputSections::m_list + "Shift_Id", 0, {"0.60"}};
 
  inline static const Key<std::string> modi_listBox_fileDirectory{
      InputSections::m_listBox + "File_Directory", {"2.1"}};
 
  inline static const Key<std::string> modi_listBox_filename{
      InputSections::m_listBox + "Filename", {"3.1"}};
 
  inline static const Key<std::string> modi_listBox_filePrefix{
      InputSections::m_listBox + "File_Prefix", {"2.1"}};
 
  inline static const Key<double> modi_listBox_length{
      InputSections::m_listBox + "Length", {"2.1"}};
 
  inline static const Key<int> modi_listBox_shiftId{
      InputSections::m_listBox + "Shift_Id", 0, {"2.1"}};
 
  inline static const Key<DensityType> output_densityType{
      InputSections::output + "Density_Type", DensityType::None, {"0.60"}};
 
  inline static const Key<double> output_outputInterval{
      InputSections::output + "Output_Interval",
      DefaultType::Dependent,
      {"0.50"}};
 
  inline static const Key<std::vector<double>> output_outputTimes{
      InputSections::output + "Output_Times", DefaultType::Dependent, {"1.7"}};
 
  inline static const Key<std::vector<std::string>> output_particles_format{
      InputSections::o_particles + "Format",
      std::vector<std::string>{},
      {"1.2"}};
  inline static const Key<std::vector<std::string>> output_collisions_format{
      InputSections::o_collisions + "Format",
      std::vector<std::string>{},
      {"1.2"}};
  inline static const Key<std::vector<std::string>> output_dileptons_format{
      InputSections::o_dileptons + "Format",
      std::vector<std::string>{},
      {"0.85"}};
  inline static const Key<std::vector<std::string>> output_photons_format{
      InputSections::o_photons + "Format", std::vector<std::string>{}, {"1.0"}};
  inline static const Key<std::vector<std::string>>
      output_initialConditions_format{
          InputSections::o_initialConditions + "Format",
          std::vector<std::string>{},
          {"1.7"}};
  inline static const Key<std::vector<std::string>> output_rivet_format{
      InputSections::o_rivet + "Format", std::vector<std::string>{}, {"2.0.2"}};
  inline static const Key<std::vector<std::string>> output_coulomb_format{
      InputSections::o_coulomb + "Format", std::vector<std::string>{}, {"2.1"}};
  inline static const Key<std::vector<std::string>>
      output_thermodynamics_format{InputSections::o_thermodynamics + "Format",
                                   std::vector<std::string>{},
                                   {"1.2"}};
 
  inline static const Key<bool> output_particles_extended{
      InputSections::o_particles + "Extended", false, {"1.2"}};
 
  inline static const Key<std::vector<std::string>> output_particles_quantities{
      {"Output", "Particles", "Quantities"},
      std::vector<std::string>{},
      {"3.2"}};
 
  inline static const Key<OutputOnlyFinal> output_particles_onlyFinal{
      InputSections::o_particles + "Only_Final",
      OutputOnlyFinal::Yes,
      {"0.50"}};
 
  inline static const Key<bool> output_collisions_extended{
      InputSections::o_collisions + "Extended", false, {"1.2"}};
 
  inline static const Key<std::vector<std::string>>
      output_collisions_quantities{{"Output", "Collisions", "Quantities"},
                                   std::vector<std::string>{},
                                   {"3.2"}};
 
  inline static const Key<bool> output_collisions_printStartEnd{
      InputSections::o_collisions + "Print_Start_End", false, {"0.50"}};
 
  inline static const Key<bool> output_dileptons_extended{
      InputSections::o_dileptons + "Extended", false, {"1.2"}};
 
  inline static const Key<bool> output_photons_extended{
      InputSections::o_photons + "Extended", false, {"1.5"}};
 
  inline static const Key<bool> output_initialConditions_extended{
      InputSections::o_initialConditions + "Extended", false, {"1.7"}};
 
  inline static const Key<double> output_initialConditions_lowerBound{
      InputSections::o_initialConditions + "Lower_Bound", 0.5, {"1.8", "3.2"}};
 
  inline static const Key<double> output_initialConditions_properTime{
      InputSections::o_initialConditions + "Proper_Time",
      DefaultType::Dependent,
      {"1.7", "3.2"}};
 
  inline static const Key<double> output_initialConditions_pTCut{
      InputSections::o_initialConditions + "pT_Cut",
      DefaultType::Dependent,
      {"2.2", "3.2"}};
 
  inline static const Key<double> output_initialConditions_rapidityCut{
      InputSections::o_initialConditions + "Rapidity_Cut",
      DefaultType::Dependent,
      {"2.2", "3.2"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_analyses{
      InputSections::o_rivet + "Analyses", DefaultType::Dependent, {"2.0.2"}};
 
  inline static const Key<std::array<double, 2>> output_rivet_crossSection{
      InputSections::o_rivet + "Cross_Section",
      DefaultType::Dependent,
      {"2.0.2"}};
 
  inline static const Key<bool> output_rivet_ignoreBeams{
      InputSections::o_rivet + "Ignore_Beams", true, {"2.0.2"}};
 
  inline static const Key<std::map<std::string, std::string>>
      output_rivet_logging{
          InputSections::o_rivet + "Logging", DefaultType::Dependent, {"0.50"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_paths{
      InputSections::o_rivet + "Paths", DefaultType::Dependent, {"2.0.2"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_preloads{
      InputSections::o_rivet + "Preloads", DefaultType::Dependent, {"2.0.2"}};
 
  inline static const Key<double> output_rivet_weights_cap{
      InputSections::o_r_weights + "Cap", DefaultType::Dependent, {"2.0.2"}};
 
  inline static const Key<std::vector<std::string>>
      output_rivet_weights_deselect{InputSections::o_r_weights + "Deselect",
                                    DefaultType::Dependent,
                                    {"2.0.2"}};
 
  inline static const Key<double> output_rivet_weights_nloSmearing{
      InputSections::o_r_weights + "NLO_Smearing",
      DefaultType::Dependent,
      {"2.0.2"}};
 
  inline static const Key<bool> output_rivet_weights_noMulti{
      InputSections::o_r_weights + "No_Multi",
      DefaultType::Dependent,
      {"2.0.2"}};
 
  inline static const Key<std::string> output_rivet_weights_nominal{
      InputSections::o_r_weights + "Nominal",
      DefaultType::Dependent,
      {"2.0.2"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_weights_select{
      InputSections::o_r_weights + "Select", DefaultType::Dependent, {"2.0.2"}};
 
  inline static const Key<bool> output_thermodynamics_onlyParticipants{
      InputSections::o_thermodynamics + "Only_Participants", false, {"2.1"}};
 
  inline static const Key<std::array<double, 3>> output_thermodynamics_position{
      InputSections::o_thermodynamics + "Position",
      std::array<double, 3>{{0.0, 0.0, 0.0}},
      {"1.0"}};
 
  inline static const Key<std::set<ThermodynamicQuantity>>
      output_thermodynamics_quantites{
          InputSections::o_thermodynamics + "Quantities",
          std::set<ThermodynamicQuantity>{},
          {"1.0"}};
 
  inline static const Key<bool> output_thermodynamics_smearing{
      InputSections::o_thermodynamics + "Smearing", true, {"1.0"}};
 
  inline static const Key<DensityType> output_thermodynamics_type{
      InputSections::o_thermodynamics + "Type", DensityType::Baryon, {"1.0"}};
 
  inline static const Key<bool> lattice_automatic{
      InputSections::lattice + "Automatic", {"3.0"}};
 
  inline static const Key<std::array<int, 3>> lattice_cellNumber{
      InputSections::lattice + "Cell_Number", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<std::array<double, 3>> lattice_origin{
      InputSections::lattice + "Origin", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<bool> lattice_periodic{
      InputSections::lattice + "Periodic", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<bool> lattice_potentialsAffectThreshold{
      InputSections::lattice + "Potentials_Affect_Thresholds", false, {"1.3"}};
 
  inline static const Key<std::array<double, 3>> lattice_sizes{
      InputSections::lattice + "Sizes", DefaultType::Dependent, {"0.80"}};
 
  inline static const Key<bool> potentials_use_potentials_outside_lattice{
      InputSections::potentials + "Use_Potentials_Outside_Lattice",
      true,
      {"3.1"}};
 
  inline static const Key<double> potentials_skyrme_skyrmeA{
      InputSections::p_skyrme + "Skyrme_A", {"0.60"}};
 
  inline static const Key<double> potentials_skyrme_skyrmeB{
      InputSections::p_skyrme + "Skyrme_B", {"0.60"}};
 
  inline static const Key<double> potentials_skyrme_skyrmeTau{
      InputSections::p_skyrme + "Skyrme_Tau", {"0.60"}};
 
  inline static const Key<double> potentials_symmetry_gamma{
      InputSections::p_symmetry + "gamma", DefaultType::Dependent, {"1.7"}};
 
  inline static const Key<double> potentials_symmetry_sPot{
      InputSections::p_symmetry + "S_Pot", {"0.60"}};
 
  inline static const Key<std::vector<double>> potentials_vdf_coeffs{
      InputSections::p_vdf + "Coeffs", {"2.1"}};
 
  inline static const Key<std::vector<double>> potentials_vdf_powers{
      InputSections::p_vdf + "Powers", {"2.1"}};
 
  inline static const Key<double> potentials_vdf_satRhoB{
      InputSections::p_vdf + "Sat_rhoB", {"2.1"}};
 
  inline static const Key<double> potentials_coulomb_rCut{
      InputSections::p_coulomb + "R_Cut", {"2.1"}};
 
  inline static const Key<double> potentials_momentum_dependence_C{
      InputSections::p_momentumDependence + "C", {"3.1"}};
 
  inline static const Key<double> potentials_momentum_dependence_Lambda{
      InputSections::p_momentumDependence + "Lambda", {"3.1"}};
 
  inline static const Key<std::array<int, 3>> forcedThermalization_cellNumber{
      InputSections::forcedThermalization + "Cell_Number", {"1.1"}};
 
  inline static const Key<double> forcedThermalization_criticalEDensity{
      InputSections::forcedThermalization + "Critical_Edens", {"1.1"}};
 
  inline static const Key<double> forcedThermalization_startTime{
      InputSections::forcedThermalization + "Start_Time", {"1.1"}};
 
  inline static const Key<double> forcedThermalization_timestep{
      InputSections::forcedThermalization + "Timestep", {"1.1"}};
 
  inline static const Key<ThermalizationAlgorithm>
      forcedThermalization_algorithm{
          InputSections::forcedThermalization + "Algorithm",
          ThermalizationAlgorithm::BiasedBF,
          {"1.1"}};
 
  inline static const Key<std::array<double, 3>>
      forcedThermalization_latticeSizes{
          InputSections::forcedThermalization + "Lattice_Sizes", {"1.1"}};
 
  inline static const Key<bool> forcedThermalization_microcanonical{
      InputSections::forcedThermalization + "Microcanonical", false, {"1.7"}};
 
  using key_references_variant = std::variant<
      std::reference_wrapper<const Key<bool>>,
      std::reference_wrapper<const Key<int>>,
      std::reference_wrapper<const Key<int64_t>>,
      std::reference_wrapper<const Key<double>>,
      std::reference_wrapper<const Key<std::string>>,
      std::reference_wrapper<const Key<std::array<int, 3>>>,
      std::reference_wrapper<const Key<std::array<double, 2>>>,
      std::reference_wrapper<const Key<std::array<double, 3>>>,
      std::reference_wrapper<const Key<std::pair<double, double>>>,
      std::reference_wrapper<const Key<std::vector<double>>>,
      std::reference_wrapper<const Key<std::vector<std::string>>>,
      std::reference_wrapper<const Key<std::set<ThermodynamicQuantity>>>,
      std::reference_wrapper<const Key<std::map<PdgCode, int>>>,
      std::reference_wrapper<const Key<std::map<std::string, std::string>>>,
      std::reference_wrapper<const Key<einhard::LogLevel>>,
      std::reference_wrapper<const Key<BoxInitialCondition>>,
      std::reference_wrapper<const Key<CalculationFrame>>,
      std::reference_wrapper<const Key<CollisionCriterion>>,
      std::reference_wrapper<const Key<DensityType>>,
      std::reference_wrapper<const Key<DerivativesMode>>,
      std::reference_wrapper<const Key<ExpansionMode>>,
      std::reference_wrapper<const Key<FermiMotion>>,
      std::reference_wrapper<const Key<FieldDerivativesMode>>,
      std::reference_wrapper<const Key<FluidizableProcessesBitSet>>,
      std::reference_wrapper<const Key<FluidizationType>>,
      std::reference_wrapper<const Key<MultiParticleReactionsBitSet>>,
      std::reference_wrapper<const Key<NNbarTreatment>>,
      std::reference_wrapper<const Key<OutputOnlyFinal>>,
      std::reference_wrapper<const Key<PdgCode>>,
      std::reference_wrapper<const Key<PseudoResonance>>,
      std::reference_wrapper<const Key<ReactionsBitSet>>,
      std::reference_wrapper<const Key<RestFrameDensityDerivativesMode>>,
      std::reference_wrapper<const Key<Sampling>>,
      std::reference_wrapper<const Key<SmearingMode>>,
      std::reference_wrapper<const Key<SphereInitialCondition>>,
      std::reference_wrapper<const Key<ThermalizationAlgorithm>>,
      std::reference_wrapper<const Key<TimeStepMode>>,
      std::reference_wrapper<const Key<TotalCrossSectionStrategy>>>;
 
  inline static const std::vector<key_references_variant> list = {
      std::cref(particles),
      std::cref(decaymodes),
      std::cref(gen_endTime),
      std::cref(gen_modus),
      std::cref(gen_nevents),
      std::cref(gen_randomseed),
      std::cref(gen_minNonEmptyEnsembles_maximumEnsembles),
      std::cref(gen_minNonEmptyEnsembles_number),
      std::cref(gen_deltaTime),
      std::cref(gen_derivativesMode),
      std::cref(gen_smearingDiscreteWeight),
      std::cref(gen_ensembles),
      std::cref(gen_expansionRate),
      std::cref(gen_fieldDerivativesMode),
      std::cref(gen_smearingGaussCutoffInSigma),
      std::cref(gen_smearingGaussianSigma),
      std::cref(gen_metricType),
      std::cref(gen_restFrameDensityDerivativeMode),
      std::cref(gen_smearingMode),
      std::cref(gen_testparticles),
      std::cref(gen_timeStepMode),
      std::cref(gen_smearingTriangularRange),
      std::cref(gen_useGrid),
      std::cref(log_default),
      std::cref(log_box),
      std::cref(log_collider),
      std::cref(log_yamlConfiguration),
      std::cref(log_experiment),
      std::cref(log_grandcanThermalizer),
      std::cref(log_initialConditions),
      std::cref(log_list),
      std::cref(log_main),
      std::cref(log_output),
      std::cref(log_sphere),
      std::cref(log_action),
      std::cref(log_clock),
      std::cref(log_crossSections),
      std::cref(log_decayModes),
      std::cref(log_density),
      std::cref(log_distributions),
      std::cref(log_findScatter),
      std::cref(log_fpe),
      std::cref(log_grid),
      std::cref(log_hyperSurfaceCrossing),
      std::cref(log_inputParser),
      std::cref(log_lattice),
      std::cref(log_nucleus),
      std::cref(log_particleType),
      std::cref(log_pauliBlocking),
      std::cref(log_potentials),
      std::cref(log_propagation),
      std::cref(log_pythia),
      std::cref(log_resonances),
      std::cref(log_rootsolver),
      std::cref(log_scatterAction),
      std::cref(log_scatterActionMulti),
      std::cref(log_tmn),
      std::cref(version),
      std::cref(collTerm_additionalElasticCrossSection),
      std::cref(collTerm_collisionCriterion),
      std::cref(collTerm_crossSectionScaling),
      std::cref(collTerm_elasticCrossSection),
      std::cref(collTerm_elasticNNCutoffSqrts),
      std::cref(collTerm_totXsStrategy),
      std::cref(collTerm_pseudoresonance),
      std::cref(collTerm_fixedMinCellLength),
      std::cref(collTerm_forceDecaysAtEnd),
      std::cref(collTerm_ignoreDecayWidthAtTheEnd),
      std::cref(collTerm_includeDecaysAtTheEnd),
      std::cref(collTerm_decayInitial),
      std::cref(collTerm_includedTwoToTwo),
      std::cref(collTerm_isotropic),
      std::cref(collTerm_maximumCrossSection),
      std::cref(collTerm_multiParticleReactions),
      std::cref(collTerm_nnbarTreatment),
      std::cref(collTerm_noCollisions),
      std::cref(collTerm_onlyWarnForHighProbability),
      std::cref(collTerm_resonanceLifetimeModifier),
      std::cref(collTerm_strings),
      std::cref(collTerm_stringsWithProbability),
      std::cref(collTerm_twoToOne),
      std::cref(collTerm_useAQM),
      std::cref(collTerm_pauliBlocking_gaussianCutoff),
      std::cref(collTerm_pauliBlocking_momentumAveragingRadius),
      std::cref(collTerm_pauliBlocking_spatialAveragingRadius),
      std::cref(collTerm_stringTrans_KNOffset),
      std::cref(collTerm_stringTrans_pipiOffset),
      std::cref(collTerm_stringTrans_lower),
      std::cref(collTerm_stringTrans_rangeNN),
      std::cref(collTerm_stringTrans_rangeNpi),
      std::cref(collTerm_stringTrans_range_width),
      std::cref(collTerm_stringParam_diquarkSuppression),
      std::cref(collTerm_stringParam_formTimeFactor),
      std::cref(collTerm_stringParam_formationTime),
      std::cref(collTerm_stringParam_gluonBeta),
      std::cref(collTerm_stringParam_gluonPMin),
      std::cref(collTerm_stringParam_mDependentFormationTimes),
      std::cref(collTerm_stringParam_quarkAlpha),
      std::cref(collTerm_stringParam_quarkBeta),
      std::cref(collTerm_stringParam_popcornRate),
      std::cref(collTerm_stringParam_powerParticleFormation),
      std::cref(collTerm_stringParam_probabilityPToDUU),
      std::cref(collTerm_stringParam_separateFragmentBaryon),
      std::cref(collTerm_stringParam_sigmaPerp),
      std::cref(collTerm_stringParam_strangeSuppression),
      std::cref(collTerm_stringParam_stringSigmaT),
      std::cref(collTerm_stringParam_stringTension),
      std::cref(collTerm_stringParam_stringZA),
      std::cref(collTerm_stringParam_stringZALeading),
      std::cref(collTerm_stringParam_stringZB),
      std::cref(collTerm_stringParam_stringZBLeading),
      std::cref(collTerm_stringParam_useMonashTune),
      std::cref(collTerm_dileptons_decays),
      std::cref(collTerm_photons_twoToTwoScatterings),
      std::cref(collTerm_photons_bremsstrahlung),
      std::cref(collTerm_photons_fractionalPhotons),
      std::cref(collTerm_HF_AQMbSuppression),
      std::cref(collTerm_HF_AQMcSuppression),
      std::cref(modi_collider_eKin),
      std::cref(modi_collider_eTot),
      std::cref(modi_collider_pLab),
      std::cref(modi_collider_sqrtSNN),
      std::cref(modi_collider_calculationFrame),
      std::cref(modi_collider_collisionWithinNucleus),
      std::cref(modi_collider_fermiMotion),
      std::cref(modi_collider_initialDistance),
      std::cref(modi_collider_projectile_diffusiveness),
      std::cref(modi_collider_target_diffusiveness),
      std::cref(modi_collider_projectile_particles),
      std::cref(modi_collider_target_particles),
      std::cref(modi_collider_projectile_radius),
      std::cref(modi_collider_target_radius),
      std::cref(modi_collider_projectile_saturationDensity),
      std::cref(modi_collider_target_saturationDensity),
      std::cref(modi_collider_projectile_eKin),
      std::cref(modi_collider_target_eKin),
      std::cref(modi_collider_projectile_eTot),
      std::cref(modi_collider_target_eTot),
      std::cref(modi_collider_projectile_pLab),
      std::cref(modi_collider_target_pLab),
      std::cref(modi_collider_projectile_custom_fileDirectory),
      std::cref(modi_collider_target_custom_fileDirectory),
      std::cref(modi_collider_projectile_custom_fileName),
      std::cref(modi_collider_target_custom_fileName),
      std::cref(modi_collider_projectile_deformed_automatic),
      std::cref(modi_collider_target_deformed_automatic),
      std::cref(modi_collider_projectile_deformed_beta2),
      std::cref(modi_collider_target_deformed_beta2),
      std::cref(modi_collider_projectile_deformed_beta3),
      std::cref(modi_collider_target_deformed_beta3),
      std::cref(modi_collider_projectile_deformed_beta4),
      std::cref(modi_collider_target_deformed_beta4),
      std::cref(modi_collider_projectile_deformed_gamma),
      std::cref(modi_collider_target_deformed_gamma),
      std::cref(modi_collider_projectile_alphaClustered_automatic),
      std::cref(modi_collider_target_alphaClustered_automatic),
      std::cref(modi_collider_projectile_alphaClustered_sideLength),
      std::cref(modi_collider_target_alphaClustered_sideLength),
      std::cref(modi_collider_projectile_orientation_phi),
      std::cref(modi_collider_target_orientation_phi),
      std::cref(modi_collider_projectile_orientation_psi),
      std::cref(modi_collider_target_orientation_psi),
      std::cref(modi_collider_projectile_orientation_randRot),
      std::cref(modi_collider_target_orientation_randRot),
      std::cref(modi_collider_projectile_orientation_theta),
      std::cref(modi_collider_target_orientation_theta),
      std::cref(modi_collider_impact_max),
      std::cref(modi_collider_impact_randomReactionPlane),
      std::cref(modi_collider_impact_range),
      std::cref(modi_collider_impact_sample),
      std::cref(modi_collider_impact_value),
      std::cref(modi_collider_impact_values),
      std::cref(modi_collider_impact_yields),
      std::cref(modi_collider_initialConditions_eDenThreshold),
      std::cref(modi_collider_initialConditions_fluidCells),
      std::cref(modi_collider_initialConditions_formTimeFraction),
      std::cref(modi_collider_initialConditions_fluidProcesses),
      std::cref(modi_collider_initialConditions_lowerBound),
      std::cref(modi_collider_initialConditions_maxTime),
      std::cref(modi_collider_initialConditions_minTime),
      std::cref(modi_collider_initialConditions_properTime),
      std::cref(modi_collider_initialConditions_pTCut),
      std::cref(modi_collider_initialConditions_rapidityCut),
      std::cref(modi_collider_initialConditions_type),
      std::cref(modi_sphere_initialMultiplicities),
      std::cref(modi_sphere_radius),
      std::cref(modi_sphere_startTime),
      std::cref(modi_sphere_temperature),
      std::cref(modi_sphere_accountResonanceWidths),
      std::cref(modi_sphere_addRadialVelocity),
      std::cref(modi_sphere_baryonChemicalPotential),
      std::cref(modi_sphere_chargeChemicalPotential),
      std::cref(modi_sphere_initialCondition),
      std::cref(modi_sphere_strangeChemicalPotential),
      std::cref(modi_sphere_useThermalMultiplicities),
      std::cref(modi_sphere_jet_jetMomentum),
      std::cref(modi_sphere_jet_jetPdg),
      std::cref(modi_box_initialMultiplicities),
      std::cref(modi_box_initialCondition),
      std::cref(modi_box_length),
      std::cref(modi_box_startTime),
      std::cref(modi_box_temperature),
      std::cref(modi_box_accountResonanceWidths),
      std::cref(modi_box_baryonChemicalPotential),
      std::cref(modi_box_chargeChemicalPotential),
      std::cref(modi_box_equilibrationTime),
      std::cref(modi_box_strangeChemicalPotential),
      std::cref(modi_box_useThermalMultiplicities),
      std::cref(modi_box_jet_jetMomentum),
      std::cref(modi_box_jet_jetPdg),
      std::cref(modi_list_fileDirectory),
      std::cref(modi_list_filename),
      std::cref(modi_list_filePrefix),
      std::cref(modi_list_shiftId),
      std::cref(modi_listBox_fileDirectory),
      std::cref(modi_listBox_filename),
      std::cref(modi_listBox_filePrefix),
      std::cref(modi_listBox_length),
      std::cref(modi_listBox_shiftId),
      std::cref(output_densityType),
      std::cref(output_outputInterval),
      std::cref(output_outputTimes),
      std::cref(output_particles_format),
      std::cref(output_collisions_format),
      std::cref(output_dileptons_format),
      std::cref(output_photons_format),
      std::cref(output_initialConditions_format),
      std::cref(output_rivet_format),
      std::cref(output_coulomb_format),
      std::cref(output_thermodynamics_format),
      std::cref(output_particles_extended),
      std::cref(output_particles_quantities),
      std::cref(output_particles_onlyFinal),
      std::cref(output_collisions_extended),
      std::cref(output_collisions_quantities),
      std::cref(output_collisions_printStartEnd),
      std::cref(output_dileptons_extended),
      std::cref(output_photons_extended),
      std::cref(output_initialConditions_extended),
      std::cref(output_initialConditions_lowerBound),
      std::cref(output_initialConditions_properTime),
      std::cref(output_initialConditions_pTCut),
      std::cref(output_initialConditions_rapidityCut),
      std::cref(output_rivet_analyses),
      std::cref(output_rivet_crossSection),
      std::cref(output_rivet_ignoreBeams),
      std::cref(output_rivet_logging),
      std::cref(output_rivet_paths),
      std::cref(output_rivet_preloads),
      std::cref(output_rivet_weights_cap),
      std::cref(output_rivet_weights_deselect),
      std::cref(output_rivet_weights_nloSmearing),
      std::cref(output_rivet_weights_noMulti),
      std::cref(output_rivet_weights_nominal),
      std::cref(output_rivet_weights_select),
      std::cref(output_thermodynamics_onlyParticipants),
      std::cref(output_thermodynamics_position),
      std::cref(output_thermodynamics_quantites),
      std::cref(output_thermodynamics_smearing),
      std::cref(output_thermodynamics_type),
      std::cref(lattice_automatic),
      std::cref(lattice_cellNumber),
      std::cref(lattice_origin),
      std::cref(lattice_periodic),
      std::cref(lattice_potentialsAffectThreshold),
      std::cref(lattice_sizes),
      std::cref(potentials_use_potentials_outside_lattice),
      std::cref(potentials_skyrme_skyrmeA),
      std::cref(potentials_skyrme_skyrmeB),
      std::cref(potentials_skyrme_skyrmeTau),
      std::cref(potentials_symmetry_gamma),
      std::cref(potentials_symmetry_sPot),
      std::cref(potentials_vdf_coeffs),
      std::cref(potentials_vdf_powers),
      std::cref(potentials_vdf_satRhoB),
      std::cref(potentials_coulomb_rCut),
      std::cref(potentials_momentum_dependence_C),
      std::cref(potentials_momentum_dependence_Lambda),
      std::cref(forcedThermalization_cellNumber),
      std::cref(forcedThermalization_criticalEDensity),
      std::cref(forcedThermalization_startTime),
      std::cref(forcedThermalization_timestep),
      std::cref(forcedThermalization_algorithm),
      std::cref(forcedThermalization_latticeSizes),
      std::cref(forcedThermalization_microcanonical)};
 
  static const Key<einhard::LogLevel> &get_logging_key(std::string_view area) {
    return get_key_reference<einhard::LogLevel>({"Logging", std::string{area}});
  }
 
  static const Key<std::vector<std::string>> &get_output_format_key(
      std::string_view content) {
    return get_key_reference<std::vector<std::string>>(
        {"Output", std::string{content}, "Format"});
  }
 
 private:
  template <typename T>
  static const Key<T> &get_key_reference(const KeyLabels &labels) {
    using key_reference = std::reference_wrapper<const Key<T>>;
    auto candidate = InputKeys::find_key(labels);
    if (candidate.has_value()) {
      return std::get<key_reference>(candidate.value());
    } else {
      throw std::invalid_argument("No database key with keys \"" +
                                  join(labels, ": ") + "\" was found.");
    }
  }
 
  static std::optional<key_references_variant> find_key(
      const KeyLabels &labels) {
    if (labels.size() == 0)
      return std::nullopt;
    auto iterator_to_key_references_variant =
        std::find_if(smash::InputKeys::list.begin(),
                     smash::InputKeys::list.end(), [&labels](auto key) {
                       return std::visit(
                           [&labels](auto &&arg) {
                             return arg.get().has_same_labels(labels);
                           },
                           key);
                     });
    if (iterator_to_key_references_variant == smash::InputKeys::list.end()) {
      return std::nullopt;
    } else {
      return *iterator_to_key_references_variant;
    }
  }
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_INPUT_KEYS_H_