smash::Configuration::Value Class Reference

Proxy object to be used when taking or reading keys in the configuration.

This type automatically converts to the target type e.g. on assignment. An object of this type is returned by the private take and read methods and it is constructed from the YAML::Node to be taken or read.

This class is an implementation detail of Configuration and can be ignored by users of Configuration.

Definition at line 803 of file configuration.h.

Public Member Functions
	Value (const Value &)=delete
	If you want to copy this you're doing it wrong. More...
Value &	operator= (const Value &)=delete
	If you want to copy this you're doing it wrong. More...
template<typename T >
	operator T () const
	This function determines the type it is assigned to and calls YAML::Node::as<T>() with this type. More...
template<typename T >
	operator std::vector< T > () const
	Check conversion exceptions. More...
template<typename T , size_t N>
	operator std::array< T, N > () const
	Cast array of keys to a std::array of length N. More...
	operator ReactionsBitSet () const
	Set ReactionBitSet from configuration values. More...
	operator MultiParticleReactionsBitSet () const
	Set MultiParticleReactionsBitSet from configuration values. More...
	operator std::set< ThermodynamicQuantity > () const
	Set thermodynamic quantity from configuration values. More...
	operator CalculationFrame () const
	Set calculation frame from configuration values. More...
	operator FermiMotion () const
	(De-)Activate Fermi motion from configuration values. More...
	operator DensityType () const
	Set density type from configuration values. More...
	operator ExpansionMode () const
	Set expansion mode from configuration values. More...
	operator DerivativesMode () const
	Set DerivativesMode. More...
	operator FieldDerivativesMode () const
	Set FieldDerivatives mode. More...
	operator SmearingMode () const
	Set SmearingMode. More...
	operator TimeStepMode () const
	Set time step mode from configuration values. More...
	operator BoxInitialCondition () const
	Set initial condition for box setup from configuration values. More...
	operator SphereInitialCondition () const
	Set initial condition for sphere setup from configuration values. More...
	operator NNbarTreatment () const
	Set treatment of N-Nbar reactions from configuration values. More...
	operator Sampling () const
	Set cross-section sampling method from configuration values. More...
	operator ThermalizationAlgorithm () const
	Set algorithm for forced thermalization from configuration values. More...
	operator CollisionCriterion () const
	Set collision criterion from configuration values. More...
	operator TotalCrossSectionStrategy () const
	Set total cross section strategy from configuration values. More...
	operator PseudoResonance () const
	Set how pseudo-resonances are used from configuration values. More...
	operator FluidizationType () const
	Set condition of fluidization for hydrodynamic initial conditions. More...
	operator OutputOnlyFinal () const
	Set OutputOnlyFinal for particles output from configuration values. More...
	operator FluidizableProcessesBitSet () const
	Set FluidizableProcessesBitSet from configuration values. More...

Private Member Functions
	Value (const YAML::Node &n, const char *key)
	Construct the Value wrapper from a YAML::Node. More...

Private Attributes
const YAML::Node	node_
	a YAML leaf node More...
const char *const	key_
	The key to be interpreted. More...

Friends
class	Configuration

Constructor & Destructor Documentation

Value() [1/2]

smash::Configuration::Value::Value ( const YAML::Node &  n, const char *  key  )

inlineprivate

Construct the Value wrapper from a YAML::Node.

Note

This constructor must be implicit, otherwise it's impossible to return an rvalue Value object - because the copy constructor is deleted.

Definition at line 817 of file configuration.h.

                                              : node_(n), key_(key) {
      if (!(n.IsScalar() || n.IsSequence() || n.IsMap())) {
        std::stringstream err;
        err << "Configuration value for \"" << key
            << "\" is missing or invalid";
        throw std::runtime_error(err.str());
      }
    }

Value() [2/2]

smash::Configuration::Value::Value ( const Value &  )

delete

If you want to copy this you're doing it wrong.

Member Function Documentation

operator=()

Value& smash::Configuration::Value::operator= ( const Value &  )

delete

If you want to copy this you're doing it wrong.

operator T()

template<typename T >

smash::Configuration::Value::operator T ( ) const

inline

This function determines the type it is assigned to and calls YAML::Node::as<T>() with this type.

This makes reading values more convenient than calling as<type>() explicitly.

Exceptions

IncorrectTypeInAssignment

Definition at line 841 of file configuration.h.

                       {
      try {
        return node_.as<T>();
      } catch (YAML::TypedBadConversion<T> &e) {
        throw IncorrectTypeInAssignment(
            "The value for key \"" + std::string(key_) +
            "\" cannot be converted to the requested type.");
      }
    }

operator std::vector< T >()

template<typename T >

smash::Configuration::Value::operator std::vector< T > ( ) const

inline

Check conversion exceptions.

Exceptions

IncorrectTypeInAssignment

in case type conversion failed.

Definition at line 857 of file configuration.h.

                                  {
      try {
        return node_.as<std::vector<T>>();
      } catch (YAML::TypedBadConversion<T> &e) {
        throw IncorrectTypeInAssignment(
            "One of the values in the sequence for key \"" + std::string(key_) +
            "\" failed to convert to the requested type. E.g. [1 2] is a "
            "sequence of one string \"1 2\" and [1, 2] is a sequence of two "
            "integers. Often there is just a comma missing in the config "
            "file.");
      } catch (YAML::TypedBadConversion<std::vector<T>> &e) {
        throw IncorrectTypeInAssignment(
            "The value for key \"" + std::string(key_) +
            "\" cannot be converted to the requested type. A sequence was "
            "expected but apparently not found.");
      }
    }

operator std::array< T, N >()

template<typename T , size_t N>

smash::Configuration::Value::operator std::array< T, N > ( ) const

inline

Cast array of keys to a std::array of length N.

Returns

Array of std::array type.

Exceptions

IncorrectTypeInAssignment

in case the number of keys does not match the length of the newly generated array.

Definition at line 883 of file configuration.h.

                                    {
      const std::vector<T> vec = operator std::vector<T>();
      const size_t n_read = vec.size();
      // Alert if size does not match
      if (n_read != N) {
        throw IncorrectTypeInAssignment("Wrong number of values in array \"" +
                                        std::string(key_) + "\". Expected " +
                                        std::to_string(N) +
                                        " values,"
                                        " found " +
                                        std::to_string(n_read) + ".");
      }
      std::array<T, N> arr;
      std::copy_n(vec.begin(), N, arr.begin());
      return arr;
    }

operator ReactionsBitSet()

smash::Configuration::Value::operator ReactionsBitSet ( ) const

inline

Set ReactionBitSet from configuration values.

Returns

ReactionBitSet with all included reaction types.

Exceptions

IncorrectTypeInAssignment

in case a reaction type that is not available is provided as a configuration value.

Definition at line 907 of file configuration.h.

                                     {
      const std::vector<std::string> v = operator std::vector<std::string>();
      ReactionsBitSet s;
      for (const auto &x : v) {
        if (x == "All") {
          s.set();
          break;
        } else if (x == "Elastic") {
          s.set(IncludedReactions::Elastic);
        } else if (x == "NN_to_NR") {
          s.set(IncludedReactions::NN_to_NR);
        } else if (x == "NN_to_DR") {
          s.set(IncludedReactions::NN_to_DR);
        } else if (x == "KN_to_KN") {
          s.set(IncludedReactions::KN_to_KN);
        } else if (x == "KN_to_KDelta") {
          s.set(IncludedReactions::KN_to_KDelta);
        } else if (x == "Strangeness_exchange") {
          s.set(IncludedReactions::Strangeness_exchange);
        } else if (x == "NNbar") {
          s.set(IncludedReactions::NNbar);
        } else if (x == "PiDeuteron_to_NN") {
          s.set(IncludedReactions::PiDeuteron_to_NN);
        } else if (x == "PiDeuteron_to_pidprime") {
          s.set(IncludedReactions::PiDeuteron_to_pidprime);
        } else if (x == "NDeuteron_to_Ndprime") {
          s.set(IncludedReactions::NDeuteron_to_Ndprime);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"All\", \"Elastic\", \"NN_to_NR\", \"NN_to_DR\","
              "\"KN_to_KN\", \"KN_to_KDelta\", \"PiDeuteron_to_NN\", "
              "\"PiDeuteron_to_pidprime\", \"NDeuteron_to_Ndprime\", "
              "\"Strangeness_exchange\" or "
              "\"NNbar\", or any combination of these.");
        }
      }
      return s;
    }

operator MultiParticleReactionsBitSet()

smash::Configuration::Value::operator MultiParticleReactionsBitSet ( ) const

inline

Set MultiParticleReactionsBitSet from configuration values.

Returns

MultiParticleReactionsBitSet with all included reaction types.

Exceptions

IncorrectTypeInAssignment

in case a reaction type that is not available is provided as a configuration value.

Definition at line 954 of file configuration.h.

                                                  {
      const std::vector<std::string> v = operator std::vector<std::string>();
      MultiParticleReactionsBitSet s;
      for (const auto &x : v) {
        if (x == "All") {
          s.set();
          break;
        } else if (x == "Meson_3to1") {
          s.set(IncludedMultiParticleReactions::Meson_3to1);
        } else if (x == "Deuteron_3to2") {
          s.set(IncludedMultiParticleReactions::Deuteron_3to2);
        } else if (x == "NNbar_5to2") {
          s.set(IncludedMultiParticleReactions::NNbar_5to2);
        } else if (x == "A3_Nuclei_4to2") {
          s.set(IncludedMultiParticleReactions::A3_Nuclei_4to2);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"All\", \"Meson_3to1\", "
              "\"Deuteron_3to2\" or \"NNbar_5to2\", "
              "\"A3_Nuclei_4to2\", or any combination of "
              "these.");
        }
      }
      return s;
    }

operator std::set< ThermodynamicQuantity >()

smash::Configuration::Value::operator std::set< ThermodynamicQuantity > ( ) const

inline

Set thermodynamic quantity from configuration values.

Returns

Set of thermodynamic quantity.

Exceptions

IncorrectTypeInAssignment

in case a thermodynamic quantity that is not available is provided as a configuration value.

Definition at line 988 of file configuration.h.

                                                   {
      const std::vector<std::string> v = operator std::vector<std::string>();
      std::set<ThermodynamicQuantity> s;
      for (const auto &x : v) {
        if (x == "rho_eckart") {
          s.insert(ThermodynamicQuantity::EckartDensity);
        } else if (x == "tmn") {
          s.insert(ThermodynamicQuantity::Tmn);
        } else if (x == "tmn_landau") {
          s.insert(ThermodynamicQuantity::TmnLandau);
        } else if (x == "landau_velocity") {
          s.insert(ThermodynamicQuantity::LandauVelocity);
        } else if (x == "j_QBS") {
          s.insert(ThermodynamicQuantity::j_QBS);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"rho_eckart\", \"tmn\""
              ", \"tmn_landau\", \"landau_velocity\" or \"j_QBS\".");
        }
      }
      return s;
    }

operator CalculationFrame()

smash::Configuration::Value::operator CalculationFrame ( ) const

inline

Set calculation frame from configuration values.

Returns

string of calculation frame.

Exceptions

IncorrectTypeInAssignment

in case a calculation frame that is not available is provided as a configuration value.

Definition at line 1019 of file configuration.h.

                                      {
      const std::string s = operator std::string();
      if (s == "center of velocity") {
        return CalculationFrame::CenterOfVelocity;
      }
      if (s == "center of mass") {
        return CalculationFrame::CenterOfMass;
      }
      if (s == "fixed target") {
        return CalculationFrame::FixedTarget;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"center of velocity\" or \"center of mass\" "
          "or \"fixed target\".");
    }

operator FermiMotion()

smash::Configuration::Value::operator FermiMotion ( ) const

inline

(De-)Activate Fermi motion from configuration values.

Returns

Fermi motion setup.

Exceptions

IncorrectTypeInAssignment

in case a Fermi motion value that is not available is provided as a configuration value.

Definition at line 1043 of file configuration.h.

                                 {
      const std::string s = operator std::string();
      if (s == "off") {
        return FermiMotion::Off;
      }
      if (s == "on") {
        return FermiMotion::On;
      }
      if (s == "frozen") {
        return FermiMotion::Frozen;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"off\" or \"on\" or \"frozen\".");
    }

operator DensityType()

smash::Configuration::Value::operator DensityType ( ) const

inline

Set density type from configuration values.

Returns

Density type.

Exceptions

IncorrectTypeInAssignment

in case a density type that is not available is provided as a configuration value.

Definition at line 1066 of file configuration.h.

                                 {
      const std::string s = operator std::string();
      if (s == "hadron") {
        return DensityType::Hadron;
      }
      if (s == "baryon") {
        return DensityType::Baryon;
      }
      if (s == "baryonic isospin") {
        return DensityType::BaryonicIsospin;
      }
      if (s == "pion") {
        return DensityType::Pion;
      }
      if (s == "total isospin") {
        return DensityType::Isospin3_tot;
      }
      if (s == "none") {
        return DensityType::None;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) +
                                      "\" should be \"hadron\" or \"baryon\" "
                                      "or \"baryonic isospin\" or \"pion\" "
                                      "or \"none\".");
    }

operator ExpansionMode()

smash::Configuration::Value::operator ExpansionMode ( ) const

inline

Set expansion mode from configuration values.

Returns

Expansion mode.

Exceptions

IncorrectTypeInAssignment

in case an expansion mode that is not available is provided as a configuration value.

Definition at line 1100 of file configuration.h.

                                   {
      const std::string s = operator std::string();
      if (s == "NoExpansion") {
        return ExpansionMode::NoExpansion;
      }
      if (s == "MasslessFRW") {
        return ExpansionMode::MasslessFRW;
      }
      if (s == "MassiveFRW") {
        return ExpansionMode::MassiveFRW;
      }
      if (s == "Exponential") {
        return ExpansionMode::Exponential;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"NoExpansion\", \"MasslessFRW\"," +
          "\"MassiveFRW\" or \"Exponential\".");
    }

operator DerivativesMode()

smash::Configuration::Value::operator DerivativesMode ( ) const

inline

Set DerivativesMode.

Definition at line 1123 of file configuration.h.

                                     {
      const std::string s = operator std::string();
      if (s == "Covariant Gaussian") {
        return DerivativesMode::CovariantGaussian;
      }
      if (s == "Finite difference") {
        return DerivativesMode::FiniteDifference;
      }
      if (s == "Off") {
        return DerivativesMode::Off;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"Covariant Gaussian\", \"Finite difference\"," +
          " or \"Off\".");
    }

operator FieldDerivativesMode()

smash::Configuration::Value::operator FieldDerivativesMode ( ) const

inline

Set FieldDerivatives mode.

Definition at line 1143 of file configuration.h.

                                          {
      const std::string s = operator std::string();
      if (s == "Chain Rule") {
        return FieldDerivativesMode::ChainRule;
      }
      if (s == "Direct") {
        return FieldDerivativesMode::Direct;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"Chain Rule\" or \"Direct\".");
    }

operator SmearingMode()

smash::Configuration::Value::operator SmearingMode ( ) const

inline

Set SmearingMode.

Definition at line 1159 of file configuration.h.

                                  {
      const std::string s = operator std::string();
      if (s == "Covariant Gaussian") {
        return SmearingMode::CovariantGaussian;
      }
      if (s == "Discrete") {
        return SmearingMode::Discrete;
      }
      if (s == "Triangular") {
        return SmearingMode::Triangular;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"Covariant Gaussian\", \"Discrete\"," +
          " or \"Triangular\".");
    }

operator TimeStepMode()

smash::Configuration::Value::operator TimeStepMode ( ) const

inline

Set time step mode from configuration values.

Returns

time step mode.

Exceptions

IncorrectTypeInAssignment

in case a time step mode that is not available is provided as a configuration value.

Definition at line 1183 of file configuration.h.

                                  {
      const std::string s = operator std::string();
      if (s == "None") {
        return TimeStepMode::None;
      }
      if (s == "Fixed") {
        return TimeStepMode::Fixed;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) +
                                      "\" should be \"None\" or \"Fixed\".");
    }

operator BoxInitialCondition()

smash::Configuration::Value::operator BoxInitialCondition ( ) const

inline

Set initial condition for box setup from configuration values.

Returns

Initial condition for box setup.

Exceptions

IncorrectTypeInAssignment

in case an initial conditions that is not available is provided as a configuration value.

Definition at line 1203 of file configuration.h.

                                         {
      const std::string s = operator std::string();
      if (s == "thermal momenta") {
        return BoxInitialCondition::ThermalMomentaBoltzmann;
      }
      if (s == "thermal momenta quantum") {
        return BoxInitialCondition::ThermalMomentaQuantum;
      }
      if (s == "peaked momenta") {
        return BoxInitialCondition::PeakedMomenta;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"thermal momenta\", \"thermal momenta quantum\", " +
          "or \"peaked momenta\".");
    }

operator SphereInitialCondition()

smash::Configuration::Value::operator SphereInitialCondition ( ) const

inline

Set initial condition for sphere setup from configuration values.

Returns

Initial condition for sphere setup.

Exceptions

IncorrectTypeInAssignment

in case an initial conditions that is not available is provided as a configuration value.

Definition at line 1227 of file configuration.h.

                                            {
      const std::string s = operator std::string();
      if (s == "thermal momenta") {
        return SphereInitialCondition::ThermalMomentaBoltzmann;
      }
      if (s == "thermal momenta quantum") {
        return SphereInitialCondition::ThermalMomentaQuantum;
      }
      if (s == "IC_ES") {
        return SphereInitialCondition::IC_ES;
      }
      if (s == "IC_1M") {
        return SphereInitialCondition::IC_1M;
      }
      if (s == "IC_2M") {
        return SphereInitialCondition::IC_2M;
      }
      if (s == "IC_Massive") {
        return SphereInitialCondition::IC_Massive;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"thermal momenta\", \"thermal momenta quantum\", " +
          "\"IC_ES\", \"IC_1M\", \"IC_2M\" or" + "\"IC_Massive\".");
    }

operator NNbarTreatment()

smash::Configuration::Value::operator NNbarTreatment ( ) const

inline

Set treatment of N-Nbar reactions from configuration values.

Returns

N-Nbar treatment.

Exceptions

IncorrectTypeInAssignment

in case an N-Nbar treatment that is not available is provided as a configuration value.

Definition at line 1260 of file configuration.h.

                                    {
      const std::string s = operator std::string();
      if (s == "no annihilation") {
        return NNbarTreatment::NoAnnihilation;
      }
      if (s == "resonances") {
        return NNbarTreatment::Resonances;
      }
      if (s == "two to five") {
        return NNbarTreatment::TwoToFive;
      }
      if (s == "strings") {
        return NNbarTreatment::Strings;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"no annihilation\", \"resonances\", \"two to five\" or " +
          " \"strings\".");
    }

operator Sampling()

smash::Configuration::Value::operator Sampling ( ) const

inline

Set cross-section sampling method from configuration values.

Returns

Sampling method of cross-section.

Exceptions

IncorrectTypeInAssignment

in case a sampling method that is not available is provided as a configuration value.

Definition at line 1287 of file configuration.h.

                              {
      const std::string s = operator std::string();
      if (s == "quadratic") {
        return Sampling::Quadratic;
      }
      if (s == "custom") {
        return Sampling::Custom;
      }
      if (s == "uniform") {
        return Sampling::Uniform;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"quadratic\", \"uniform\" or \"custom\".");
    }

operator ThermalizationAlgorithm()

smash::Configuration::Value::operator ThermalizationAlgorithm ( ) const

inline

Set algorithm for forced thermalization from configuration values.

Returns

Algorithm for forced thermalization.

Exceptions

IncorrectTypeInAssignment

in case a thermalization algorithm that is not available is provided as a configuration value.

Definition at line 1310 of file configuration.h.

                                             {
      const std::string s = operator std::string();
      if (s == "mode sampling") {
        return ThermalizationAlgorithm::ModeSampling;
      }
      if (s == "biased BF") {
        return ThermalizationAlgorithm::BiasedBF;
      }
      if (s == "unbiased BF") {
        return ThermalizationAlgorithm::UnbiasedBF;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) +
          "\" should be \"mode sampling\", \"biased BF\" or \"unbiased BF\".");
    }

operator CollisionCriterion()

smash::Configuration::Value::operator CollisionCriterion ( ) const

inline

Set collision criterion from configuration values.

Returns

CollisionCriterion.

Exceptions

IncorrectTypeInAssignment

in case an collision criterion that is not available is provided as a configuration value.

Definition at line 1333 of file configuration.h.

                                        {
      const std::string s = operator std::string();
      if (s == "Geometric") {
        return CollisionCriterion::Geometric;
      }
      if (s == "Stochastic") {
        return CollisionCriterion::Stochastic;
      }
      if (s == "Covariant") {
        return CollisionCriterion::Covariant;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"Geometric\", \"Stochastic\" " + "or \"Covariant\".");
    }

operator TotalCrossSectionStrategy()

smash::Configuration::Value::operator TotalCrossSectionStrategy ( ) const

inline

Set total cross section strategy from configuration values.

Returns

TotalCrossSectionStrategy.

Exceptions

IncorrectTypeInAssignment

in case a strategy that is not available is provided as a configuration value.

Definition at line 1356 of file configuration.h.

                                               {
      const std::string s = operator std::string();
      if (s == "BottomUp") {
        return TotalCrossSectionStrategy::BottomUp;
      }
      if (s == "TopDown") {
        return TotalCrossSectionStrategy::TopDown;
      }
      if (s == "TopDownMeasured") {
        return TotalCrossSectionStrategy::TopDownMeasured;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"BottomUp\", \"TopDown\" " + "or \"TopDownMeasured\".");
    }

operator PseudoResonance()

smash::Configuration::Value::operator PseudoResonance ( ) const

inline

Set how pseudo-resonances are used from configuration values.

Returns

PseudoResonance.

Exceptions

IncorrectTypeInAssignment

in case a key that is not available is provided as a configuration value.

Definition at line 1379 of file configuration.h.

                                     {
      const std::string s = operator std::string();
      if (s == "None") {
        return PseudoResonance::None;
      }
      if (s == "Largest") {
        return PseudoResonance::Largest;
      }
      if (s == "Closest") {
        return PseudoResonance::Closest;
      }
      if (s == "LargestFromUnstable") {
        return PseudoResonance::LargestFromUnstable;
      }
      if (s == "ClosestFromUnstable") {
        return PseudoResonance::ClosestFromUnstable;
      }
      throw IncorrectTypeInAssignment(
          "The value for key \"" + std::string(key_) + "\" should be " +
          "\"None\",  \"Largest\",  \"Closest\", \"LargestFromUnstable\", or "
          "\"ClosestFromUnstable\".");
    }

operator FluidizationType()

smash::Configuration::Value::operator FluidizationType ( ) const

inline

Set condition of fluidization for hydrodynamic initial conditions.

Returns

FluidizationType.

Exceptions

IncorrectTypeInAssignment

in case a key that is not available is provided as a configuration value.

Definition at line 1410 of file configuration.h.

                                      {
      const std::string s = operator std::string();
      if (s == "Constant_Tau") {
        return FluidizationType::ConstantTau;
      } else if (s == "Dynamic") {
        return FluidizationType::Dynamic;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) + "\" should be " +
                                      "\"Constant_Tau\" or \"Dynamic\".");
    }

operator OutputOnlyFinal()

smash::Configuration::Value::operator OutputOnlyFinal ( ) const

inline

Set OutputOnlyFinal for particles output from configuration values.

Returns

OutputOnlyFinal.

Exceptions

IncorrectTypeInAssignment

in case only_final value that is not available is provided as a configuration value.

Definition at line 1429 of file configuration.h.

                                     {
      const std::string s = operator std::string();
      if (s == "Yes") {
        return OutputOnlyFinal::Yes;
      }
      if (s == "No") {
        return OutputOnlyFinal::No;
      }
      if (s == "IfNotEmpty") {
        return OutputOnlyFinal::IfNotEmpty;
      }
      throw IncorrectTypeInAssignment("The value for key \"" +
                                      std::string(key_) + "\" should be " +
                                      "\"Yes\", \"No\" or \"IfNotEmpty\".");
    }

operator FluidizableProcessesBitSet()

smash::Configuration::Value::operator FluidizableProcessesBitSet ( ) const

inline

Set FluidizableProcessesBitSet from configuration values.

Returns

FluidizableProcessesBitSet with all included reaction types.

Exceptions

IncorrectTypeInAssignment

in case a reaction type that is not available is provided as a configuration value.

Definition at line 1452 of file configuration.h.

                                                {
      const std::vector<std::string> v = operator std::vector<std::string>();
      FluidizableProcessesBitSet s;
      for (const auto &x : v) {
        if (x == "All") {
          s.set();
          break;
        } else if (x == "Elastic") {
          s.set(IncludedFluidizableProcesses::From_Elastic);
        } else if (x == "Decay") {
          s.set(IncludedFluidizableProcesses::From_Decay);
        } else if (x == "Inelastic") {
          s.set(IncludedFluidizableProcesses::From_Inelastic);
        } else if (x == "SoftString") {
          s.set(IncludedFluidizableProcesses::From_SoftString);
        } else if (x == "HardString") {
          s.set(IncludedFluidizableProcesses::From_HardString);
        } else {
          throw IncorrectTypeInAssignment(
              "The value for key \"" + std::string(key_) +
              "\" should be \"All\", \"Elastic\", \"Decay\", "
              "\"Inelastic\", \"SoftString\", \"HardString\", "
              "or any combination of these.");
        }
      }
      return s;
    }

Friends And Related Function Documentation

Configuration

friend class Configuration

friend

Definition at line 804 of file configuration.h.

Member Data Documentation

node_

const YAML::Node smash::Configuration::Value::node_

private

a YAML leaf node

Todo:

(steinberg) What is that?

Definition at line 807 of file configuration.h.

key_

const char* const smash::Configuration::Value::key_

private

The key to be interpreted.

Definition at line 809 of file configuration.h.

---

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

• src/include/smash/configuration.h