input_keys.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2022-2024
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_INPUT_KEYS_H_
#define SRC_INCLUDE_SMASH_INPUT_KEYS_H_
 
#include <any>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include "smash/configuration.h"
#include "smash/stringfunctions.h"
 
namespace smash {
using Version = std::string;
 
using KeyLabels = std::vector<std::string>;
 
template <typename default_type>
class Key {
 public:
  struct WrongNumberOfVersions : public std::runtime_error {
    using std::runtime_error::runtime_error;
  };
 
  explicit Key(const std::initializer_list<std::string_view>& labels,
               const std::initializer_list<std::string_view>& versions)
      : Key{labels, std::nullopt, versions} {}
 
  Key(const std::initializer_list<std::string_view>& labels,
      const std::optional<default_type>& value,
      const std::initializer_list<std::string_view>& versions)
      : default_{value}, labels_{labels.begin(), labels.end()} {
    /*
     * The following switch statement is a compact way to initialize the
     * three version member variables without repetition and lots of logic
     * clauses. The versions variable can have 1, 2 or 3 entries. The use of
     * the iterator is needed, since std::initializer_list has no access
     * operator.
     */
    switch (auto it = versions.end(); versions.size()) {
      case 3:
        removed_in_ = *(--it);
        [[fallthrough]];
      case 2:
        deprecated_in_ = *(--it);
        [[fallthrough]];
      case 1:
        introduced_in_ = *(--it);
        break;
      default:
        throw WrongNumberOfVersions(
            "Key constructor needs one, two or three version numbers.");
    }
  }
 
  using type = default_type;
 
  default_type default_value() const { return default_.value(); }
 
  Version introduced_in() const noexcept { return introduced_in_; }
 
  Version deprecated_in() const { return deprecated_in_.value(); }
 
  Version removed_in() const { return removed_in_.value(); }
 
  bool is_deprecated() const noexcept { return deprecated_in_.has_value(); }
 
  bool is_allowed() const noexcept { return !removed_in_.has_value(); }
 
  bool has_same_labels(const KeyLabels& labels) const noexcept {
    return std::equal(std::begin(labels_), std::end(labels_),
                      std::begin(labels), std::end(labels));
  }
 
  explicit operator std::string() const noexcept {
    return smash::quote(smash::join(labels_, ": "));
  }
 
  const KeyLabels& labels() const { return labels_; }
 
 private:
  Version introduced_in_{};
  std::optional<Version> deprecated_in_{};
  std::optional<Version> removed_in_{};
  std::optional<default_type> default_{};
  KeyLabels labels_{};
};
 
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{{"General", "End_Time"},
                                              {"0.50"}};
 
  inline static const Key<std::string> gen_modus{{"General", "Modus"},
                                                 {"0.50"}};
 
  inline static const Key<int> gen_nevents{{"General", "Nevents"}, {"0.50"}};
 
  inline static const Key<int> gen_randomseed{{"General", "Randomseed"},
                                              {"0.50"}};
 
  inline static const Key<int> gen_minNonEmptyEnsembles_maximumEnsembles{
      {"General", "Minimum_Nonempty_Ensembles", "Maximum_Ensembles_Run"},
      {"2.2"}};
 
  inline static const Key<int> gen_minNonEmptyEnsembles_number{
      {"General", "Minimum_Nonempty_Ensembles", "Number"}, {"1.3"}};
 
  inline static const Key<double> gen_deltaTime{
      {"General", "Delta_Time"}, 1.0, {"0.50"}};
 
  inline static const Key<DerivativesMode> gen_derivativesMode{
      {"General", "Derivatives_Mode"},
      DerivativesMode::CovariantGaussian,
      {"2.1"}};
 
  inline static const Key<double> gen_smearingDiscreteWeight{
      {"General", "Discrete_Weight"}, 1. / 3, {"2.1"}};
 
  inline static const Key<int> gen_ensembles{
      {"General", "Ensembles"}, 1, {"2.1"}};
 
  inline static const Key<double> gen_expansionRate{
      {"General", "Expansion_Rate"}, 0.1, {"1.1"}};
 
  inline static const Key<FieldDerivativesMode> gen_fieldDerivativesMode{
      {"General", "Field_Derivatives_Mode"},
      FieldDerivativesMode::ChainRule,
      {"2.1"}};
 
  inline static const Key<double> gen_smearingGaussCutoffInSigma{
      {"General", "Gauss_Cutoff_In_Sigma"}, 4.0, {"0.80"}};
 
  inline static const Key<double> gen_smearingGaussianSigma{
      {"General", "Gaussian_Sigma"}, 1.0, {"0.60"}};
 
  inline static const Key<ExpansionMode> gen_metricType{
      {"General", "Metric_Type"}, ExpansionMode::NoExpansion, {"1.1"}};
 
  inline static const Key<RestFrameDensityDerivativesMode>
      gen_restFrameDensityDerivativeMode{
          {"General", "Rest_Frame_Density_Derivatives_Mode"},
          RestFrameDensityDerivativesMode::Off,
          {"2.1"}};
 
  inline static const Key<SmearingMode> gen_smearingMode{
      {"General", "Smearing_Mode"}, SmearingMode::CovariantGaussian, {"2.1"}};
 
  inline static const Key<int> gen_testparticles{
      {"General", "Testparticles"}, 1, {"0.50"}};
 
  inline static const Key<TimeStepMode> gen_timeStepMode{
      {"General", "Time_Step_Mode"}, TimeStepMode::Fixed, {"0.85"}};
 
  inline static const Key<double> gen_smearingTriangularRange{
      {"General", "Triangular_Range"}, 2.0, {"2.1"}};
 
  inline static const Key<bool> gen_useGrid{
      {"General", "Use_Grid"}, true, {"0.80"}};
 
  inline static const Key<einhard::LogLevel> log_default{
      {"Logging", "default"}, einhard::ALL, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_box{{"Logging", "Box"},
                                                     {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_collider{
      {"Logging", "Collider"}, {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_yamlConfiguration{
      {"Logging", "Configuration"}, {"3.0"}};
 
  inline static const Key<einhard::LogLevel> log_experiment{
      {"Logging", "Experiment"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_grandcanThermalizer{
      {"Logging", "GrandcanThermalizer"}, {"1.2"}};
 
  inline static const Key<einhard::LogLevel> log_initialConditions{
      {"Logging", "InitialConditions"}, {"1.8"}};
 
  inline static const Key<einhard::LogLevel> log_list{{"Logging", "List"},
                                                      {"0.60"}};
 
  inline static const Key<einhard::LogLevel> log_main{{"Logging", "Main"},
                                                      {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_output{{"Logging", "Output"},
                                                        {"0.60"}};
 
  inline static const Key<einhard::LogLevel> log_potentials{
      {"Logging", "Potentials"}, {"3.1"}};
 
  inline static const Key<einhard::LogLevel> log_rootsolver{
      {"Logging", "RootSolver"}, {"3.1"}};
 
  inline static const Key<einhard::LogLevel> log_sphere{{"Logging", "Sphere"},
                                                        {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_action{{"Logging", "Action"},
                                                        {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_clock{{"Logging", "Clock"},
                                                       {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_crossSections{
      {"Logging", "CrossSections"}, {"1.3"}};
 
  inline static const Key<einhard::LogLevel> log_decayModes{
      {"Logging", "DecayModes"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_density{{"Logging", "Density"},
                                                         {"0.60"}};
 
  inline static const Key<einhard::LogLevel> log_distributions{
      {"Logging", "Distributions"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_findScatter{
      {"Logging", "FindScatter"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_fpe{{"Logging", "Fpe"},
                                                     {"0.80"}};
 
  inline static const Key<einhard::LogLevel> log_grid{{"Logging", "Grid"},
                                                      {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_hyperSurfaceCrossing{
      {"Logging", "HyperSurfaceCrossing"}, {"1.7"}};
 
  inline static const Key<einhard::LogLevel> log_inputParser{
      {"Logging", "InputParser"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_lattice{{"Logging", "Lattice"},
                                                         {"0.80"}};
 
  inline static const Key<einhard::LogLevel> log_nucleus{{"Logging", "Nucleus"},
                                                         {"0.30"}};
 
  inline static const Key<einhard::LogLevel> log_particleType{
      {"Logging", "ParticleType"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_pauliBlocking{
      {"Logging", "PauliBlocking"}, {"0.7.1"}};
 
  inline static const Key<einhard::LogLevel> log_propagation{
      {"Logging", "Propagation"}, {"0.7.1"}};
 
  inline static const Key<einhard::LogLevel> log_pythia{{"Logging", "Pythia"},
                                                        {"1.0"}};
 
  inline static const Key<einhard::LogLevel> log_resonances{
      {"Logging", "Resonances"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_scatterAction{
      {"Logging", "ScatterAction"}, {"0.50"}};
 
  inline static const Key<einhard::LogLevel> log_scatterActionMulti{
      {"Logging", "ScatterActionMulti"}, {"2.0"}};
 
  inline static const Key<einhard::LogLevel> log_tmn{{"Logging", "Tmn"},
                                                     {"0.80"}};
 
  inline static const Key<std::string> version{{"Version"}, {"1.0", "3.0"}};
 
  inline static const Key<double> collTerm_additionalElasticCrossSection{
      {"Collision_Term", "Additional_Elastic_Cross_Section"}, 0.0, {"2.0"}};
 
  inline static const Key<CollisionCriterion> collTerm_collisionCriterion{
      {"Collision_Term", "Collision_Criterion"},
      CollisionCriterion::Covariant,
      {"1.7"}};
 
  inline static const Key<double> collTerm_crossSectionScaling{
      {"Collision_Term", "Cross_Section_Scaling"}, 1.0, {"2.0"}};
 
  inline static const Key<double> collTerm_elasticCrossSection{
      {"Collision_Term", "Elastic_Cross_Section"}, -1.0, {"1.2"}};
 
  inline static const Key<double> collTerm_elasticNNCutoffSqrts{
      {"Collision_Term", "Elastic_NN_Cutoff_Sqrts"}, 1.98, {"1.0"}};
 
  inline static const Key<TotalCrossSectionStrategy> collTerm_totXsStrategy{
      {"Collision_Term", "Total_Cross_Section_Strategy"},
      TotalCrossSectionStrategy::TopDownMeasured,
      {"3.1"}};
 
  inline static const Key<PseudoResonance> collTerm_pseudoresonance{
      {"Collision_Term", "Pseudoresonance"},
      PseudoResonance::LargestFromUnstable,
      {"3.1"}};
 
  inline static const Key<double> collTerm_fixedMinCellLength{
      {"Collision_Term", "Fixed_Min_Cell_Length"}, 2.5, {"2.1"}};
 
  inline static const Key<bool> collTerm_forceDecaysAtEnd{
      {"Collision_Term", "Force_Decays_At_End"}, true, {"0.60"}};
 
  inline static const Key<bool> collTerm_includeDecaysAtTheEnd{
      {"Collision_Term", "Include_Weak_And_EM_Decays_At_The_End"},
      false,
      {"2.2", "3.1"}};
 
  inline static const Key<bool> collTerm_decayInitial{
      {"Collision_Term", "Decay_Initial_Particles"}, true, {"3.0"}};
 
  inline static const Key<ReactionsBitSet> collTerm_includedTwoToTwo{
      {"Collision_Term", "Included_2to2"},
      ReactionsBitSet{}.set(),  // All interactions => all bit set
      {"1.3"}};
 
  inline static const Key<bool> collTerm_isotropic{
      {"Collision_Term", "Isotropic"}, false, {"0.7.1"}};
 
  inline static const Key<double> collTerm_maximumCrossSection{
      {"Collision_Term", "Maximum_Cross_Section"}, {"2.0"}};
 
  inline static const Key<MultiParticleReactionsBitSet>
      collTerm_multiParticleReactions{
          {"Collision_Term", "Multi_Particle_Reactions"},
          MultiParticleReactionsBitSet{}.reset(),  // Empty list => no bit set
          {"2.0"}};
 
  inline static const Key<NNbarTreatment> collTerm_nnbarTreatment{
      {"Collision_Term", "NNbar_Treatment"}, NNbarTreatment::Strings, {"1.3"}};
 
  inline static const Key<bool> collTerm_noCollisions{
      {"Collision_Term", "No_Collisions"}, false, {"1.3"}};
 
  inline static const Key<bool> collTerm_onlyWarnForHighProbability{
      {"Collision_Term", "Only_Warn_For_High_Probability"}, false, {"3.0"}};
 
  inline static const Key<double> collTerm_resonanceLifetimeModifier{
      {"Collision_Term", "Resonance_Lifetime_Modifier"}, 1.0, {"1.8"}};
 
  inline static const Key<bool> collTerm_strings{{"Collision_Term", "Strings"},
                                                 {"1.0"}};
 
  inline static const Key<bool> collTerm_stringsWithProbability{
      {"Collision_Term", "Strings_with_Probability"}, true, {"1.3"}};
 
  inline static const Key<bool> collTerm_twoToOne{
      {"Collision_Term", "Two_to_One"}, true, {"0.85"}};
 
  inline static const Key<bool> collTerm_useAQM{
      {"Collision_Term", "Use_AQM"}, true, {"1.3"}};
 
  inline static const Key<double> collTerm_pauliBlocking_gaussianCutoff{
      {"Collision_Term", "Pauli_Blocking", "Gaussian_Cutoff"}, 2.2, {"0.7.1"}};
 
  inline static const Key<double>
      collTerm_pauliBlocking_momentumAveragingRadius{
          {"Collision_Term", "Pauli_Blocking", "Momentum_Averaging_Radius"},
          0.08,
          {"0.7.1"}};
 
  inline static const Key<double> collTerm_pauliBlocking_spatialAveragingRadius{
      {"Collision_Term", "Pauli_Blocking", "Spatial_Averaging_Radius"},
      1.86,
      {"0.7.1"}};
 
  inline static const Key<double> collTerm_stringTrans_KNOffset{
      {"Collision_Term", "String_Transition", "KN_Offset"}, 15.15, {"3.0"}};
 
  inline static const Key<double> collTerm_stringTrans_pipiOffset{
      {"Collision_Term", "String_Transition", "PiPi_Offset"}, 1.12, {"3.0"}};
 
  inline static const Key<double> collTerm_stringTrans_lower{
      {"Collision_Term", "String_Transition", "Sqrts_Lower"}, 0.9, {"3.0"}};
 
  inline static const Key<std::pair<double, double>>
      collTerm_stringTrans_rangeNN{
          {"Collision_Term", "String_Transition", "Sqrts_Range_NN"},
          std::make_pair(3.5, 4.5),
          {"3.0"}};
 
  inline static const Key<std::pair<double, double>>
      collTerm_stringTrans_rangeNpi{
          {"Collision_Term", "String_Transition", "Sqrts_Range_Npi"},
          std::make_pair(1.9, 2.2),
          {"3.0"}};
 
  inline static const Key<double> collTerm_stringTrans_range_width{
      {"Collision_Term", "String_Transition", "Sqrts_Range_Width"},
      1.0,
      {"3.0"}};
 
  inline static const Key<double> collTerm_stringParam_diquarkSuppression{
      {"Collision_Term", "String_Parameters", "Diquark_Supp"}, 0.036, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_formTimeFactor{
      {"Collision_Term", "String_Parameters", "Form_Time_Factor"},
      1.0,
      {"1.4"}};
 
  inline static const Key<double> collTerm_stringParam_formationTime{
      {"Collision_Term", "String_Parameters", "Formation_Time"}, 1.0, {"1.0"}};
 
  inline static const Key<double> collTerm_stringParam_gluonBeta{
      {"Collision_Term", "String_Parameters", "Gluon_Beta"}, 0.5, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_gluonPMin{
      {"Collision_Term", "String_Parameters", "Gluon_Pmin"}, 0.001, {"1.3"}};
 
  inline static const Key<bool> collTerm_stringParam_mDependentFormationTimes{
      {"Collision_Term", "String_Parameters", "Mass_Dependent_Formation_Times"},
      false,
      {"1.5.2"}};
 
  inline static const Key<double> collTerm_stringParam_quarkAlpha{
      {"Collision_Term", "String_Parameters", "Quark_Alpha"}, 2.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_quarkBeta{
      {"Collision_Term", "String_Parameters", "Quark_Beta"}, 7.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_popcornRate{
      {"Collision_Term", "String_Parameters", "Popcorn_Rate"}, 0.15, {"1.6"}};
 
  inline static const Key<double> collTerm_stringParam_powerParticleFormation{
      {"Collision_Term", "String_Parameters", "Power_Particle_Formation"},
      {"1.4"}};
 
  inline static const Key<double> collTerm_stringParam_probabilityPToDUU{
      {"Collision_Term", "String_Parameters", "Prob_proton_to_d_uu"},
      1.0 / 3,
      {"1.5"}};
 
  inline static const Key<bool> collTerm_stringParam_separateFragmentBaryon{
      {"Collision_Term", "String_Parameters", "Separate_Fragment_Baryon"},
      true,
      {"1.6"}};
 
  inline static const Key<double> collTerm_stringParam_sigmaPerp{
      {"Collision_Term", "String_Parameters", "Sigma_Perp"}, 0.42, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_strangeSuppression{
      {"Collision_Term", "String_Parameters", "Strange_Supp"}, 0.16, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringSigmaT{
      {"Collision_Term", "String_Parameters", "String_Sigma_T"}, 0.5, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringTension{
      {"Collision_Term", "String_Parameters", "String_Tension"}, 1.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringZA{
      {"Collision_Term", "String_Parameters", "StringZ_A"}, 2.0, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringZALeading{
      {"Collision_Term", "String_Parameters", "StringZ_A_Leading"},
      0.2,
      {"1.6"}};
 
  inline static const Key<double> collTerm_stringParam_stringZB{
      {"Collision_Term", "String_Parameters", "StringZ_B"}, 0.55, {"1.3"}};
 
  inline static const Key<double> collTerm_stringParam_stringZBLeading{
      {"Collision_Term", "String_Parameters", "StringZ_B_Leading"},
      2.0,
      {"1.6"}};
 
  inline static const Key<bool> collTerm_stringParam_useMonashTune{
      {"Collision_Term", "String_Parameters", "Use_Monash_Tune"},
      false,
      {"3.0"}};
 
  inline static const Key<bool> collTerm_dileptons_decays{
      {"Collision_Term", "Dileptons", "Decays"}, false, {"0.50"}};
 
  inline static const Key<bool> collTerm_photons_twoToTwoScatterings{
      {"Collision_Term", "Photons", "2to2_Scatterings"}, false, {"1.8"}};
 
  inline static const Key<bool> collTerm_photons_bremsstrahlung{
      {"Collision_Term", "Photons", "Bremsstrahlung"}, false, {"1.8"}};
 
  inline static const Key<int> collTerm_photons_fractionalPhotons{
      {"Collision_Term", "Photons", "Fractional_Photons"}, {"1.8"}};
 
  inline static const Key<double> modi_collider_eKin{
      {"Modi", "Collider", "E_Kin"}, {"0.50"}};
 
  inline static const Key<double> modi_collider_eTot{
      {"Modi", "Collider", "E_Tot"}, {"2.0.2"}};
 
  inline static const Key<double> modi_collider_pLab{
      {"Modi", "Collider", "P_Lab"}, {"0.50"}};
 
  inline static const Key<double> modi_collider_sqrtSNN{
      {"Modi", "Collider", "Sqrtsnn"}, {"0.50"}};
 
  inline static const Key<CalculationFrame> modi_collider_calculationFrame{
      {"Modi", "Collider", "Calculation_Frame"},
      CalculationFrame::CenterOfVelocity,
      {"0.50"}};
 
  inline static const Key<bool> modi_collider_collisionWithinNucleus{
      {"Modi", "Collider", "Collisions_Within_Nucleus"}, false, {"1.0"}};
 
  inline static const Key<FermiMotion> modi_collider_fermiMotion{
      {"Modi", "Collider", "Fermi_Motion"}, FermiMotion::Off, {"0.60"}};
 
  inline static const Key<double> modi_collider_initialDistance{
      {"Modi", "Collider", "Initial_Distance"}, 2.0, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_diffusiveness{
      {"Modi", "Collider", "Projectile", "Diffusiveness"}, {"0.90"}};
  inline static const Key<double> modi_collider_target_diffusiveness{
      {"Modi", "Collider", "Target", "Diffusiveness"}, {"0.90"}};
 
  inline static const Key<std::map<PdgCode, int>>
      modi_collider_projectile_particles{
          {"Modi", "Collider", "Projectile", "Particles"}, {"0.50"}};
  inline static const Key<std::map<PdgCode, int>>
      modi_collider_target_particles{
          {"Modi", "Collider", "Target", "Particles"}, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_radius{
      {"Modi", "Collider", "Projectile", "Radius"}, {"0.50"}};
  inline static const Key<double> modi_collider_target_radius{
      {"Modi", "Collider", "Target", "Radius"}, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_saturationDensity{
      {"Modi", "Collider", "Projectile", "Saturation_Density"}, {"0.50"}};
  inline static const Key<double> modi_collider_target_saturationDensity{
      {"Modi", "Collider", "Target", "Saturation_Density"}, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_eKin{
      {"Modi", "Collider", "Projectile", "E_Kin"}, {"0.50"}};
  inline static const Key<double> modi_collider_target_eKin{
      {"Modi", "Collider", "Target", "E_Kin"}, {"0.50"}};
 
  inline static const Key<double> modi_collider_projectile_eTot{
      {"Modi", "Collider", "Projectile", "E_Tot"}, {"2.0.2"}};
  inline static const Key<double> modi_collider_target_eTot{
      {"Modi", "Collider", "Target", "E_Tot"}, {"2.0.2"}};
 
  inline static const Key<double> modi_collider_projectile_pLab{
      {"Modi", "Collider", "Projectile", "P_Lab"}, {"0.50"}};
  inline static const Key<double> modi_collider_target_pLab{
      {"Modi", "Collider", "Target", "P_Lab"}, {"0.50"}};
 
  inline static const Key<std::string>
      modi_collider_projectile_custom_fileDirectory{
          {"Modi", "Collider", "Projectile", "Custom", "File_Directory"},
          {"1.6"}};
  inline static const Key<std::string>
      modi_collider_target_custom_fileDirectory{
          {"Modi", "Collider", "Target", "Custom", "File_Directory"}, {"1.6"}};
 
  inline static const Key<std::string> modi_collider_projectile_custom_fileName{
      {"Modi", "Collider", "Projectile", "Custom", "File_Name"}, {"1.6"}};
  inline static const Key<std::string> modi_collider_target_custom_fileName{
      {"Modi", "Collider", "Target", "Custom", "File_Name"}, {"1.6"}};
 
  inline static const Key<bool> modi_collider_projectile_deformed_automatic{
      {"Modi", "Collider", "Projectile", "Deformed", "Automatic"}, {"1.5"}};
  inline static const Key<bool> modi_collider_target_deformed_automatic{
      {"Modi", "Collider", "Target", "Deformed", "Automatic"}, {"1.5"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_beta2{
      {"Modi", "Collider", "Projectile", "Deformed", "Beta_2"}, 0.0, {"1.5"}};
  inline static const Key<double> modi_collider_target_deformed_beta2{
      {"Modi", "Collider", "Target", "Deformed", "Beta_2"}, 0.0, {"1.5"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_beta3{
      {"Modi", "Collider", "Projectile", "Deformed", "Beta_3"}, 0.0, {"3.0"}};
  inline static const Key<double> modi_collider_target_deformed_beta3{
      {"Modi", "Collider", "Target", "Deformed", "Beta_3"}, 0.0, {"3.0"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_beta4{
      {"Modi", "Collider", "Projectile", "Deformed", "Beta_4"}, 0.0, {"1.5"}};
  inline static const Key<double> modi_collider_target_deformed_beta4{
      {"Modi", "Collider", "Target", "Deformed", "Beta_4"}, 0.0, {"1.5"}};
 
  inline static const Key<double> modi_collider_projectile_deformed_gamma{
      {"Modi", "Collider", "Projectile", "Deformed", "Gamma"}, 0.0, {"3.0"}};
  inline static const Key<double> modi_collider_target_deformed_gamma{
      {"Modi", "Collider", "Target", "Deformed", "Gamma"}, 0.0, {"3.0"}};
 
  inline static const Key<double>
      modi_collider_projectile_deformed_orientation_phi{
          {"Modi", "Collider", "Projectile", "Deformed", "Orientation", "Phi"},
          0.0,
          {"0.50"}};
  inline static const Key<double> modi_collider_target_deformed_orientation_phi{
      {"Modi", "Collider", "Target", "Deformed", "Orientation", "Phi"},
      0.0,
      {"0.50"}};
 
  inline static const Key<double>
      modi_collider_projectile_deformed_orientation_psi{
          {"Modi", "Collider", "Projectile", "Deformed", "Orientation", "Psi"},
          0.0,
          {"3.0"}};
  inline static const Key<double> modi_collider_target_deformed_orientation_psi{
      {"Modi", "Collider", "Target", "Deformed", "Orientation", "Psi"},
      0.0,
      {"3.0"}};
 
  inline static const Key<bool>
      modi_collider_projectile_deformed_orientation_randomRotation{
          {"Modi", "Collider", "Projectile", "Deformed", "Orientation",
           "Random_Rotation"},
          false,
          {"1.7"}};
  inline static const Key<bool>
      modi_collider_target_deformed_orientation_randomRotation{
          {"Modi", "Collider", "Target", "Deformed", "Orientation",
           "Random_Rotation"},
          false,
          {"1.7"}};
 
  inline static const Key<double>
      modi_collider_projectile_deformed_orientation_theta{
          {"Modi", "Collider", "Projectile", "Deformed", "Orientation",
           "Theta"},
          M_PI / 2,
          {"0.50"}};
  inline static const Key<double>
      modi_collider_target_deformed_orientation_theta{
          {"Modi", "Collider", "Target", "Deformed", "Orientation", "Theta"},
          M_PI / 2,
          {"0.50"}};
 
  inline static const Key<double> modi_collider_impact_max{
      {"Modi", "Collider", "Impact", "Max"}, 0.0, {"0.50"}};
 
  inline static const Key<bool> modi_collider_impact_randomReactionPlane{
      {"Modi", "Collider", "Impact", "Random_Reaction_Plane"}, false, {"1.8"}};
 
  inline static const Key<std::array<double, 2>> modi_collider_impact_range{
      {"Modi", "Collider", "Impact", "Range"}, {{0.0, 0.0}}, {"0.50"}};
 
  inline static const Key<Sampling> modi_collider_impact_sample{
      {"Modi", "Collider", "Impact", "Sample"}, Sampling::Quadratic, {"0.50"}};
 
  inline static const Key<double> modi_collider_impact_value{
      {"Modi", "Collider", "Impact", "Value"}, 0.0, {"0.50"}};
 
  inline static const Key<std::vector<double>> modi_collider_impact_values{
      {"Modi", "Collider", "Impact", "Values"}, {"0.80"}};
 
  inline static const Key<std::vector<double>> modi_collider_impact_yields{
      {"Modi", "Collider", "Impact", "Yields"}, {"0.80"}};
 
  inline static const Key<std::map<PdgCode, int>>
      modi_sphere_initialMultiplicities{
          {"Modi", "Sphere", "Init_Multiplicities"}, {"0.50"}};
 
  inline static const Key<double> modi_sphere_radius{
      {"Modi", "Sphere", "Radius"}, {"0.50"}};
 
  inline static const Key<double> modi_sphere_startTime{
      {"Modi", "Sphere", "Start_Time"}, {"0.50"}};
 
  inline static const Key<double> modi_sphere_temperature{
      {"Modi", "Sphere", "Temperature"}, {"1.5.2"}};
 
  inline static const Key<bool> modi_sphere_accountResonanceWidths{
      {"Modi", "Sphere", "Account_Resonance_Widths"}, true, {"1.7"}};
 
  inline static const Key<double> modi_sphere_addRadialVelocity{
      {"Modi", "Sphere", "Add_Radial_Velocity"}, -1.0, {"2.2"}};
 
  inline static const Key<double> modi_sphere_baryonChemicalPotential{
      {"Modi", "Sphere", "Baryon_Chemical_Potential"}, 0.0, {"1.0"}};
 
  inline static const Key<double> modi_sphere_chargeChemicalPotential{
      {"Modi", "Sphere", "Charge_Chemical_Potential"}, 0.0, {"2.1"}};
 
  inline static const Key<SphereInitialCondition> modi_sphere_initialCondition{
      {"Modi", "Sphere", "Initial_Condition"},
      SphereInitialCondition::ThermalMomentaBoltzmann,
      {"1.1"}};
 
  inline static const Key<double> modi_sphere_strangeChemicalPotential{
      {"Modi", "Sphere", "Strange_Chemical_Potential"}, 0.0, {"1.0"}};
 
  inline static const Key<bool> modi_sphere_useThermalMultiplicities{
      {"Modi", "Sphere", "Use_Thermal_Multiplicities"}, false, {"1.0"}};
 
  inline static const Key<double> modi_sphere_jet_jetMomentum{
      {"Modi", "Sphere", "Jet", "Jet_Momentum"}, 20.0, {"1.5.2"}};
 
  inline static const Key<PdgCode> modi_sphere_jet_jetPdg{
      {"Modi", "Sphere", "Jet", "Jet_PDG"}, {"1.5.2"}};
 
  inline static const Key<std::map<PdgCode, int>>
      modi_box_initialMultiplicities{{"Modi", "Box", "Init_Multiplicities"},
                                     {"0.50"}};
 
  inline static const Key<BoxInitialCondition> modi_box_initialCondition{
      {"Modi", "Box", "Initial_Condition"}, {"0.50"}};
 
  inline static const Key<double> modi_box_length{{"Modi", "Box", "Length"},
                                                  {"0.50"}};
 
  inline static const Key<double> modi_box_startTime{
      {"Modi", "Box", "Start_Time"}, {"0.50"}};
 
  inline static const Key<double> modi_box_temperature{
      {"Modi", "Box", "Temperature"}, {"0.50"}};
 
  inline static const Key<bool> modi_box_accountResonanceWidths{
      {"Modi", "Box", "Account_Resonance_Widths"}, true, {"1.7"}};
 
  inline static const Key<double> modi_box_baryonChemicalPotential{
      {"Modi", "Box", "Baryon_Chemical_Potential"}, 0.0, {"1.0"}};
 
  inline static const Key<double> modi_box_chargeChemicalPotential{
      {"Modi", "Box", "Charge_Chemical_Potential"}, 0.0, {"2.0"}};
 
  inline static const Key<double> modi_box_equilibrationTime{
      {"Modi", "Box", "Equilibration_Time"}, -1.0, {"1.8"}};
 
  inline static const Key<double> modi_box_strangeChemicalPotential{
      {"Modi", "Box", "Strange_Chemical_Potential"}, 0.0, {"1.0"}};
 
  inline static const Key<bool> modi_box_useThermalMultiplicities{
      {"Modi", "Box", "Use_Thermal_Multiplicities"}, false, {"1.0"}};
 
  inline static const Key<double> modi_box_jet_jetMomentum{
      {"Modi", "Box", "Jet", "Jet_Momentum"}, 20.0, {"1.7"}};
 
  inline static const Key<PdgCode> modi_box_jet_jetPdg{
      {"Modi", "Box", "Jet", "Jet_PDG"}, {"1.7"}};
 
  inline static const Key<std::string> modi_list_fileDirectory{
      {"Modi", "List", "File_Directory"}, {"0.60"}};
 
  inline static const Key<std::string> modi_list_filename{
      {"Modi", "List", "Filename"}, {"3.1"}};
 
  inline static const Key<std::string> modi_list_filePrefix{
      {"Modi", "List", "File_Prefix"}, {"0.60"}};
 
  inline static const Key<int> modi_list_shiftId{
      {"Modi", "List", "Shift_Id"}, 0, {"0.60"}};
 
  inline static const Key<std::string> modi_listBox_fileDirectory{
      {"Modi", "ListBox", "File_Directory"}, {"2.1"}};
 
  inline static const Key<std::string> modi_listBox_filename{
      {"Modi", "ListBox", "Filename"}, {"3.1"}};
 
  inline static const Key<std::string> modi_listBox_filePrefix{
      {"Modi", "ListBox", "File_Prefix"}, {"2.1"}};
 
  inline static const Key<double> modi_listBox_length{
      {"Modi", "ListBox", "Length"}, {"2.1"}};
 
  inline static const Key<int> modi_listBox_shiftId{
      {"Modi", "ListBox", "Shift_Id"}, 0, {"2.1"}};
 
  inline static const Key<std::string> output_densityType{
      {"Output", "Density_Type"}, "none", {"0.60"}};
 
  inline static const Key<double> output_outputInterval{
      {"Output", "Output_Interval"}, {"0.50"}};
 
  inline static const Key<std::vector<double>> output_outputTimes{
      {"Output", "Output_Times"}, {"1.7"}};
 
  inline static const Key<std::vector<std::string>> output_particles_format{
      {"Output", "Particles", "Format"}, {}, {"1.2"}};
  inline static const Key<std::vector<std::string>> output_collisions_format{
      {"Output", "Collisions", "Format"}, {}, {"1.2"}};
  inline static const Key<std::vector<std::string>> output_dileptons_format{
      {"Output", "Dileptons", "Format"}, {}, {"0.85"}};
  inline static const Key<std::vector<std::string>> output_photons_format{
      {"Output", "Photons", "Format"}, {}, {"1.0"}};
  inline static const Key<std::vector<std::string>>
      output_initialConditions_format{
          {"Output", "Initial_Conditions", "Format"}, {}, {"1.7"}};
  inline static const Key<std::vector<std::string>> output_rivet_format{
      {"Output", "Rivet", "Format"}, {}, {"2.0.2"}};
  inline static const Key<std::vector<std::string>> output_coulomb_format{
      {"Output", "Coulomb", "Format"}, {}, {"2.1"}};
  inline static const Key<std::vector<std::string>>
      output_thermodynamics_format{
          {"Output", "Thermodynamics", "Format"}, {}, {"1.2"}};
 
  inline static const Key<bool> output_particles_extended{
      {"Output", "Particles", "Extended"}, false, {"1.2"}};
 
  inline static const Key<OutputOnlyFinal> output_particles_onlyFinal{
      {"Output", "Particles", "Only_Final"}, OutputOnlyFinal::Yes, {"0.50"}};
 
  inline static const Key<bool> output_collisions_extended{
      {"Output", "Collisions", "Extended"}, false, {"1.2"}};
 
  inline static const Key<bool> output_collisions_printStartEnd{
      {"Output", "Collisions", "Print_Start_End"}, false, {"0.50"}};
 
  inline static const Key<bool> output_dileptons_extended{
      {"Output", "Dileptons", "Extended"}, false, {"1.2"}};
 
  inline static const Key<bool> output_photons_extended{
      {"Output", "Photons", "Extended"}, false, {"1.5"}};
 
  inline static const Key<bool> output_initialConditions_extended{
      {"Output", "Initial_Conditions", "Extended"}, false, {"1.7"}};
 
  inline static const Key<double> output_initialConditions_lowerBound{
      {"Output", "Initial_Conditions", "Lower_Bound"}, 0.5, {"1.8"}};
 
  inline static const Key<double> output_initialConditions_properTime{
      {"Output", "Initial_Conditions", "Proper_Time"}, {"1.7"}};
 
  inline static const Key<double> output_initialConditions_pTCut{
      {"Output", "Initial_Conditions", "pT_Cut"}, {"2.2"}};
 
  inline static const Key<double> output_initialConditions_rapidityCut{
      {"Output", "Initial_Conditions", "Rapidity_Cut"}, {"2.2"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_analyses{
      {"Output", "Rivet", "Analyses"}, {"2.0.2"}};
 
  inline static const Key<std::array<double, 2>> output_rivet_crossSection{
      {"Output", "Rivet", "Cross_Section"}, {"2.0.2"}};
 
  inline static const Key<bool> output_rivet_ignoreBeams{
      {"Output", "Rivet", "Ignore_Beams"}, true, {"2.0.2"}};
 
  inline static const Key<std::map<std::string, std::string>>
      output_rivet_logging{{"Output", "Rivet", "Logging"}, {"0.50"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_paths{
      {"Output", "Rivet", "Paths"}, {"2.0.2"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_preloads{
      {"Output", "Rivet", "Preloads"}, {"2.0.2"}};
 
  inline static const Key<double> output_rivet_weights_cap{
      {"Output", "Rivet", "Weights", "Cap"}, {"2.0.2"}};
 
  inline static const Key<std::vector<std::string>>
      output_rivet_weights_deselect{{"Output", "Rivet", "Weights", "Deselect"},
                                    {"2.0.2"}};
 
  inline static const Key<double> output_rivet_weights_nloSmearing{
      {"Output", "Rivet", "Weights", "NLO_Smearing"}, {"2.0.2"}};
 
  inline static const Key<std::array<double, 2>> output_rivet_weights_noMulti{
      {"Output", "Rivet", "Weights", "No_Multi"}, {"2.0.2"}};
 
  inline static const Key<std::string> output_rivet_weights_nominal{
      {"Output", "Rivet", "Weights", "Nominal"}, {"2.0.2"}};
 
  inline static const Key<std::vector<std::string>> output_rivet_weights_select{
      {"Output", "Rivet", "Weights", "Select"}, {"2.0.2"}};
 
  inline static const Key<bool> output_thermodynamics_onlyParticipants{
      {"Output", "Thermodynamics", "Only_Participants"}, false, {"2.1"}};
 
  inline static const Key<std::array<double, 3>> output_thermodynamics_position{
      {"Output", "Thermodynamics", "Position"}, {{0.0, 0.0, 0.0}}, {"1.0"}};
 
  inline static const Key<std::set<ThermodynamicQuantity>>
      output_thermodynamics_quantites{
          {"Output", "Thermodynamics", "Quantities"}, {}, {"1.0"}};
 
  inline static const Key<bool> output_thermodynamics_smearing{
      {"Output", "Thermodynamics", "Smearing"}, true, {"1.0"}};
 
  inline static const Key<DensityType> output_thermodynamics_type{
      {"Output", "Thermodynamics", "Type"}, DensityType::Baryon, {"1.0"}};
 
  inline static const Key<bool> lattice_automatic{{"Lattice", "Automatic"},
                                                  {"3.0"}};
 
  inline static const Key<std::array<int, 3>> lattice_cellNumber{
      {"Lattice", "Cell_Number"}, {"0.80"}};
 
  inline static const Key<std::array<double, 3>> lattice_origin{
      {"Lattice", "Origin"}, {"0.80"}};
 
  inline static const Key<bool> lattice_periodic{{"Lattice", "Periodic"},
                                                 {"0.80"}};
 
  inline static const Key<bool> lattice_potentialsAffectThreshold{
      {"Lattice", "Potentials_Affect_Thresholds"}, false, {"1.3"}};
 
  inline static const Key<std::array<double, 3>> lattice_sizes{
      {"Lattice", "Sizes"}, {"0.80"}};
 
  inline static const Key<bool> potentials_use_potentials_outside_lattice{
      {"Potentials", "Use_Potentials_Outside_Lattice"}, true, {"3.1"}};
 
  inline static const Key<double> potentials_skyrme_skyrmeA{
      {"Potentials", "Skyrme", "Skyrme_A"}, {"0.60"}};
 
  inline static const Key<double> potentials_skyrme_skyrmeB{
      {"Potentials", "Skyrme", "Skyrme_B"}, {"0.60"}};
 
  inline static const Key<double> potentials_skyrme_skyrmeTau{
      {"Potentials", "Skyrme", "Skyrme_Tau"}, {"0.60"}};
 
  inline static const Key<double> potentials_symmetry_gamma{
      {"Potentials", "Symmetry", "gamma"}, {"1.7"}};
 
  inline static const Key<double> potentials_symmetry_sPot{
      {"Potentials", "Symmetry", "S_Pot"}, {"0.60"}};
 
  inline static const Key<std::vector<double>> potentials_vdf_coeffs{
      {"Potentials", "VDF", "Coeffs"}, {"2.1"}};
 
  inline static const Key<std::vector<double>> potentials_vdf_powers{
      {"Potentials", "VDF", "Powers"}, {"2.1"}};
 
  inline static const Key<double> potentials_vdf_satRhoB{
      {"Potentials", "VDF", "Sat_rhoB"}, {"2.1"}};
 
  inline static const Key<std::vector<double>> potentials_coulomb_rCut{
      {"Potentials", "Coulomb", "R_Cut"}, {"2.1"}};
 
  inline static const Key<double> potentials_momentum_dependence_C{
      {"Potentials", "Momentum_Dependence", "C"}, {"3.1"}};
 
  inline static const Key<double> potentials_momentum_dependence_Lambda{
      {"Potentials", "Momentum_Dependence", "Lambda"}, {"3.1"}};
 
  inline static const Key<std::array<int, 3>> forcedThermalization_cellNumber{
      {"Forced_Thermalization", "Cell_Number"}, {"1.1"}};
 
  inline static const Key<double> forcedThermalization_criticalEDensity{
      {"Forced_Thermalization", "Critical_Edens"}, {"1.1"}};
 
  inline static const Key<double> forcedThermalization_startTime{
      {"Forced_Thermalization", "Start_Time"}, {"1.1"}};
 
  inline static const Key<double> forcedThermalization_timestep{
      {"Forced_Thermalization", "Timestep"}, {"1.1"}};
 
  inline static const Key<ThermalizationAlgorithm>
      forcedThermalization_algorithm{{"Forced_Thermalization", "Algorithm"},
                                     ThermalizationAlgorithm::BiasedBF,
                                     {"1.1"}};
 
  inline static const Key<std::array<double, 3>>
      forcedThermalization_latticeSizes{
          {"Forced_Thermalization", "Lattice_Sizes"}, {"1.1"}};
 
  inline static const Key<bool> forcedThermalization_microcanonical{
      {"Forced_Thermalization", "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<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<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_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(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_deformed_orientation_phi),
      std::cref(modi_collider_target_deformed_orientation_phi),
      std::cref(modi_collider_projectile_deformed_orientation_psi),
      std::cref(modi_collider_target_deformed_orientation_psi),
      std::cref(modi_collider_projectile_deformed_orientation_randomRotation),
      std::cref(modi_collider_target_deformed_orientation_randomRotation),
      std::cref(modi_collider_projectile_deformed_orientation_theta),
      std::cref(modi_collider_target_deformed_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_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_onlyFinal),
      std::cref(output_collisions_extended),
      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)};
};
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_INPUT_KEYS_H_