smash Namespace Reference

Namespaces
	anonymous_namespace{bremsstrahlungactiondilepton.cc}
	anonymous_namespace{configuration.cc}
	anonymous_namespace{decaymodes.cc}
	anonymous_namespace{oscaroutput.cc}
	anonymous_namespace{particletype.cc}
	anonymous_namespace{smash.cc}
	decaytree
	detail
	specialize a type for all of the STL containers.
	InputSections
	A namespace to keep track of all ever existed sections in the input file.
	LogArea
	The namespace where log areas are declared.
	lowess
	pdg
	Constants representing PDG codes.
	random
	Namespace random provides functions for random Number Generation.
	sha256
	Test
	utf8

Classes
class	Action
	Action is the base class for a generic process that takes a number of incoming particles and transforms them into any number of outgoing particles. More...
class	ActionFinderInterface
	ActionFinderInterface is the abstract base class for all action finders, i.e. More...
class	Actions
	The Actions class abstracts the storage and manipulation of actions. More...
class	AlphaClusteredNucleus
	Child of Nucleus for alpha clustered nuclei. More...
class	Angles
	Angles provides a common interface for generating directions: i.e., two angles that should be interpreted as azimuthal and polar angles. More...
class	Average
	Calculate an average value incrementally. More...
class	BinaryOutputBase
	Base class for SMASH binary output. More...
class	BinaryOutputCollisions
	Saves SMASH collision history to binary file. More...
class	BinaryOutputParticles
	Writes the particle list at specific times to the binary file. More...
class	BinaryOutputInitialConditions
	Writes the particles when crossing the hypersurface to the binary file. More...
class	BoxModus
	BoxModus: Provides a modus for infinite matter calculations. More...
class	BremsstrahlungActionDilepton
	Similar to the photon treatment, BremsstrahlungActionDilepton is a special action which takes two incoming particles and performs a perturbative scattering where a Bremsstrahlung photon is produced. More...
class	BremsstrahlungActionPhoton
	BremsAction is a special action which takes two incoming particles and performs a perturbative scattering where a Bremsstrahlung photon is produced. More...
class	ChemicalPotentialSolver
	A class which encapsulates a GSL algorithm for finding the effective chemical potential and supporting functions. More...
class	I_tot_range
	Range of total isospin for reaction of particle a with particle b. More...
class	ClebschGordan
	Class to store and retrieve/calculate Clebsch-Gordan coefficients. More...
class	Clock
	Clock tracks the time in the simulation. More...
class	UniformClock
	Clock with uniformly spaced time steps. More...
class	CustomClock
	Clock with explicitly defined time steps. More...
class	ColliderModus
	ColliderModus: Provides a modus for colliding nuclei. More...
class	Configuration
	Interface to the SMASH configuration files. More...
class	CrossSections
	The CrossSections class assembles everything that is needed to calculate cross sections and gathers a list of all possible reactions for the incoming particles at the given energy with the calculated cross sections. More...
class	CrosssectionsPhoton
class	CrosssectionsPhoton< ComputationMethod::Analytic >
	Class to calculate the cross-section of a meson-meson to meson-photon process. More...
struct	Nucleoncustom
	Contains data for one nucleon that is read in from the list. More...
class	CustomNucleus
	Inheriting from Nucleus-Class using modified Nucleon configurations. More...
struct	remove_cvref
	Definition for remove_cvref type trait, which is in C++20's standard library. More...
class	DecayAction
	DecayAction is a special action which takes one single particle in the initial state and makes it decay into a number of daughter particles (currently two or three). More...
class	DecayActionDilepton
	DecayActionDilepton is special action created for particles that can decay into dileptons. More...
class	DecayActionsFinder
	A simple decay finder: Just loops through all particles and checks if they can decay during the next timestep. More...
class	DecayActionsFinderDilepton
	A dilepton decay finder: Loops through all particles and if they can decay into dileptons, it treats the decays with the shining method. More...
class	DecayModes
	The DecayModes class is used to store and update information about decay branches (i.e. More...
class	DecayType
	DecayType is the abstract base class for all decay types. More...
class	TwoBodyDecay
	TwoBodyDecay represents a decay type with two final-state particles. More...
class	TwoBodyDecayStable
	TwoBodyDecayStable represents a decay type with two stable final-state particles. More...
class	TwoBodyDecaySemistable
	TwoBodyDecaySemistable represents a decay type with two final-state particles, one of which is stable and the other is unstable. More...
class	TwoBodyDecayUnstable
	TwoBodyDecayUnstable represents a decay type with two unstable final-state particles. More...
class	TwoBodyDecayDilepton
	TwoBodyDecayDilepton represents a decay with a lepton and its antilepton as the final-state particles. More...
class	ThreeBodyDecay
	ThreeBodyDecay represents a decay type with three final-state particles. More...
class	ThreeBodyDecayDilepton
	ThreeBodyDecayDilepton represents a decay type with three final-state particles, two of which are leptons. More...
class	DeformedNucleus
	DeformedNucleus: Child of nucleus for deformed nuclei. More...
class	DensityParameters
	A class to pre-calculate and store parameters relevant for density calculation. More...
class	DensityOnLattice
	A class for time-efficient (time-memory trade-off) calculation of density on the lattice. More...
class	DynamicFluidizationFinder
	Finder for dynamic fluidizations. More...
class	EnergyMomentumTensor
	The EnergyMomentumTensor class represents a symmetric positive semi-definite energy-momentum tensor \( T^{\mu \nu}\). More...
class	ExperimentBase
	Non-template interface to Experiment<Modus>. More...
class	Experiment
	The main class, where the simulation of an experiment is executed. More...
struct	ExperimentParameters
	Helper structure for Experiment. More...
class	FieldsOnLattice
	A class for calculating the fields A^mu associated with the VDF potentials. More...
struct	FileDeleter
	FileDeleter is the deleter class for std::unique_ptr of std::FILE. More...
class	RenamingFilePtr
	A RAII type to replace std::FILE *. More...
class	FileLock
	Guard to create a file lock. More...
class	FluidizationAction
	FluidizationAction is a special action indicating that a particle will be removed from the hadronic evolution, and considered a fluid to be evolved with an external hydrodynamics model. More...
class	FourVector
	The FourVector class holds relevant values in Minkowski spacetime with (+, −, −, −) metric signature. More...
class	DisableFloatTraps
	Guard type that safely disables floating point traps for the scope in which it is placed. More...
class	FreeforallAction
	Action class to create any incoming/outgoing particle combination freely. More...
class	ThermLatticeNode
	The ThermLatticeNode class is intended to compute thermodynamical quantities in a cell given a set of particles. More...
class	GrandCanThermalizer
	The GrandCanThermalizer class implements the following functionality: More...
class	GridBase
	Base class for Grid to host common functions that do not depend on the GridOptions parameter. More...
class	Grid
	Abstracts a list of cells that partition the particles in the experiment into regions of space that can interact / cannot interact. More...
class	EosTable
	A class to hold, compute and access tabulated EoS. More...
class	HadronGasEos
	Class to handle the equation of state (EoS) of the hadron gas, consisting of all hadrons included in SMASH. More...
class	HepMcInterface
	Base class for output handlers that need the HepMC3 structure. More...
class	HepMcOutput
	SMASH output to HepMC file. More...
class	HyperSurfaceCrossActionsFinder
	Finder for hypersurface crossing actions. More...
class	ICOutput
	SMASH output in a format containing initial conditions for hydrodynamic codes ("For_vHLLE"). More...
struct	InitialConditionParameters
	The variables in this POD struct are of type std::optional<double> so that only the relevant parameters are set for the different types of initial conditions. More...
struct	InputKeys
	A container to keep track of all ever existed input keys. More...
struct	Line
	Line consists of a line number and the contents of that line. More...
struct	GslWorkspaceDeleter
	A deleter type for std::unique_ptr to be used with gsl_integration_workspace pointers. More...
class	Result
	The result type returned from integrations, containing the value and an error. More...
class	Integrator
	A C++ interface for numerical integration in one dimension with the GSL CQUAD integration functions. More...
struct	Integrand2d
	This is a wrapper for the integrand, so we can pass the limits as well for renormalizing to the unit cube. More...
class	Integrator2d
	A C++ interface for numerical integration in two dimensions with the Cuba Cuhre integration function. More...
class	InterpolateLinear
	Represent a linear interpolation. More...
class	InterpolateDataLinear
	Represent a piecewise linear interpolation. More...
class	InterpolateDataSpline
	Represent a cubic spline interpolation. More...
class	InterpolateData2DSpline
	Represent a bicubic spline interpolation. More...
class	IsoParticleType
	IsoParticleType is a class to represent isospin multiplets. More...
class	Key
	Object to store a YAML input file key together with metadata associated to it. More...
class	RectangularLattice
	A container class to hold all the arrays on the lattice and access them. More...
class	ListModus
	ListModus: Provides a modus for running SMASH on an external particle list, for example as an afterburner calculation. More...
class	ListBoxModus
	ListBox: Provides a modus for running the SMASH Box with an external particle list,. More...
struct	FormattingHelper
class	ModusDefault
	Base class for Modus classes that provides default function implementations. More...
class	Nucleus
	A nucleus is a collection of particles that are initialized, before the beginning of the simulation and all have the same velocity. More...
class	OscarOutput
struct	ToASCII
	Structure to convert a given value into ASCII format, such that all methods return a std::string. More...
class	ToBinary
	Structure to convert a given value into binary format, such that all methods return a std::vector<char>. More...
class	OutputFormatter
	A general-purpose formatter for output, supporting both ASCII and binary formats. More...
struct	EventInfo
	Structure to contain custom data for output. More...
struct	EventLabel
	Structure to contain information about the event and ensemble numbers. More...
class	OutputInterface
	Abstraction of generic output. More...
struct	RivetOutputParameters
	Helper structure for OutputParameters in order to store and hand over Rivet parameters. More...
struct	OutputParameters
	Helper structure for Experiment to hold output options and parameters. More...
struct	OutputDefaultQuantities
	Struct that holds quantities required by default output standards. More...
struct	pair_hash
	Hash a pair of integers. More...
class	KaonNucleonRatios
	Calculate and store isospin ratios for K N -> K Delta reactions. More...
struct	HistoryData
	A structure to hold information about the history of the particle, e.g. More...
class	ParticleData
	ParticleData contains the dynamic information of a certain particle. More...
struct	PrintParticleListDetailed
class	Particles
	The Particles class abstracts the storage and manipulation of particles. More...
class	ParticleType
	Particle type contains the static properties of a particle species. More...
class	ParticleTypePtr
	A pointer-like interface to global references to ParticleType objects. More...
class	PauliBlocker
	A class that stores parameters needed for Pauli blocking, tabulates necessary integrals and computes phase-space density. More...
class	PdgCode
	PdgCode stores a Particle Data Group Particle Numbering Scheme particle type number. More...
class	Potentials
	A class that stores parameters of potentials, calculates potentials and their gradients. More...
class	ProcessBranch
	ProcessBranch represents one possible final state of an interaction process. More...
class	CollisionBranch
	CollisionBranch is a derivative of ProcessBranch, which is used to represent particular final-state channels in a collision. More...
class	DecayBranch
	DecayBranch is a derivative of ProcessBranch, which is used to represent decay channels. More...
struct	ExpansionProperties
	Struct containing the type of the metric and the expansion parameter of the metric. More...
class	QuantumNumbers
	A container for storing conserved values. More...
class	QuantumSampling
	This class: More...
class	RivetOutput
	SMASH output to Rivet analyses. More...
class	RootOutput
class	RootSolver1D
	A class used for calculating the root of a one-dimensional equation. More...
class	ScatterAction
	ScatterAction is a special action which takes two incoming particles and performs a scattering, producing one or more final-state particles. More...
class	ScatterActionMulti
	ScatterActionMulti is a special action which takes any number of incoming particles and performs a scattering with the use of the stochastic criterion, producing one or more final-state particles. More...
class	ScatterActionPhoton
	ScatterActionPhoton is a special action which takes two incoming particles and performs a perturbative electromagnetic scattering. More...
class	ScatterActionsFinder
	A simple scatter finder: Just loops through all particles and checks each pair for a collision. More...
struct	StringTransitionParameters
	Constants related to transition between low and high collision energies. More...
class	ScatterActionsFinderParameters
	Helper class for ScatterActionsFinder. More...
class	SphereModus
	SphereModus: Provides a modus for expanding matter calculations. More...
class	StringProcess
	String excitation processes used in SMASH. More...
class	Tabulation
	A class for storing a one-dimensional lookup table of floating-point values. More...
class	ThermalizationAction
	ThermalizationAction implements forced thermalization as an Action class. More...
class	ThermodynamicLatticeOutput
	Writes the thermodynamic quantities at lattice points versus time. More...
class	ThermodynamicOutput
	Writes the thermodynamic quantities at a specified point versus time. More...
class	ThreeVector
	The ThreeVector class represents a physical three-vector \( \mathbf{x} = (x_1,x_2,x_3)\) with the components \( x_1,x_2,x_3 \). More...
struct	is_stl_container
	Type trait to infer if a type is an STL container. More...
struct	is_tuple_like
	Type trait to infer if a type is tuple-like (std::pair or std::tuple or std::array or few others). More...
struct	is_tuple_like< T, std::void_t< decltype(std::tuple_size< T >::value)> >
	Trait specialization for the case when the type is tuple-like. More...
struct	is_map_like
	Type trait to infer if a type is map-like (for the moment only std::map is considered). More...
struct	is_map_like< std::map< K, V, Args... > >
	Trait specialization for the case when the type is std::map. More...
struct	is_streamable
	Type trait to infer if a type can be streamed via the << operator. More...
struct	is_streamable< S, T, std::void_t< decltype(std::declval< S & >()<< std::declval< T >())> >
	Trait specialization for the case when the type is streamable. More...
struct	is_writable_to_stream
	Type trait to infer if a type can be written via the << operator, by that not only meaning that an overload exists, but also that possible contained types can be streamed, too. More...
struct	is_writable_to_stream< S, T, std::enable_if_t<!is_stl_container_v< T > &&!is_tuple_like_v< T > > >
	Trait specialization for the case in which the type is not a container and not tuple-like. More...
struct	is_writable_to_stream< S, T, std::enable_if_t< is_stl_container_v< T > &&!is_map_like_v< T > > >
	Trait specialization for the case in which the type is an STL container, but not map-like. More...
struct	is_writable_to_stream< S, T, std::enable_if_t< is_map_like_v< T > > >
	Trait specialization for the case in which the type is map-like. More...
struct	is_writable_to_stream< S, T, std::enable_if_t< is_tuple_like_v< T > > >
	Trait specialization for the case in which the type is tuple-like. More...
struct	has_to_string
	Type trait to infer if there is an std::string to_string(T) overload for a given type T. More...
struct	has_to_string< T, std::void_t< decltype(smash::to_string(std::declval< T >()))> >
	Trait specialization for the case when the overload is present. More...
struct	has_to_string< std::bitset< N >, std::void_t< decltype(smash::to_string(std::declval< std::bitset< N >>()))> >
	Trait specialization for std::bitset types for which a different signature of the overload is required. More...
class	VtkOutput
	Output format processible by ParaView , intended for simple visualization. More...
class	WallcrossingAction
	WallcrossingAction is a special action which indicates that a particle has crossed a box wall. More...
class	WallCrossActionsFinder
	Finder for wall crossing actions, when using peridic boundary conditons. More...
struct	NeighborLookup
	A strust containing the informations needed to search the neighboring cell. More...
struct	FinalStateCrossSection
	Represent a final-state cross section. More...

Typedefs
using	SystemTimePoint = std::chrono::time_point< std::chrono::system_clock >
	Type (alias) that is used to store the current time. More...
using	SystemClock = std::chrono::system_clock
	Type (alias) used to obtain the current time via SystemClock:Now(). More...
using	SystemTimeSpan = SystemClock::duration
	The time duration type (alias) used for measuring run times. More...
template<class T >
using	remove_cvref_t = typename remove_cvref< T >::type
	Helper alias which is always defined next to a type trait. More...
typedef RectangularLattice< DensityOnLattice >	DensityLattice
	Conveniency typedef for lattice of density. More...
typedef RectangularLattice< FieldsOnLattice >	FieldsLattice
	Conveniency typedef for lattice of fields. More...
using	FilePtr = std::unique_ptr< std::FILE, FileDeleter >
	A RAII type to replace std::FILE *. More...
using	Permutation = std::vector< size_t >
	Represent a permutation. More...
using	Version = std::string
	Descriptive alias for storing a SMASH version associated to keys metadata. More...
using	KeyMetadata = std::initializer_list< std::string_view >
	Descriptive alias for storing keys metadata. More...
using	KeyLabels = std::vector< std::string_view >
	Descriptive alias for storing key labels, i.e. More...

Enumerations
enum class	ComputationMethod { Analytic }
	Calculation method for the cross sections. More...
enum class	HadronClass {   Baryon = 0 , Antibaryon = 1 , PositiveSMeson = 2 , NegativeSMeson = 3 ,   PositiveQZeroSMeson = 4 , NegativeQZeroSMeson = 5 , ZeroQZeroSMeson = 6 }
	Specifier to classify the different hadron species according to their quantum numbers. More...
enum class	GridOptions : char { Normal = 0 , PeriodicBoundaries = 1 }
	Identifies the mode of the Grid. More...
enum class	CellSizeStrategy : char { Optimal , Largest }
	Indentifies the strategy of determining the cell size. More...
enum class	CellNumberLimitation : char { None , ParticleNumber }
	Identifies whether the number of cells should be limited. More...
enum class	DefaultType { Null , Value , Dependent }
	New type to explicit distinguish between mandatory and optional keys. More...
enum class	LatticeUpdate { AtOutput = 0 , EveryTimestep = 1 , EveryFixedInterval = 2 }
	Enumerator option for lattice updates. More...
enum	OscarOutputFormat { OscarFormat2013 , OscarFormat2013Extended , OscarFormat1999 , ASCII }
	Selector for the output format of OscarOutput. More...
enum	OscarOutputContents {   OscarInteractions = 0x001 , OscarTimesteps = 0x002 , OscarAtEventstart = 0x004 , OscarParticlesAtEventend = 0x008 ,   OscarParticlesAtEventendIfNotEmpty = 0x010 , OscarParticlesIC = 0x020 }
	Flags for the Contents template parameter of OscarOutput. More...
enum class	BelongsTo : uint8_t { Nothing = 0 , Projectile = 1 , Target = 2 }
enum class	Parity { Pos , Neg }
	Represent the parity of a particle type. More...
enum class	WhichDecaymodes { All , Hadronic , Dileptons }
	Decide which decay mode widths are returned in get partical widths. More...
enum class	ProcessType {   None = 0 , Elastic = 1 , TwoToOne = 2 , TwoToTwo = 3 ,   TwoToThree = 4 , TwoToFour = 15 , TwoToFive = 13 , Decay = 5 ,   Wall = 6 , Thermalization = 7 , Fluidization = 8 , FluidizationNoRemoval = 21 ,   BremsstrahlungPhoton = 9 , BremsstrahlungDilepton = 16 , MultiParticleThreeMesonsToOne = 10 , MultiParticleThreeToTwo = 11 ,   MultiParticleFourToTwo = 14 , MultiParticleFiveToTwo = 12 , StringSoftSingleDiffractiveAX = 41 , StringSoftSingleDiffractiveXB = 42 ,   StringSoftDoubleDiffractive = 43 , StringSoftAnnihilation = 44 , StringSoftNonDiffractive = 45 , StringHardNonDiffractive = 46 ,   StringHardSingleDiffractiveAX = 47 , StringHardSingleDiffractiveXB = 48 , StringHardDoubleDiffractive = 49 , FailedString = 50 ,   Freeforall = 90 }
	ProcessTypes are used to identify the type of the process. More...
enum class	NeedsToWrap { PlusLength , No , MinusLength }
	The options determining what to do if a particle flies out of the grids PlusLength: Used if a periodic boundary condition is applied and a particle passes through the lower bound of the grid. More...

Functions
std::vector< ActionPtr > &	operator+= (std::vector< ActionPtr > &lhs, std::vector< ActionPtr > &&rhs)
	Append vector of action pointers. More...
std::ostream &	operator<< (std::ostream &out, const ActionPtr &action)
	Convenience: dereferences the ActionPtr to Action. More...
std::ostream &	operator<< (std::ostream &out, const ActionList &actions)
	Writes multiple actions to the out stream. More...
template<typename Iterator >
static bool	enforce_periodic_boundaries (Iterator begin, const Iterator &end, typename std::iterator_traits< Iterator >::value_type length)
	Enforces periodic boundaries on the given collection of values. More...
template<typename Container , typename UnaryPredicate >
bool	all_of (Container &&c, UnaryPredicate &&p)
	Convenience wrapper for std::all_of that operates on a complete container. More...
template<typename Container , typename UnaryFunction >
UnaryFunction	for_each (Container &&c, UnaryFunction &&f)
	Convenience wrapper for std::for_each that operates on a complete container. More...
std::ostream &	operator<< (std::ostream &out, const Angles &a)
	Creates output for an Angles object in the form "φ: 0.1294, cos ϑ: 0.423". More...
template<typename T >
std::pair< std::vector< T >, std::vector< T > >	dedup_avg (const std::vector< T > &x, const std::vector< T > &y)
	Remove duplicates from data (x, y) by averaging y. More...
std::unique_ptr< OutputInterface >	create_binary_output (const std::string &format, const std::string &content, const std::filesystem::path &path, const OutputParameters &out_par)
	Create a binary output object. More...
double	isospin_clebsch_gordan_sqr_2to1 (const ParticleType &p_a, const ParticleType &p_b, const ParticleType &Res)
	Calculate the squared isospin Clebsch-Gordan coefficient for two particles p_a and p_b coupling to a resonance Res. More...
double	isospin_clebsch_gordan_sqr_3to1 (const ParticleType &p_a, const ParticleType &p_b, const ParticleType &p_c, const ParticleType &Res)
	Calculate the squared isospin Clebsch-Gordan coefficient for three particles p_a, p_b and p_c coupling to a resonance Res. More...
double	isospin_clebsch_gordan_sqr_2to2 (const ParticleType &p_a, const ParticleType &p_b, const ParticleType &p_c, const ParticleType &p_d, const int I=-1)
	Calculate the squared isospin Clebsch-Gordan coefficient for a 2-to-2 reaction A + B -> C + D. More...
double	cut_off (const double sigma_mb)
	Cross section after cut off. More...
double	y_l_m (int l, int m, double cosx, double phi)
	Spherical harmonics Y_2_0, Y_2_2, Y_3_0 and Y_4_0. More...
std::ostream &	operator<< (std::ostream &os, DensityType dt)
	Create the output operator for the densities. More...
double	density_factor (const ParticleType &type, DensityType dens_type)
	Get the factor that determines how much a particle contributes to the density type that is computed. More...
double	smearing_factor_norm (const double two_sigma_sqr)
	Norm of the Gaussian smearing function. More...
double	smearing_factor_rcut_correction (const double rcut_in_sigma)
	Gaussians used for smearing are cut at radius \(r_{cut} = a \sigma \) for calculation speed-up. More...
std::pair< double, ThreeVector >	unnormalized_smearing_factor (const ThreeVector &r, const FourVector &p, const double m_inv, const DensityParameters &dens_par, const bool compute_gradient=false)
	Implements gaussian smearing for any quantity. More...
std::tuple< double, FourVector, ThreeVector, ThreeVector, FourVector, FourVector, FourVector, FourVector >	current_eckart (const ThreeVector &r, const ParticleList &plist, const DensityParameters &par, DensityType dens_type, bool compute_gradient, bool smearing)
	Calculates Eckart rest frame density and 4-current of a given density type and optionally the gradient of the density in an arbitary frame (grad j0), the curl of the 3-current, and the time, x, y, and z derivatives of the 4-current. More...
std::tuple< double, FourVector, ThreeVector, ThreeVector, FourVector, FourVector, FourVector, FourVector >	current_eckart (const ThreeVector &r, const Particles &plist, const DensityParameters &par, DensityType dens_type, bool compute_gradient, bool smearing)
	convenience overload of the above (ParticleList -> Particles) More...
template<typename T >
void	update_lattice_with_list_of_particles (RectangularLattice< T > *lat, const LatticeUpdate update, const DensityType dens_type, const DensityParameters &par, const ParticleList &plist, const bool compute_gradient, const bool lattice_reset=true)
	Updates the contents on the lattice. More...
template<typename T >
void	update_lattice_accumulating_ensembles (RectangularLattice< T > *lat, const LatticeUpdate update, const DensityType dens_type, const DensityParameters &par, const std::vector< Particles > &ensembles, const bool compute_gradient)
	Updates the contents on the lattice when ensembles are used. More...
void	update_lattice (RectangularLattice< DensityOnLattice > *lat, RectangularLattice< FourVector > *old_jmu, RectangularLattice< FourVector > *new_jmu, RectangularLattice< std::array< FourVector, 4 >> *four_grad_lattice, const LatticeUpdate update, const DensityType dens_type, const DensityParameters &par, const std::vector< Particles > &ensembles, const double time_step, const bool compute_gradient)
	Updates the contents on the lattice of DensityOnLattice type. More...
double	breit_wigner (double m, double pole, double width)
	Returns a relativistic Breit-Wigner distribution. More...
double	breit_wigner_nonrel (double m, double pole, double width)
	Returns a non-relativistic Breit-Wigner distribution, which is essentially a Cauchy distribution with half width. More...
double	cauchy (double x, double pole, double width)
	Returns a Cauchy distribution (sometimes also called Lorentz or non-relativistic Breit-Wigner distribution) with the given parameters. More...
double	density_integrand_mass (const double energy, const double momentum_sqr, const double temperature)
	density_integrand_mass - off_equilibrium distribution for massive particles More...
double	density_integrand_1M_IC (const double energy, const double momentum_sqr, const double temperature)
	density integrand - 1M_IC massless particles for expanding metric initialization, see Bazow:2016oky [10] More...
double	density_integrand_2M_IC (const double energy, const double momentum_sqr, const double temperature)
	density integrand - 2M_IC massless particles for expanding metric initialization, see Bazow:2016oky [10] More...
double	juttner_distribution_func (double momentum_radial, double mass, double temperature, double effective_chemical_potential, double statistics)
	Relativistic Juttner distribution function is just a convenience wrapper for displaying Fermi, Bose, and Boltzmann distributions in one mathematical form. More...
double	sample_momenta_non_eq_mass (const double temperature, const double mass)
	Samples a momentum via rejection method from the non-equilibrium distribution. More...
double	sample_momenta_1M_IC (const double temperature, const double mass)
	Samples a momentum from the non-equilibrium distribution 1M_IC from Bazow:2016oky [10]. More...
double	sample_momenta_2M_IC (const double temperature, const double mass)
	Samples a momentum from the non-equilibrium distribution 2M_IC from Bazow:2016oky [10]. More...
double	sample_momenta_from_thermal (const double temperature, const double mass)
	Samples a momentum from the Maxwell-Boltzmann (thermal) distribution in a faster way, given by Scott Pratt (see Pratt:2014vja [51]) APPENDIX: ALGORITHM FOR GENERATING PARTICLES math trick: for \( x^{n-1}e^{-x} \) distribution, sample x by: \( x = -ln(r_1 r_2 r_3 ... r_n) \) where \( r_i \) are uniform random numbers between [0,1) for \( T/m > 0.6 \): \( p^2 e^{-E/T} = p^2 e^{-p/T} * e^{(p-E)/T} \), where \( e^{(p-E)/T}\) is used as rejection weight. More...
double	sample_momenta_IC_ES (const double temperature)
	Sample momenta according to the momentum distribution in Bazow:2016oky [10]. More...
std::ostream &	operator<< (std::ostream &out, const EnergyMomentumTensor &Tmn)
	Prints out 4x4 tensor to the output stream. More...
EnergyMomentumTensor	operator+ (EnergyMomentumTensor a, const EnergyMomentumTensor &b)
	Direct addition operator. More...
EnergyMomentumTensor	operator- (EnergyMomentumTensor a, const EnergyMomentumTensor &b)
	Direct subtraction operator. More...
EnergyMomentumTensor	operator* (EnergyMomentumTensor a, const double b)
	Direct multiplication operator. More...
EnergyMomentumTensor	operator* (const double a, EnergyMomentumTensor b)
	Direct multiplication operator. More...
EnergyMomentumTensor	operator/ (EnergyMomentumTensor a, const double b)
	Direct division operator. More...
template<typename Modus >
std::ostream &	operator<< (std::ostream &out, const Experiment< Modus > &e)
	Creates a verbose textual description of the setup of the Experiment. More...
ExperimentParameters	create_experiment_parameters (Configuration &config)
	Gathers all general Experiment parameters. More...
const std::string	hline (113, '-')
	String representing a horizontal line. More...
std::string	format_measurements (const std::vector< Particles > &ensembles, uint64_t scatterings_this_interval, const QuantumNumbers &conserved_initial, SystemTimePoint time_start, double time, double E_mean_field, double E_mean_field_initial)
	Generate a string which will be printed to the screen when SMASH is running. More...
double	calculate_mean_field_energy (const Potentials &potentials, RectangularLattice< smash::DensityOnLattice > &jmu_B_lat, RectangularLattice< std::pair< ThreeVector, ThreeVector >> *em_lattice, const ExperimentParameters &parameters)
	Calculate the total mean field energy of the system; this will be printed to the screen when SMASH is running. More...
EventInfo	fill_event_info (const std::vector< Particles > &ensembles, double E_mean_field, double modus_impact_parameter, const ExperimentParameters &parameters, bool projectile_target_interact, bool kinematic_cut_for_SMASH_IC)
	Generate the EventInfo object which is passed to outputs_. More...
void	validate_and_adjust_particle_list (ParticleList &particle_list)
	Validate a particle list adjusting each particle to be a valid SMASH particle. More...
void	check_interactions_total (uint64_t interactions_total)
	Make sure interactions_total can be represented as a 32-bit integer. More...
void	update_fields_lattice (RectangularLattice< FieldsOnLattice > *fields_lat, RectangularLattice< FourVector > *old_fields, RectangularLattice< FourVector > *new_fields, RectangularLattice< std::array< FourVector, 4 >> *fields_four_grad_lattice, DensityLattice *jmu_B_lat, const LatticeUpdate fields_lat_update, const Potentials &potentials, const double time_step)
	Updates the contents on the lattice of FieldsOnLattice type. More...
FilePtr	fopen (const std::filesystem::path &filename, const std::string &mode)
	Open a file with given mode. More...
double	blatt_weisskopf_sqr (const double p_ab, const int L)
double	post_ff_sqr (double m, double M0, double srts0, double L)
	An additional form factor for unstable final states as used in GiBUU, according to M. More...
double	em_form_factor_ps (PdgCode pdg, double mass)
double	em_form_factor_sqr_vec (PdgCode pdg, double mass)
double	form_factor_delta ([[maybe_unused]] double m)
double	pion_em_form_factor_sqr_FF1 (double m_inv_sqr, double m_rho, double gamma_rho)
double	pion_em_form_factor_sqr_FF2 (double m_inv_sqr, double m_rho, double gamma_rho)
FourVector	operator+ (FourVector a, const FourVector &b)
	add two FourVectors More...
FourVector	operator- (FourVector a, const FourVector &b)
	subtract two FourVectors More...
FourVector	operator* (FourVector a, double b)
	multiply a vector with a scalar More...
FourVector	operator* (double b, FourVector a)
	multiply a vector with a scalar More...
FourVector	operator/ (FourVector a, const double &b)
	divide a vector by a scalar More...
std::ostream &	operator<< (std::ostream &os, const FourVector &vec)
	Writes the four components of the vector to the output stream. More...
bool	enable_float_traps (int)
	Fallback that fails to set the trap. More...
void	setup_default_float_traps ()
	Setup the floating-point traps used throughout SMASH. More...
template<typename F >
void	without_float_traps (F &&f)
	Convenience function to create a scope where all floating point traps are disabled. More...
std::ostream &	operator<< (std::ostream &s, const ThermLatticeNode &node)
	This operator writes all the thermodynamic quantities at a certain position to the file out. More...
std::string	build_error_string (std::string message, const Line &line)
	Builds a meaningful error message. More...
build_vector_< Line >	line_parser (const std::string &input)
	Helper function for parsing particles.txt and decaymodes.txt. More...
void	ensure_all_read (std::istream &input, const Line &line)
	Makes sure that nothing is left to read from this line. More...
std::string	read_all (std::istream &&input)
	Utility function to read a complete input stream (e.g. More...
bool	has_crlf_line_ending (const std::string in)
	Check if a line in the string ends with \r\n. More...
template<typename T , typename Cmp >
Permutation	generate_sort_permutation (std::vector< T > const &v, Cmp compare)
	Calculate the permutations necessary for sorting a vector. More...
template<typename T >
std::vector< T >	apply_permutation (const std::vector< T > &v, const Permutation &p)
	Apply a permutation to a vector. More...
template<typename T >
void	check_duplicates (const std::vector< T > &x, const std::string &error_position)
	Check whether two components have the same value in a sorted vector x. More...
template<typename T >
size_t	find_index (const std::vector< T > &v, T x)
	Find the index in v that corresponds to the last value strictly smaller than x. More...
template<int w = 9, int p = w - 3, typename CharT , typename Traits >
std::basic_ostream< CharT, Traits > &	field (std::basic_ostream< CharT, Traits > &s)
	Stream modifier to align the next object to a specific width w. More...
double	center_of_velocity_v (double s, double ma, double mb)
double	fixed_target_projectile_v (double s, double ma, double mb)
template<typename T >
T	pCM_sqr_from_s (const T s, const T mass_a, const T mass_b) noexcept
template<typename T >
T	pCM_from_s (const T s, const T mass_a, const T mass_b) noexcept
template<typename T >
T	pCM (const T sqrts, const T mass_a, const T mass_b) noexcept
template<typename T >
T	pCM_sqr (const T sqrts, const T mass_a, const T mass_b) noexcept
template<typename T >
std::array< T, 2 >	get_t_range (const T sqrts, const T m1, const T m2, const T m3, const T m4)
	Get the range of Mandelstam-t values allowed in a particular 2->2 process, see PDG 2014 booklet, eq. More...
static void	check_energy (double mandelstam_s, double m_sum)
	Helper function for plab_from_s. More...
static void	check_radicand (double mandelstam_s, double radicand)
	Helper function for plab_from_s. More...
double	plab_from_s (double mandelstam_s, double mass)
	Convert Mandelstam-s to p_lab in a fixed-target collision. More...
double	plab_from_s (double mandelstam_s)
	Convert Mandelstam-s to p_lab in a fixed-target collision. More...
double	plab_from_s (double mandelstam_s, double m_projectile, double m_target)
	Convert Mandelstam-s to p_lab in a fixed-target collision. More...
double	plab_from_s_heavier_particle_at_rest (double mandelstam_s, double m1, double m2)
	Convert Mandelstam-s to p_lab in a fixed-target collision. More...
double	s_from_Etot (double e_tot, double m_P, double m_T)
	Convert E_tot to Mandelstam-s for a fixed-target setup, with a projectile of mass m_P and a total energy e_tot and a target of mass m_T at rest. More...
double	s_from_Etot (double e_tot_p, double e_tot_t, double m_p, double m_t)
	Convert E_tot to Mandelstam-s for two beams with total energies and masses (E,m) More...
double	s_from_Ekin (double e_kin, double m_P, double m_T)
	Convert E_kin to Mandelstam-s for a fixed-target setup, with a projectile of mass m_P and a kinetic energy e_kin and a target of mass m_T at rest. More...
double	s_from_Ekin (double e_kin_p, double e_kin_t, double m_p, double m_t)
	Convert E_kin=(E_tot-m) to Mandelstam-s for two beams with total energies and masses (E,m) More...
double	s_from_plab (double plab, double m_P, double m_T)
	Convert p_lab to Mandelstam-s for a fixed-target setup, with a projectile of mass m_P and momentum plab and a target of mass m_T at rest. More...
double	s_from_plab (double plab_p, double plab_t, double m_p, double m_t)
	Convert P_lab to Mandelstam-s for two beams with total momenta and masses (P,m) (P_lab gives per nucleon, P=P_lab*A) More...
Configuration	setup_config_and_logging (const std::string &config_file, const std::string &particles_file={}, const std::string &decaymodes_file={}, const std::vector< std::string > &extra_config={})
	Set up configuration and logging from input files and extra config. More...
void	initialize_particles_decays_and_tabulations (Configuration &configuration, const std::string &version, const std::string &tabulations_dir={})
	Wrapper over a function that initializes the particles and decays from the given configuration, and over another that tabulates the resonance integrals. More...
sha256::Hash	initialize_particles_decays_and_return_hash (Configuration &configuration, const std::string &version)
	Initialize the particles and decays from the given configuration. More...
void	tabulate_resonance_integrals (const sha256::Hash &hash, const std::string &tabulations_dir)
	Tabulate the resonance integrals. More...
void	create_all_loggers (Configuration config)
	Called from main() right after the Configuration object is fully set up to create all logger objects (as defined by LogArea::AreaTuple) with the correct area names and log levels. More...
einhard::LogLevel	default_loglevel ()
void	set_default_loglevel (einhard::LogLevel level)
	Set the default log level (what will be returned from subsequent default_loglevel calls). More...
template<typename T >
FormattingHelper< T >	format (const T &value, const char *unit, int width=-1, int precision=-1)
	Acts as a stream modifier for std::ostream to output an object with an optional suffix string and with a given field width and precision. More...
std::array< einhard::Logger<>, std::tuple_size< LogArea::AreaTuple >::value > &	get_loggers ()
	Return the globally shared logger array. More...
template<typename T >
std::vector< T >	smooth (const std::vector< T > &x, const std::vector< T > &y, T span=2./3, size_t iter=3, T delta=0)
	Apply the LOWESS smoother (see the reference below) to the given data (x, y). More...
bool	has_projectile_or_target (const Configuration &config)
	Find out whether a configuration has a projectile or a target sub-section. More...
bool	is_about_projectile (const Configuration &config)
	Find out whether a configuration is about projectile or target. More...
template<typename To , class From , typename std::enable_if_t< std::is_arithmetic_v< To >, bool > = true>
constexpr To	numeric_cast (From from) noexcept(false)
	Function template to perform a safe numeric conversion between types. More...
template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>
bool	almost_equal (const N x, const N y)
	Checks whether two floating-point numbers are almost equal. More...
template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>
bool	almost_equal_physics (const N x, const N y)
	Like smash::almost_equal, but using a less strict tolerance, smash::small_number. More...
template<typename T = std::initializer_list<double>>
bool	is_any_nan (const T &collection)
	Returns whether any element in a collection is NaN. More...
std::unique_ptr< OutputInterface >	create_oscar_output (const std::string &format, const std::string &content, const std::filesystem::path &path, const OutputParameters &out_par)
template<typename Converter , class Range , std::enable_if_t< std::is_same_v< Range, Particles >||std::is_same_v< Range, ParticleList >, bool > = true>
void	write_in_chunk (const Range &particles, const OutputFormatter< Converter > &formatter, std::function< void(const typename Converter::type &)> write)
	User-facing wrapper for chunked particle writing. More...
bool	parametrization_exists (const PdgCode &pdg_a, const PdgCode &pdg_b)
	Checks if supplied codes have existing parametrizations of total cross sections. More...
double	xs_high_energy (double mandelstam_s, bool is_opposite_charge, double ma, double mb, double P, double R1, double R2)
	total hadronic cross sections at high energies parametrized in the 2016 PDG book (http://pdg.lbl.gov/2016/reviews/rpp2016-rev-cross-section-plots.pdf) More...
double	pp_high_energy (double mandelstam_s)
	pp total cross section at high energies More...
double	ppbar_high_energy (double mandelstam_s)
	ppbar total cross section at high energies More...
double	np_high_energy (double mandelstam_s)
	np total cross section at high energies More...
double	npbar_high_energy (double mandelstam_s)
	npbar total cross section at high energies More...
double	piplusp_high_energy (double mandelstam_s)
	pi+p total cross section at high energies More...
double	piminusp_high_energy (double mandelstam_s)
	pi-p total cross section at high energies More...
double	xs_ppbar_annihilation (double mandelstam_s)
	parametrized cross-section for proton-antiproton annihilation used in the UrQMD model More...
double	xs_string_hard (double mandelstam_s, double xs_0, double e_0, double lambda_pow)
	Utility function called by specific other parametrizations Parametrized hard scattering cross section (with partonic scattering) This parametrization is a direct fit to cross sections in PYTHIA See Sjostrand:1987su [59]. More...
double	NN_string_hard (double mandelstam_s)
	nucleon-nucleon hard scattering cross section (with partonic scattering) More...
double	Npi_string_hard (double mandelstam_s)
	nucleon-pion hard scattering cross section (with partonic scattering) More...
double	pipi_string_hard (double mandelstam_s)
	pion-pion hard scattering cross section (with partonic scattering) More...
double	pipluspiminus_total (double sqrts)
	pi+ pi- total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm. More...
double	pizeropizero_total (double sqrts)
	pi0 pi0 total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm. More...
double	piplusp_total (double sqrts)
	pi+ p total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm. More...
double	piplusp_elastic_AQM (double mandelstam_s, double m1, double m2)
	pi+p elactic cross section parametrization. More...
double	piplusp_elastic (double mandelstam_s)
	pi+p elastic cross section parametrization, PDG data. More...
double	piplusp_sigmapluskplus_pdg (double mandelstam_s)
	pi+ p to Sigma+ K+ cross section parametrization, PDG data. More...
double	piminusp_total (double sqrts)
	pi- p total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm. More...
double	piminusp_elastic (double mandelstam_s)
	pi-p elastic cross section parametrization Source: GiBUU:parametrizationBarMes_HighEnergy.f90 More...
double	piminusp_lambdak0_pdg (double mandelstam_s)
	pi- p -> Lambda K0 cross section parametrization, PDG data. More...
double	piminusp_sigmaminuskplus_pdg (double mandelstam_s)
	pi- p -> Sigma- K+ cross section parametrization, PDG data. More...
double	piminusp_sigma0k0_res (double mandelstam_s)
	pi- p -> Sigma0 K0 cross section parametrization, resonance contribution. More...
double	pp_elastic (double mandelstam_s)
	pp elastic cross section parametrization Source: Weil:2013mya [72], eq. More...
double	pp_elastic_high_energy (double mandelstam_s, double m1, double m2)
	pp elastic cross section parametrization, with only the high energy part generalized to all energy regimes (used for AQM) Source: Weil:2013mya [72], eq. More...
double	pp_total (double mandelstam_s)
	pp total cross section parametrization Sources: low-p: Cugnon:1996kh [21] highest-p: Buss:2011mx [16] More...
double	np_elastic (double mandelstam_s)
	np elastic cross section parametrization Source: Weil:2013mya [72], eq. More...
double	np_total (double mandelstam_s)
	np total cross section parametrization Sources: low-p: Cugnon:1996kh [21] highest-p: Buss:2011mx [16] More...
double	ppbar_elastic (double mandelstam_s)
	ppbar elastic cross section parametrization Source: Bass:1998ca [8] More...
double	ppbar_total (double mandelstam_s)
	ppbar total cross section parametrization Source: Bass:1998ca [8] More...
double	deuteron_pion_elastic (double mandelstam_s)
	Deuteron pion elastic cross-section [mb] parametrized to fit pi-d elastic scattering data (the data collection was be obtained from SAID data base, gwdac.phys.gwu.edu) More...
double	deuteron_nucleon_elastic (double mandelstam_s)
	Deuteron nucleon elastic cross-section [mb] parametrized by Oh:2009gx [46]. More...
double	deuteron_pion_inelastic (double pion_kinetic_energy)
	Parametrization of deuteron-pion inelastic cross section. More...
double	deuteron_nucleon_inelastic (double N_kinetic_energy)
	Parametrization of deuteron-nucleon inelastic cross section. More...
double	deuteron_antinucleon_inelastic (double aN_kinetic_energy)
	Parametrization of deuteron-antinucleon inelastic cross section. More...
double	kplusp_total (double mandelstam_s)
	K+ p total cross section parametrization. More...
double	kplusn_total (double mandelstam_s)
	K+ n total cross section parametrization. More...
double	kminusn_total (double mandelstam_s)
	K- n total cross section parametrization. More...
double	kminusp_total (double mandelstam_s)
	K- p total cross section parametrization. More...
double	kplusp_elastic_background (double mandelstam_s)
	K+ p elastic background cross section parametrization. More...
double	kplusn_elastic_background (double mandelstam_s)
	K+ n elastic background cross section parametrization sigma(K+n->K+n) = sigma(K+n->K0p) = 0.5 * sigma(K+p->K+p) Source: Buss:2011mx [16], B.3.8. More...
double	kplusn_k0p (double mandelstam_s)
	K+ n charge exchange cross section parametrization. More...
double	kminusp_elastic_background (double mandelstam_s)
	K- p elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9. More...
double	kminusn_elastic_background (double mandelstam_s)
	K- n elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9. More...
double	k0p_elastic_background (double mandelstam_s)
	K0 p elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9. More...
double	k0n_elastic_background (double mandelstam_s)
	K0 n elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9. More...
double	kbar0p_elastic_background (double mandelstam_s)
	Kbar0 p elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9. More...
double	kbar0n_elastic_background (double mandelstam_s)
	Kbar0 n elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9. More...
double	kplusp_inelastic_background (double mandelstam_s)
	K+ p inelastic background cross section parametrization Source: Buss:2011mx [16], B.3.8. More...
double	kplusn_inelastic_background (double mandelstam_s)
	K+ n inelastic background cross section parametrization Source: Buss:2011mx [16], B.3.8. More...
double	kminusp_kbar0n (double mandelstam_s)
	K- p <-> Kbar0 n cross section parametrization. More...
double	kminusp_piminussigmaplus (double sqrts)
	K- p <-> pi- Sigma+ cross section parametrization Taken from UrQMD (Graef:2014mra [28]). More...
double	kminusp_piplussigmaminus (double sqrts)
	K- p <-> pi+ Sigma- cross section parametrization Taken from UrQMD (Graef:2014mra [28]). More...
double	kminusp_pi0sigma0 (double sqrts)
	K- p <-> pi0 Sigma0 cross section parametrization Fit to Landolt-Börnstein instead of UrQMD values. More...
double	kminusp_pi0lambda (double sqrts)
	K- p <-> pi0 Lambda cross section parametrization Fit to Landolt-Börnstein instead of UrQMD values. More...
double	kminusn_piminussigma0 (double sqrts)
	K- n <-> pi- Sigma0 cross section parametrization Follow from the parametrization with the same strange product via isospin symmetry. More...
double	kminusn_piminuslambda (double sqrts)
	K- n <-> pi- Lambda cross section parametrization Follow from the parametrization with the same strange product via isospin symmetry. More...
double	lambdalambda_ximinusp (double sqrts_sqrts0, double p_N, double p_lambda)
	Lambda Lambda <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	lambdalambda_xi0n (double sqrts_sqrts0, double p_N, double p_lambda)
	Lambda Lambda <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	lambdasigmaplus_xi0p (double sqrts_sqrts0)
	Lambda Sigma+ <-> Xi0 p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	lambdasigmaminus_ximinusn (double sqrts_sqrts0)
	Lambda Sigma- <-> Xi- n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	lambdasigma0_ximinusp (double sqrts_sqrts0)
	Lambda Sigma0 <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	lambdasigma0_xi0n (double sqrts_sqrts0)
	Lambda Sigma0 <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	sigma0sigma0_ximinusp (double sqrts_sqrts0)
	Sigma0 Sigma0 <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	sigma0sigma0_xi0n (double sqrts_sqrts0)
	Sigma0 Sigma0 <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	sigmaplussigmaminus_xi0p (double sqrts_sqrts0)
	Sigma+ Sigma- <-> Xi0 p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	sigma0sigmaminus_ximinusn (double sqrts_sqrts0)
	Sigma0 Sigma- <-> Xi- n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	sigmaplussigmaminus_ximinusp (double sqrts_sqrts0)
	Sigma+ Sigma- <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
double	sigmaplussigmaminus_xi0n (double sqrts_sqrts0)
	Sigma+ Sigma- <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]). More...
std::optional< double >	Dzeropiplus_elastic (double sqrts)
	D⁰π⁺ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
double	Dzeropiplus_Dpluspizero (double sqrts)
	D⁰π⁺ -> D⁺π⁰ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dzeropiminus_elastic (double sqrts)
	D⁰π⁻ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dzeropizero_elastic (double sqrts)
	D⁰π⁰ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
double	Dzeropizero_Dpluspiminus (double sqrts)
	D⁰π⁰ -> D⁺π⁻ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dpluspiplus_elastic (double sqrts)
	D⁺π⁺ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dpluspiminus_elastic (double sqrts)
	D⁺π⁻ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
double	Dpluspiminus_Dzeropizero (double sqrts)
	D⁺π⁻ -> D⁰π⁰ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dpluspizero_elastic (double sqrts)
	D⁺π⁰ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
double	Dpluspizero_Dzeropiplus (double sqrts)
	D⁺π⁰ -> D⁰π⁺ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dpluseta_elastic (double sqrts)
	D⁺η elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dzeroeta_elastic (double sqrts)
	D⁰η elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DplusKplus_elastic (double sqrts)
	D⁺K⁺ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DplusKzero_elastic (double sqrts)
	D⁺K⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
double	DplusKzero_DzeroKplus (double sqrts)
	D⁺K⁰ -> D⁰K⁺ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
double	DzeroKplus_DplusKzero (double sqrts)
	D⁰K⁺ -> D⁺K⁰ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DzeroKplus_elastic (double sqrts)
	D⁰K⁺ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DzeroKzero_elastic (double sqrts)
	D⁰K⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DplusKbarzero_elastic (double sqrts)
	D⁺K̄⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DplusKminus_elastic (double sqrts)
	D⁺K⁻ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
double	DplusKminus_DzeroKbarzero (double sqrts)
	D⁺K⁻ -> D⁰K̄⁰ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
double	DzeroKbarzero_DplusKminus (double sqrts)
	D⁰K̄⁰ -> D⁺K⁻ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DzeroKbarzero_elastic (double sqrts)
	D⁰K̄⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DzeroKminus_elastic (double sqrts)
	D⁰K⁻ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarpluspiplus_elastic (double sqrts)
	D*(2010)⁺π⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarpluspiminus_elastic (double sqrts)
	D*(2010)⁺π⁻ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	Dstarpluspiminus_Dstarzeropizero (double sqrts)
	D*(2010)⁺π⁻ -> D*(2007)⁰π⁰ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarpluspizero_elastic (double sqrts)
	D*(2010)⁺π⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	Dstarpluspizero_Dstarzeropiplus (double sqrts)
	D*(2010)⁺π⁰ -> D*(2007)⁰π⁺ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	Dstarzeropiplus_Dstarpluspizero (double sqrts)
	D*(2007)⁰π⁺ -> D*(2010)⁺π⁰ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarzeropiplus_elastic (double sqrts)
	D*(2007)⁰π⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarzeropiminus_elastic (double sqrts)
	D*(2007)⁰π- elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	Dstarzeropizero_Dstarpluspiminus (double sqrts)
	D*(2007)⁰π⁰ -> D*(2010)⁺π⁻ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarzeropizero_elastic (double sqrts)
	D*(2007)⁰π⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarpluseta_elastic (double sqrts)
	D*(2010)⁺η elastic cross section (data provided by Juan Torres-Rincon). More...
std::optional< double >	Dstarzeroeta_elastic (double sqrts)
	D*(2007)⁰η elastic cross section (data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarplusKplus_elastic (double sqrts)
	D*(2010)⁺K⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarplusKzero_elastic (double sqrts)
	D*(2010)⁺K⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	DstarplusKzero_DstarzeroKplus (double sqrts)
	D*(2010)⁺K⁰ -> D*(2007)⁰K⁺ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	DstarzeroKplus_DstarplusKzero (double sqrts)
	D*(2007)⁰K⁺ -> D*(2010)⁺K⁰ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarzeroKplus_elastic (double sqrts)
	D*(2007)⁰K⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarzeroKzero_elastic (double sqrts)
	D*(2007)⁰K⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarplusKbarzero_elastic (double sqrts)
	D*(2010)⁺K̄⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarplusKminus_elastic (double sqrts)
	D*(2010)⁺K⁻ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
double	DstarplusKminus_DstarzeroKbarzero (double sqrts)
	D*(2010)⁺K⁻ -> D*(2007)⁰K̄⁰ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
double	DstarzeroKbarzero_DstarplusKminus (double sqrts)
	D*(2007)⁰K̄⁰ -> D*(2010)⁺K⁻ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarzeroKbarzero_elastic (double sqrts)
	D*(2007)⁰K̄⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	DstarzeroKminus_elastic (double sqrts)
	D*(2007)⁰K⁻ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon). More...
std::optional< double >	Dplusn_elastic (double sqrts)
	D⁺n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	Dplusn_Dzerop (double sqrts)
	D⁺n -> D⁰p cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dplusp_elastic (double sqrts)
	D⁺p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dzeron_elastic (double sqrts)
	D⁰n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	Dzerop_Dplusn (double sqrts)
	D⁰p -> D⁺n cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dzerop_elastic (double sqrts)
	D⁰p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dminusn_elastic (double sqrts)
	D⁻n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dminusp_elastic (double sqrts)
	D⁻p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	Dminusp_Dbarzeron (double sqrts)
	D⁻p -> D̄⁰n cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	Dbarzeron_Dminusp (double sqrts)
	D̄⁰n -> D⁻p cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dbarzeron_elastic (double sqrts)
	D̄⁰n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	Dbarzerop_elastic (double sqrts)
	D̄⁰p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DplusDeltaplus_elastic (double sqrts)
	D⁺Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DplusDeltaplus_DzeroDeltaplusplus (double sqrts)
	D⁺Δ⁺ -> D⁰Δ⁺⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DplusDeltaplusplus_elastic (double sqrts)
	D⁺Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DplusDeltaminus_elastic (double sqrts)
	D⁺Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DplusDeltaminus_DzeroDeltazero (double sqrts)
	D⁺Δ⁻ -> D⁰Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DplusDeltazero_elastic (double sqrts)
	D⁺Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DplusDeltazero_DzeroDeltaplus (double sqrts)
	D⁺Δ⁰ -> D⁰Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DzeroDeltaplus_DplusDeltazero (double sqrts)
	D⁰Δ⁺ -> D⁺Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DzeroDeltaplus_elastic (double sqrts)
	D⁰Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DzeroDeltaplusplus_DplusDeltaplus (double sqrts)
	D⁰Δ⁺⁺ -> D⁺Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DzeroDeltaplusplus_elastic (double sqrts)
	D⁰Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DzeroDeltaminus_elastic (double sqrts)
	D⁰Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DzeroDeltazero_DplusDeltaminus (double sqrts)
	D⁰Δ⁰ -> D⁺Δ⁻ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DzeroDeltazero_elastic (double sqrts)
	D⁰Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DminusDeltaplus_elastic (double sqrts)
	D⁻Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DminusDeltaplus_DbarzeroDeltazero (double sqrts)
	D⁻Δ⁺ -> D̄⁰Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DminusDeltaplusplus_elastic (double sqrts)
	D⁻Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DminusDeltaplusplus_DbarzeroDeltaplus (double sqrts)
	D⁻Δ⁺⁺ -> D̄⁰Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DminusDeltaminus_elastic (double sqrts)
	D⁻Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DminusDeltazero_elastic (double sqrts)
	D⁻Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DminusDeltazero_DbarzeroDeltaminus (double sqrts)
	D⁻Δ⁰ -> D̄⁰Δ⁻ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DbarzeroDeltaplus_DminusDeltaplusplus (double sqrts)
	D̄⁰Δ⁺ -> D⁻Δ⁺⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DbarzeroDeltaplus_elastic (double sqrts)
	D̄⁰Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DbarzeroDeltaplusplus_elastic (double sqrts)
	D̄⁰Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DbarzeroDeltaminus_DminusDeltazero (double sqrts)
	D̄⁰Δ⁻ -> D⁻Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DbarzeroDeltaminus_elastic (double sqrts)
	D̄⁰Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
double	DbarzeroDeltazero_DminusDeltaplus (double sqrts)
	D̄⁰Δ⁰ -> D⁻Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::optional< double >	DbarzeroDeltazero_elastic (double sqrts)
	D̄⁰Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon. More...
std::ostream &	operator<< (std::ostream &s, const ParticleData &p)
	Writes the state of the particle to the output stream. More...
std::ostream &	operator<< (std::ostream &out, const ParticleList &particle_list)
	Writes a compact overview over the particles in the particle_list argument to the stream. More...
PrintParticleListDetailed	detailed (const ParticleList &list)
	Request the ParticleList to be printed in full detail (i.e. More...
std::ostream &	operator<< (std::ostream &out, const PrintParticleListDetailed &particle_list)
	Writes a detailed overview over the particles in the particle_list argument to the stream. More...
ParticleData	create_valid_smash_particle_matching_provided_quantities (PdgCode pdgcode, double mass, const FourVector &four_position, const FourVector &four_momentum, int log_area, bool &mass_warning, bool &on_shell_warning)
	This function creates a SMASH particle validating the provided information. More...
bool	are_particles_identical_at_given_time (const ParticleData &p1, const ParticleData &p2, double time)
	Utility function to compare two ParticleData instances with respect to their PDG code, 4-position and 4-momenta. More...
Parity	operator- (Parity p)
Parity	operator* (Parity x, Parity y)
void	operator*= (Parity &x, Parity y)
ParticleTypePtrList	list_possible_resonances (const ParticleTypePtr type_a, const ParticleTypePtr type_b)
	Lists the possible resonances that decay into two particles. More...
std::pair< double, double >	sample_two_resonance_masses (const ParticleType &t1, const ParticleType &t2, const double cms_energy, int L=0)
	Resonance mass sampling for 2-particle final state with two resonances. More...
std::istream &	operator>> (std::istream &is, PdgCode &code)
	Sets the PDG code from the textual representation in the input stream. More...
std::ostream &	operator<< (std::ostream &is, const PdgCode &code)
	Writes the textual representation of the PDG code to the output stream. More...
bool	is_dilepton (const PdgCode pdg1, const PdgCode pdg2)
bool	has_lepton_pair (const PdgCode pdg1, const PdgCode pdg2, const PdgCode pdg3)
constexpr uint64_t	pack (int32_t x, int32_t y)
	Pack two int32_t into an uint64_t. More...
template<class T >
constexpr T	pow_int (const T base, unsigned const exponent)
	Efficient template for calculating integer powers using squaring. More...
bool	is_valid_process_type (int v)
bool	is_string_soft_process (ProcessType p)
	Check if a given process type is a soft string excitation. More...
bool	is_string_hard_process (ProcessType p)
	Check if a given process type is a hard string excitation. More...
bool	is_string_process (ProcessType p)
	Check if a given process type is a string excitation. More...
std::ostream &	operator<< (std::ostream &os, ProcessType process_type)
	Writes the textual representation of the process_type to the output stream os. More...
std::ostream &	operator<< (std::ostream &os, const CollisionBranch &cbranch)
	Writes the textual representation of the Collision Branch cbranch to the output stream os. More...
double	calc_hubble (double time, const ExpansionProperties &metric)
	Calculate the Hubble parameter \(H(t)\), which describes how large the expansion flow is. More...
double	propagate_straight_line (Particles *particles, double to_time, const std::vector< FourVector > &beam_momentum)
	Propagates the positions of all particles on a straight line to a given moment. More...
void	backpropagate_straight_line (Particles *particles, double to_time)
void	expand_space_time (Particles *particles, const ExperimentParameters &parameters, const ExpansionProperties &metric)
	Modifies positions and momentum of all particles to account for space-time deformation. More...
void	update_momenta (std::vector< Particles > &particles, double dt, const Potentials &pot, RectangularLattice< std::pair< ThreeVector, ThreeVector >> *FB_lat, RectangularLattice< std::pair< ThreeVector, ThreeVector >> *FI3_lat, RectangularLattice< std::pair< ThreeVector, ThreeVector >> *EM_lat, DensityLattice *jB_lat)
	Updates the momenta of all particles at the current time step according to the equations of motion: More...
ScatterActionsFinderParameters	create_finder_parameters (Configuration &config, const ExperimentParameters &parameters)
	Gather all relevant parameters for a ScatterActionsFinder either getting them from an ExperimentParameters instance or extracting them from a Configuration . More...
std::pair< std::string, std::string >	load_particles_and_decaymodes (const std::filesystem::path &particles_file, const std::filesystem::path &decaymodes_file)
	Loads particles and decaymodes from provided files particles_file and decaymodes_file. More...
void	initialize_default_particles_and_decaymodes ()
	Loads default smash particle list and decaymodes. More...
std::string	trim (const std::string &s)
	Strip leading and trailing whitespaces. More...
void	remove_substr (std::string &s, const std::string &p)
	Remove all instances of a substring p in a string s. More...
void	isoclean (std::string &s)
	Remove ⁺, ⁻, ⁰ from string. More...
std::vector< std::string >	split (const std::string &s, char delim)
	Split string by delimiter. More...
std::string	join (const std::vector< std::string > &v, std::string_view delim)
	Join strings using delimiter. More...
std::string	join (const std::vector< std::string_view > &v, std::string_view delim)
	Join string views using delimiter. More...
std::string	join (const std::set< std::string > &s, std::string_view delim)
	Join strings using delimiter. More...
std::string	quote (const std::string &s)
	Add quotes around string. More...
std::string	to_string (ThermodynamicQuantity quantity)
	Convert a ThermodynamicQuantity enum value to its corresponding string. More...
std::string	to_string (CalculationFrame frame)
	Convert a CalculationFrame enum value to its corresponding string. More...
std::string	to_string (DileptonBremsPionFormFactor factor)
	Convert a DileptonBremsPionFormFactor enum value to its corresponding string. More...
std::string	to_string (FermiMotion motion)
	Convert a FermiMotion enum value to its corresponding string. More...
std::string	to_string (DensityType type)
	Convert a DensityType enum value to its corresponding string. More...
std::string	to_string (ExpansionMode mode)
	Convert an ExpansionMode enum value to its corresponding string. More...
std::string	to_string (DerivativesMode mode)
	Convert a DerivativesMode enum value to its corresponding string. More...
std::string	to_string (FieldDerivativesMode mode)
	Convert a FieldDerivativesMode enum value to its corresponding string. More...
std::string	to_string (SmearingMode mode)
	Convert a SmearingMode enum value to its corresponding string. More...
std::string	to_string (TimeStepMode mode)
	Convert a TimeStepMode enum value to its corresponding string. More...
std::string	to_string (BoxInitialCondition cond)
	Convert a BoxInitialCondition enum value to its corresponding string. More...
std::string	to_string (SphereInitialCondition cond)
	Convert a SphereInitialCondition enum value to its corresponding string. More...
std::string	to_string (NNbarTreatment t)
	Convert a NNbarTreatment enum value to its corresponding string. More...
std::string	to_string (Sampling s)
	Convert a Sampling enum value to its corresponding string. More...
std::string	to_string (ThermalizationAlgorithm algo)
	Convert a ThermalizationAlgorithm enum value to its corresponding string. More...
std::string	to_string (CollisionCriterion c)
	Convert a CollisionCriterion enum value to its corresponding string. More...
std::string	to_string (CharmRescattering c)
	Convert a CharmRescattering enum value to its corresponding string. More...
std::string	to_string (SpinInteractionType type)
	Convert a SpinInteractionType enum value to its corresponding string. More...
std::string	to_string (HardStringTransitionMode mode)
	Convert a HardStringTransitionMode enum value to its corresponding string. More...
std::string	to_string (TotalCrossSectionStrategy s)
	Convert a TotalCrossSectionStrategy enum value to its corresponding string. More...
std::string	to_string (PseudoResonance p)
	Convert a PseudoResonance enum value to its corresponding string. More...
std::string	to_string (FluidizationType f)
	Convert a FluidizationType enum value to its corresponding string. More...
std::string	to_string (OutputOnlyFinal o)
	Convert an OutputOnlyFinal enum value to its corresponding string. More...
std::string	to_string (einhard::LogLevel level)
	Convert a LogLevel enum value to its corresponding string. More...
std::vector< std::string >	to_string (const ReactionsBitSet &s)
	Convert a ReactionsBitSet to a vector of strings for all set reactions. More...
std::vector< std::string >	to_string (const MultiParticleReactionsBitSet &s)
	Convert a MultiParticleReactionsBitSet to a vector of strings for all set reactions. More...
std::vector< std::string >	to_string (const FluidizableProcessesBitSet &s)
	Convert a FluidizableProcessesBitSet to a vector of strings for all set processes. More...
double	spec_func_integrand_1res (double resonance_mass, double sqrts, double stable_mass, const ParticleType &type)
	Spectral function integrand for GSL integration, with one resonance in the final state (the second particle is stable). More...
double	spec_func_integrand_2res (double sqrts, double res_mass_1, double res_mass_2, const ParticleType &t1, const ParticleType &t2)
	Spectral function integrand for GSL integration, with two resonances in the final state. More...
Tabulation	spectral_integral_semistable (Integrator &integrate, const ParticleType &resonance, const ParticleType &stable, double range)
	Create a table for the spectral integral of a resonance and a stable particle. More...
Tabulation	spectral_integral_unstable (Integrator2d &integrate2d, const ParticleType &res1, const ParticleType &res2, double range)
	Create a table for the spectral integral of two resonances. More...
std::ostream &	operator<< (std::ostream &, const ThreeVector &)
	Writes the three components of the vector to the output stream. More...
ThreeVector	operator+ (ThreeVector a, const ThreeVector &b)
ThreeVector	operator- (ThreeVector a, const ThreeVector &b)
ThreeVector	operator* (ThreeVector a, const double &b)
	multiply a three-vector by constant factor: \( b\cdot\mathbf{a} \). More...
ThreeVector	operator* (const double &a, ThreeVector b)
	multiply a three-vector by constant factor: \( a\cdot\mathbf{b} \). More...
double	operator* (ThreeVector a, const ThreeVector &b)
ThreeVector	operator/ (ThreeVector a, const double &b)
	divide a three-vector by constant factor: \(\mathbf{a}/b\). More...
static auto	get_list_of_binary_quantities (const std::string &content, const std::string &format, const OutputParameters &parameters)
static auto	get_binary_filename (const std::string &content, const std::vector< std::string > &quantities)
std::ostream &	operator<< (std::ostream &out, const BoxModus &m)
static double	isospin_clebsch_gordan_2to1 (const ParticleType &p_a, const ParticleType &p_b, const int I_tot, const int I_z)
	Calculate isospin Clebsch-Gordan coefficient for two particles p_a and p_b coupling to a total isospin. More...
std::ostream &	operator<< (std::ostream &out, const ColliderModus &m)
static double	detailed_balance_factor_stable (double s, const ParticleType &a, const ParticleType &b, const ParticleType &c, const ParticleType &d)
	Helper function: Calculate the detailed balance factor R such that. More...
static double	detailed_balance_factor_RK (double sqrts, double pcm, const ParticleType &a, const ParticleType &b, const ParticleType &c, const ParticleType &d)
	Helper function: Calculate the detailed balance factor R such that. More...
static double	detailed_balance_factor_RR (double sqrts, double pcm, const ParticleType &a, const ParticleType &b, const ParticleType &c, const ParticleType &d)
	Helper function: Calculate the detailed balance factor R such that. More...
static void	append_list (CollisionBranchList &main_list, CollisionBranchList in_list, double weight=1.)
	Helper function: Append a list of processes to another (main) list of processes. More...
static void	throw_xsec_is_not_implemented (const ParticleData &data_a, const ParticleData &data_b, const std::string func_name)
	Helper function: Throw if cross section between two particles is not implemented. More...
static void	throw_xsec_is_negative (const double sqrts, const double xsec, const ParticleData &data_a, const ParticleData &data_b, std::string func_name)
	Helper function: Throw if cross section is negative. More...
static double	effective_AQM_s (const double mandelstam_s, const double m1, const double m2, const double m1_ref, const double m2_ref)
	Helper function: Shift the energy of a collision for AQM rescaled cross sections. More...
static double	AQM_based_on_piminusp_high_energy (const double sqrts, const PdgCode &pdg_a, const PdgCode &pdg_b, const double AQM_scaling_factor_a, const double AQM_scaling_factor_b)
	Helper function: Approximate cross section using AQM based on function piminusp_high_energy. More...
static void	warn_if_charm_rescattering_enabled_and_AQM_disabled (const double sqrts, const ParticleType &type_a, const ParticleType &type_b, const CharmRescattering charm_rescattering)
	Helper function: Print a warning message if Charm_Rescattering_Method is not set to none and AQM is disabled but should be used. More...
static int	min_angular_momentum (int s0, int s1, int s2)
static int	min_angular_momentum (int s0, int s1, int s2, int s3)
static double	integrand_rho_Manley_1res (double sqrts, double mass, double stable_mass, ParticleTypePtr type, int L)
static double	integrand_rho_Manley_2res (double sqrts, double m1, double m2, ParticleTypePtr t1, ParticleTypePtr t2, int L)
static ParticleTypePtrList &	arrange_particles (ParticleTypePtrList &part_types)
	Rearrange the particle list such that the first particle is the stable one. More...
static ParticleTypePtrList	sort_particles (ParticleTypePtrList part_types)
	sort the particle list More...
template<typename T >
std::tuple< double, FourVector, ThreeVector, ThreeVector, FourVector, FourVector, FourVector, FourVector >	current_eckart_impl (const ThreeVector &r, const T &plist, const DensityParameters &par, DensityType dens_type, bool compute_gradient, bool smearing)
	Calculates Eckart rest frame density and 4-current of a given density type and optionally the gradient of the density in an arbitary frame (grad j0), the curl of the 3-current, and the time, x, y, and z derivatives of the 4-current. More...
static IsoParticleType *	try_find_private (const std::string &name)
	Helper function for IsoParticleType::try_find and friends. More...
static std::string	multiplet_name (std::string name)
	Construct the name-string for an isospin multiplet from the given name-string for the particle. More...
static std::filesystem::path	generate_tabulation_path (const std::filesystem::path &dir, const std::string &prefix, const std::string &res_name)
static bool	cache_integral (std::unordered_map< std::string, Tabulation > &tabulations, const std::filesystem::path &dir, sha256::Hash hash, const IsoParticleType &part, const IsoParticleType &res, const IsoParticleType *antires, bool unstable)
static Configuration	create_configuration (const std::string &, const std::vector< std::string > &)
static void	do_minimal_loggers_setup_for_config_validation ()
static void	fully_validate_configuration (const Configuration &)
static void	setup_logging (Configuration &)
static void	read_particles_and_decaymodes_files_setting_keys_in_configuration (const std::string &, const std::string &, Configuration &)
static bool	is_list_of_particles_invalid (const Particles &, int)
std::ostream &	operator<< (std::ostream &out, const ListModus &m)
template<int index, int stop = 0>
constexpr std::enable_if<(index==stop), int >::type	find_longest_logger_name ()
template<int index, int stop = 0, int mid = (index + stop) / 2>
constexpr std::enable_if<(index > stop), int >::type	find_longest_logger_name ()
template<std::size_t index, int >
std::enable_if<(index==0)>::type	create_all_loggers_impl (Configuration &)
template<std::size_t index, int longest_name = find_longest_logger_name<index - 1>()>
std::enable_if<(index !=0)>::type	create_all_loggers_impl (Configuration &config)
std::ostream &	operator<< (std::ostream &out, const Nucleus &n)
static double	piplusp_elastic_pdg (double mandelstam_s)
static double	piminusp_elastic_pdg (double mandelstam_s)
static double	kminusp_elastic_pdg (double mandelstam_s)
static void	initialize (std::unordered_map< std::pair< uint64_t, uint64_t >, double, pair_hash > &ratios)
	Calculate and store isospin ratios for K N -> K Delta reactions. More...
std::ostream &	operator<< (std::ostream &out, const Particles &particles)
static std::string	antiname (const std::string &name, PdgCode code)
	Construct an antiparticle name-string from the given name-string for the particle and its PDG code. More...
static std::string	chargestr (int charge)
	Construct a charge string, given the charge as integer. More...
std::ostream &	operator<< (std::ostream &out, const ParticleType &type)
static double	high_energy_bpp (double plab)
	Computes the B coefficients from the STAR fit, see fig. More...
static double	Cugnon_bpp (double plab)
	Computes the B coefficients from the Cugnon parametrization of the angular distribution in elastic pp scattering. More...
static double	Cugnon_bnp (double plab)
	Computes the B coefficients from the Cugnon parametrization of the angular distribution in elastic np scattering. More...
static void	boost_spin_vectors_after_elastic_scattering (ParticleData &outgoing_particle_a, ParticleData &outgoing_particle_b)
static StringTransitionParameters	create_string_transition_parameters (Configuration &config)
static void	deduplicate (std::vector< FinalStateCrossSection > &final_state_xs)
	Deduplicate the final-state cross sections by summing. More...
std::ostream &	operator<< (std::ostream &out, const SphereModus &m)
template<typename Out >
void	split (const std::string &s, char delim, Out result)
	Split string by delimiter. More...
template<typename Container >
static std::string	join_impl (const Container &container, std::string_view delim)
static void	throw_unhandled_enum (std::string_view enum_name, int value)
static void	swrite (std::ofstream &stream, double x)
	Write binary representation to stream. More...
static double	sread_double (std::ifstream &stream)
	Read binary representation of a double. More...
static void	swrite (std::ofstream &stream, size_t x)
	Write binary representation to stream. More...
static size_t	sread_size (std::ifstream &stream)
	Read binary representation of a size_t. More...
static void	swrite (std::ofstream &stream, const std::vector< double > x)
	Write binary representation to stream. More...
static std::vector< double >	sread_vector (std::ifstream &stream)
	Read binary representation of a vector of doubles. More...
static void	swrite (std::ofstream &stream, sha256::Hash x)
	Write binary representation to stream. More...
static sha256::Hash	sread_hash (std::ifstream &stream)
	Read binary representation of a SHA256 hash. More...
std::ostream &	operator<< (std::ostream &out, const TimeStampCounter &tsc)

Variables
static constexpr int	LAction = LogArea::Action::id
static constexpr int	LClock = LogArea::Clock::id
template<typename T >
constexpr T	smash_NaN = std::numeric_limits<T>::quiet_NaN()
	Centralized alias for a quiet NaN. More...
constexpr double	hbarc = 0.197327053
	GeV <-> fm conversion factor. More...
constexpr double	fm2_mb = 0.1
	mb <-> fm^2 conversion factor. More...
constexpr double	gev2_mb = hbarc * hbarc / fm2_mb
	GeV^-2 <-> mb conversion factor. More...
constexpr double	mev_to_gev = 1.e-3
	MeV to GeV conversion factor. More...
constexpr double	really_small = 1.0e-6
	Numerical error tolerance. More...
constexpr double	very_small_double = 1.0e-15
	A very small double, used to avoid division by zero. More...
constexpr double	twopi = 2. * M_PI
	\( 2\pi \). More...
constexpr double	nuclear_density = 0.168
	Ground state density of symmetric nuclear matter [fm^-3]. More...
constexpr double	small_number = 1.0e-4
	Physical error tolerance. More...
constexpr double	electron_mass = 0.000511
	Electron mass in GeV. More...
constexpr double	nucleon_mass = 0.938
	Nucleon mass in GeV. More...
constexpr double	pion_mass = 0.138
	Pion mass in GeV. More...
constexpr double	kaon_mass = 0.494
	Kaon mass in GeV. More...
constexpr double	omega_mass = 0.783
	omega mass in GeV. More...
constexpr double	delta_mass = 1.232
	Delta mass in GeV. More...
constexpr double	deuteron_mass = 1.8756
	Deuteron mass in GeV. More...
constexpr double	fine_structure = 7.2973525698e-3
	Fine-struture constant, approximately 1/137. More...
const double	elementary_charge = std::sqrt(fine_structure * 4 * M_PI)
	Elementary electric charge in natural units, approximately 0.3. More...
constexpr int	maximum_rndm_seed_in_pythia = 900000000
	The maximum value of the random seed used in PYTHIA. More...
constexpr double	minimum_sqrts_pythia_can_handle = 10.0
	Energy in GeV, below which hard reactions via pythia are impossible. More...
constexpr std::uint32_t	ID_PROCESS_PHOTON
	Process ID for any photon process. More...
const std::initializer_list< double >	BREMS_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	BREMS_K
	photon momentum More...
const std::initializer_list< double >	BREMS_THETA
	theta angle with respect to collision axis of incoming pions More...
const std::initializer_list< double >	BREMS_PIPI_PIPI_OPP_SIG
	Total π+- + π-+ -> π+- + π-+ + γ cross section. More...
const std::initializer_list< double >	BREMS_PIPI_PIPI_OPP_DIFF_SIG_K
	dSigma/dk for π+- + π-+ -> π+- + π-+ + γ More...
const std::initializer_list< double >	BREMS_PIPI_PIPI_OPP_DIFF_SIG_THETA
	dSigma/dtheta for π+- + π-+ -> π+- + π-+ + γ More...
const std::initializer_list< double >	BREMS_PIPI_PIPI_SAME_SIG
	Total π+ + π+ -> π+ + π+ + γ or π- + π- -> π- + π- + γ cross section. More...
const std::initializer_list< double >	BREMS_PIPI_PIPI_SAME_DIFF_SIG_K
	dSigma/dk for π+ + π+ -> π+ + π+ + γ or π- + π- -> π- + π- + γ More...
const std::initializer_list< double >	BREMS_PIPI_PIPI_SAME_DIFF_SIG_THETA
	dSigma/dtheta for π+ + π+ -> π+ + π+ + γ or π- + π- -> π- + π- + γ More...
const std::initializer_list< double >	BREMS_PIPI0_PIPI0_SIG
	Total π0 + π -> π0 + π + γ cross section. More...
const std::initializer_list< double >	BREMS_PIPI0_PIPI0_DIFF_SIG_K
	dSigma/dk for π0 + π -> π0 + π + γ More...
const std::initializer_list< double >	BREMS_PIPI0_PIPI0_DIFF_SIG_THETA
	dSigma/dtheta for π0 + π -> π0 + π + γ More...
const std::initializer_list< double >	BREMS_PIPI_PI0PI0_SIG
	Total π+- + π-+ -> π0 + π0 + γ cross section. More...
const std::initializer_list< double >	BREMS_PIPI_PI0PI0_DIFF_SIG_K
	dSigma/dk for π+- + π-+ -> π0 + π0 + γ More...
const std::initializer_list< double >	BREMS_PIPI_PI0PI0_DIFF_SIG_THETA
	dSigma/dtheta for π+- + π-+ -> π0 + π0 + γ More...
const std::initializer_list< double >	BREMS_PI0PI0_PIPI_SIG
	Total π0 + π0 -> π+- + π-+ + γ cross section. More...
const std::initializer_list< double >	BREMS_PI0PI0_PIPI_DIFF_SIG_K
	dSigma/dk for π0 + π0 -> π+- + π-+ + γ More...
const std::initializer_list< double >	BREMS_PI0PI0_PIPI_DIFF_SIG_THETA
	dSigma/dtheta for π0 + π0 -> π+- + π-+ + γ More...
static constexpr int	LDensity = LogArea::Density::id
static constexpr int	LMain = LogArea::Main::id
static constexpr int	LInitialConditions = LogArea::InitialConditions::id
static constexpr int	LLattice = LogArea::Lattice::id
std::array< einhard::Logger<>, std::tuple_size< LogArea::AreaTuple >::value > &	logg = get_loggers()
	An array that stores all pre-configured Logger objects. More...
static constexpr int	LOutput = LogArea::Output::id
static constexpr int	LExperiment = LogArea::Experiment::id
KaonNucleonRatios	kaon_nucleon_ratios
const std::initializer_list< double >	KMINUSN_TOT_PLAB
	PDG data on K- n total cross section: momentum in lab frame. More...
const std::initializer_list< double >	KMINUSN_TOT_SIG
	PDG data on K- n total cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	kminusn_total_interpolation = nullptr
	An interpolation that gets lazily filled using the KMINUSN_TOT data. More...
const std::initializer_list< double >	KMINUSP_ELASTIC_P_LAB
	PDG data on K- p elastic cross section: momentum in lab frame. More...
const std::initializer_list< double >	KMINUSP_ELASTIC_SIG
	PDG data on K- p elastic cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	kminusp_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the KMINUSP_ELASTIC data. More...
const std::initializer_list< double >	KMINUSP_TOT_PLAB
	PDG smoothed data on K- p total cross section: momentum in lab frame. More...
const std::initializer_list< double >	KMINUSP_TOT_SIG
	PDG smoothed data on K- p total cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	kminusp_total_interpolation = nullptr
	An interpolation that gets lazily filled using the KMINUSP_TOT data. More...
const std::initializer_list< double >	KMINUSP_RES_SQRTS
	Center-of-mass energy list for K̅⁻ N⁺ More...
const std::initializer_list< double >	KMINUSP_RES_SIG
	Elastic K̅⁻ N⁺ cross section contributions from decays. More...
static std::unique_ptr< InterpolateDataSpline >	kminusp_elastic_res_interpolation = nullptr
	An interpolation that gets lazily filled using the KMINUSP_RES data. More...
const std::initializer_list< double >	KPLUSN_TOT_PLAB
	PDG data on K+ n total cross section: momentum in lab frame. More...
const std::initializer_list< double >	KPLUSN_TOT_SIG
	PDG data on K+ n total cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	kplusn_total_interpolation = nullptr
	An interpolation that gets lazily filled using the KPLUSN_TOT data. More...
const std::initializer_list< double >	KPLUSP_TOT_PLAB
	PDG data on K+ p total cross section: momentum in lab frame. More...
const std::initializer_list< double >	KPLUSP_TOT_SIG
	PDG data on K+ p total cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	kplusp_total_interpolation = nullptr
	An interpolation that gets lazily filled using the KPLUSP_TOT data. More...
const std::initializer_list< double >	PIMINUSP_ELASTIC_P_LAB
	PDG data on pi- p elastic cross section: momentum in lab frame. More...
const std::initializer_list< double >	PIMINUSP_ELASTIC_SIG
	PDG data on pi- p elastic cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piminusp_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the PIMINUSP_ELASTIC data. More...
const std::initializer_list< double >	PIMINUSP_LAMBDAK0_P_LAB
	PDG data on pi- p to Lambda K0 cross section: momentum in lab frame. More...
const std::initializer_list< double >	PIMINUSP_LAMBDAK0_SIG
	PDG data on pi- p to Lambda K0 cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piminusp_lambdak0_interpolation = nullptr
	An interpolation that gets lazily filled using the PIMINUSP_LAMBDAK0 data. More...
const std::initializer_list< double >	PIMINUSP_SIGMAMINUSKPLUS_P_LAB
	PDG data on pi- p to Sigma- K+ cross section: momentum in lab frame. More...
const std::initializer_list< double >	PIMINUSP_SIGMAMINUSKPLUS_SIG
	PDG data on pi- p to Sigma- K+ cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piminusp_sigmaminuskplus_interpolation = nullptr
	An interpolation that gets lazily filled using the PIMINUSP_SIGMAMINUSKPLUS data. More...
const std::initializer_list< double >	PIMINUSP_SIGMA0K0_RES_SQRTS
	pi- p to Sigma0 K0 cross section: square root s More...
const std::initializer_list< double >	PIMINUSP_SIGMA0K0_RES_SIG
	pi- p to Sigma0 K0 cross section: cross section More...
static std::unique_ptr< InterpolateDataLinear< double > >	piminusp_sigma0k0_interpolation = nullptr
	An interpolation that gets lazily filled using the PIMINUSP_SIGMA0K0_RES data. More...
const std::initializer_list< double >	PIMINUSP_RES_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	PIMINUSP_RES_SIG
	Elastic π⁻N⁺ cross section contributions from decays. More...
static std::unique_ptr< InterpolateDataSpline >	piminusp_elastic_res_interpolation = nullptr
	An interpolation that gets lazily filled using the PIMINUSP_RES data. More...
const std::initializer_list< double >	PIPLUSP_ELASTIC_P_LAB
	PDG data on pi+ p elastic cross section: momentum in lab frame. More...
const std::initializer_list< double >	PIPLUSP_ELASTIC_SIG
	PDG data on pi+ p elastic cross section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piplusp_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the PIPLUSP_ELASTIC_SIG data. More...
const std::initializer_list< double >	PIPLUSP_SIGMAPLUSKPLUS_P_LAB
	PDG data on pi+ p to Sigma+ K+ cross section: momentum in lab frame. More...
const std::initializer_list< double >	PIPLUSP_SIGMAPLUSKPLUS_SIG
	PDG data on pi+ p to Sigma+ K+ section: cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piplusp_sigmapluskplus_interpolation = nullptr
	An interpolation that gets lazily filled using the PIPLUSP_SIGMAPLUSKPLUS_SIG data. More...
const std::initializer_list< double >	PIPLUSP_RES_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	PIPLUSP_RES_SIG
	Elastic π⁺N⁺ cross section contributions from decays. More...
static std::unique_ptr< InterpolateDataSpline >	piplusp_elastic_res_interpolation = nullptr
	A null interpolation that gets filled using the PIPLUSP_RES data. More...
const std::initializer_list< double >	PIPLUSP_TOT_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	PIPLUSP_TOT_SIG
	Total p π⁺ cross section parametrized from bottom-up SMASH-3.0, using the hadronic list from PDG2018. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piplusp_total_interpolation = nullptr
	An interpolation that gets lazily filled using the PIPLUSP_TOT data. More...
const std::initializer_list< double >	PIMINUSP_TOT_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	PIMINUSP_TOT_SIG
	Total p π⁻ cross section parametrized from bottom-up SMASH-3.0, using the hadronic list from PDG2018. More...
static std::unique_ptr< InterpolateDataLinear< double > >	piminusp_total_interpolation = nullptr
	An interpolation that gets lazily filled using the PIMINUSP_TOT data. More...
const std::initializer_list< double >	PIPLUSPIMINUS_TOT_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	PIPLUSPIMINUS_TOT_SIG
	Total π⁺ π⁻ cross section parametrized from bottom-up SMASH-3.0, using the hadronic list from PDG2018. More...
static std::unique_ptr< InterpolateDataLinear< double > >	pipluspiminus_total_interpolation = nullptr
	An interpolation that gets lazily filled using the PIPLUSPIMINUS_TOT data. More...
const std::initializer_list< double >	PIZEROPIZERO_TOT_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	PIZEROPIZERO_TOT_SIG
	Total π⁰ π⁰ cross section parametrized from bottom-up SMASH-3.0 using the hadronic list from PDG2018. More...
static std::unique_ptr< InterpolateDataLinear< double > >	pizeropizero_total_interpolation = nullptr
	An interpolation that gets lazily filled using the PIZEROPIZERO_TOT data. More...
const std::initializer_list< double >	DPI_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DPLUSPIPLUS_ELASTIC_SIG
	Elastic D⁺π⁺ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dpluspiplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSPIPLUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSPIMINUS_ELASTIC_SIG
	Elastic D⁺π⁻ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dpluspiminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSPIMINUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSPIMINUS_DZEROPIZERO_SIG
	D⁺π⁻ -> D⁰π⁰ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dpluspiminus_Dzeropizero_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSPIMINUS_DZEROPIZERO data. More...
const std::initializer_list< double >	DPLUSPIZERO_ELASTIC_SIG
	Elastic D⁺π⁰ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dpluspizero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSPIZERO_ELASTIC data. More...
const std::initializer_list< double >	DPLUSPIZERO_DZEROPIPLUS_SIG
	D⁺π⁰ -> D⁰π⁺ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dpluspizero_Dzeropiplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSPIZERO_DZEROPIPLUS data. More...
const std::initializer_list< double >	DZEROPIPLUS_DPLUSPIZERO_SIG
	D⁰π⁺ -> D⁺π⁰ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeropiplus_Dpluspizero_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROPIPLUS_DPLUSPIZERO data. More...
const std::initializer_list< double >	DZEROPIPLUS_ELASTIC_SIG
	Elastic D⁰π⁺ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeropiplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROPIPLUS_ELASTIC data. More...
const std::initializer_list< double >	DZEROPIMINUS_ELASTIC_SIG
	Elastic D⁰π⁻ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeropiminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROPIMINUS_ELASTIC data. More...
const std::initializer_list< double >	DZEROPIZERO_DPLUSPIMINUS_SIG
	D⁰π⁰ -> D⁺π⁻ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeropizero_Dpluspiminus_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROPIZERO_DPLUSPIMINUS data. More...
const std::initializer_list< double >	DZEROPIZERO_ELASTIC_SIG
	Elastic D⁰π⁰ cross section Abreu:2011ic [1]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeropizero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROPIZERO_ELASTIC data. More...
const std::initializer_list< double >	DETA_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DPLUSETA_ELASTIC_SIG
	Elastic D⁺η cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dpluseta_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSETA_ELASTIC data. More...
const std::initializer_list< double >	DZEROETA_ELASTIC_SIG
	Elastic D⁰η cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeroeta_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROETA_ELASTIC data. More...
const std::initializer_list< double >	DKAON_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DPLUSKPLUS_ELASTIC_SIG
	Elastic D⁺K⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusKplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSKPLUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSKMINUS_ELASTIC_SIG
	Elastic D⁺K⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusKminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSKMINUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSKMINUS_DZEROKBARZERO_SIG
	D⁺K⁻ -> D⁰K̄⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusKminus_DzeroKbarzero_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSKMINUS_DZEROKBARZERO data. More...
const std::initializer_list< double >	DPLUSKZERO_ELASTIC_SIG
	Elastic D⁺K⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusKzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSKZERO_ELASTIC data. More...
const std::initializer_list< double >	DPLUSKZERO_DZEROKPLUS_SIG
	D⁺K⁰ -> D⁰K⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusKzero_DzeroKplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSKZERO_DZEROKPLUS data. More...
const std::initializer_list< double >	DPLUSKBARZERO_ELASTIC_SIG
	Elastic D⁺K̄⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusKbarzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSKBARZERO_ELASTIC data. More...
const std::initializer_list< double >	DZEROKPLUS_DPLUSKZERO_SIG
	D⁰K⁺ -> D⁺K⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroKplus_DplusKzero_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROKPLUS_DPLUSKZERO data. More...
const std::initializer_list< double >	DZEROKPLUS_ELASTIC_SIG
	Elastic D⁰K⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroKplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROKPLUS_ELASTIC data. More...
const std::initializer_list< double >	DZEROKMINUS_ELASTIC_SIG
	Elastic D⁰K⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroKminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROKMINUS_ELASTIC data. More...
const std::initializer_list< double >	DZEROKZERO_ELASTIC_SIG
	Elastic D⁰K⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroKzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROKZERO_ELASTIC data. More...
const std::initializer_list< double >	DZEROKBARZERO_DPLUSKMINUS_SIG
	D⁰K̄⁰ -> D⁺K⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroKbarzero_DplusKminus_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROKBARZERO_DPLUSKMINUS data. More...
const std::initializer_list< double >	DZEROKBARZERO_ELASTIC_SIG
	Elastic D⁰K̄⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroKbarzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROKBARZERO_ELASTIC data. More...
const std::initializer_list< double >	DSTARPI_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DSTARPLUSPIPLUS_ELASTIC_SIG
	Elastic D*(2010)⁺π⁺ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarpluspiplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSPIPLUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARPLUSPIMINUS_ELASTIC_SIG
	Elastic D*(2010)⁺π⁻ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarpluspiminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSPIMINUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARPLUSPIMINUS_DSTARZEROPIZERO_SIG
	D*(2010)⁺π⁻ -> D*(2007)⁰π⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarpluspiminus_Dstarzeropizero_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSPIMINUS_DSTARZEROPIZERO data. More...
const std::initializer_list< double >	DSTARPLUSPIZERO_ELASTIC_SIG
	Elastic D*(2010)⁺π⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarpluspizero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSPIZERO_ELASTIC data. More...
const std::initializer_list< double >	DSTARPLUSPIZERO_DSTARZEROPIPLUS_SIG
	D*(2010)⁺π⁰ -> D*(2007)⁰π⁺ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarpluspizero_Dstarzeropiplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSPIZERO_DSTARZEROPIPLUS data. More...
const std::initializer_list< double >	DSTARZEROPIPLUS_DSTARPLUSPIZERO_SIG
	D*(2007)⁰π⁺ -> D*(2010)⁺π⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarzeropiplus_Dstarpluspizero_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROPIPLUS_DSTARPLUSPIZERO data. More...
const std::initializer_list< double >	DSTARZEROPIPLUS_ELASTIC_SIG
	Elastic D*(2007)⁰π⁺ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarzeropiplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROPIPLUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROPIMINUS_ELASTIC_SIG
	Elastic D*(2007)⁰π⁻ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarzeropiminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROPIMINUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROPIZERO_DSTARPLUSPIMINUS_SIG
	D*(2007)⁰π⁰ -> D*(2010)⁺π⁻ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarzeropizero_Dstarpluspiminus_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROPIZERO_DSTARPLUSPIMINUS data. More...
const std::initializer_list< double >	DSTARZEROPIZERO_ELASTIC_SIG
	Elastic D*(2007)⁰π⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarzeropizero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROPIZERO_ELASTIC data. More...
const std::initializer_list< double >	DSTARETA_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DSTARPLUSETA_ELASTIC_SIG
	Elastic D*(2010)⁺η cross section. Data provided by Juan Torres-Rincon. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarpluseta_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSETA_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROETA_ELASTIC_SIG
	Elastic D*(2007)⁰η cross section. Data provided by Juan Torres-Rincon. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dstarzeroeta_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROETA_ELASTIC data. More...
const std::initializer_list< double >	DSTARKAON_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DSTARPLUSKPLUS_ELASTIC_SIG
	Elastic D*(2010)⁺K⁺ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarplusKplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSKPLUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARPLUSKMINUS_ELASTIC_SIG
	Elastic D*(2010)⁺K⁻ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarplusKminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSKMINUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARPLUSKMINUS_DSTARZEROKBARZERO_SIG
	D*(2010)⁺K⁻ -> D*(2007)⁰K̄⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarplusKminus_DstarzeroKbarzero_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSKMINUS_DSTARZEROKBARZERO data. More...
const std::initializer_list< double >	DSTARPLUSKZERO_ELASTIC_SIG
	Elastic D*(2010)⁺K⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarplusKzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSKZERO_ELASTIC data. More...
const std::initializer_list< double >	DSTARPLUSKZERO_DSTARZEROKPLUS_SIG
	D*(2010)⁺K⁰ -> D*(2007)⁰K⁺ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarplusKzero_DstarzeroKplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSKZERO_DSTARZEROKPLUS data. More...
const std::initializer_list< double >	DSTARPLUSKBARZERO_ELASTIC_SIG
	Elastic D*(2010)⁺K̄⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarplusKbarzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARPLUSKBARZERO_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROKPLUS_DSTARPLUSKZERO_SIG
	D*(2007)⁰K⁺ -> D*(2010)⁺K⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarzeroKplus_DstarplusKzero_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROKPLUS_DSTARPLUSKZERO data. More...
const std::initializer_list< double >	DSTARZEROKPLUS_ELASTIC_SIG
	Elastic D*(2007)⁰K⁺ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarzeroKplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROKPLUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROKMINUS_ELASTIC_SIG
	Elastic D*(2007)⁰K⁻ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarzeroKminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROKMINUS_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROKZERO_ELASTIC_SIG
	Elastic D*(2007)⁰K⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarzeroKzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROKZERO_ELASTIC data. More...
const std::initializer_list< double >	DSTARZEROKBARZERO_DSTARPLUSKMINUS_SIG
	D*(2007)⁰K̄⁰ -> D*(2010)⁺K⁻ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarzeroKbarzero_DstarplusKminus_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROKBARZERO_DSTARPLUSKMINUS data. More...
const std::initializer_list< double >	DSTARZEROKBARZERO_ELASTIC_SIG
	Elastic D*(2007)⁰K̄⁰ cross section. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DstarzeroKbarzero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DSTARZEROKBARZERO_ELASTIC data. More...
const std::initializer_list< double >	DN_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DPLUSN_ELASTIC_SIG
	Elastic D⁺n cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dplusn_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSN_ELASTIC data. More...
const std::initializer_list< double >	DPLUSN_DZEROP_SIG
	D⁺n -> D⁰p cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dplusn_Dzerop_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSN_DZEROP data. More...
const std::initializer_list< double >	DPLUSP_ELASTIC_SIG
	Elastic D⁺p cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dplusp_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSP_ELASTIC data. More...
const std::initializer_list< double >	DZERON_ELASTIC_SIG
	Elastic D⁰n cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzeron_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERON_ELASTIC data. More...
const std::initializer_list< double >	DZEROP_DPLUSN_SIG
	D⁰p -> D⁺n cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzerop_Dplusn_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROP_DPLUSN data. More...
const std::initializer_list< double >	DZEROP_ELASTIC_SIG
	Elastic D⁰p cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dzerop_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZEROP_ELASTIC data. More...
const std::initializer_list< double >	DBARN_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DMINUSN_ELASTIC_SIG
	Elastic D⁻n cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dminusn_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSN_ELASTIC data. More...
const std::initializer_list< double >	DMINUSP_ELASTIC_SIG
	Elastic D⁻p cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dminusp_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSP_ELASTIC data. More...
const std::initializer_list< double >	DMINUSP_DBARZERON_SIG
	D⁻p -> D̄⁰n cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dminusp_Dbarzeron_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSP_DBARZERON data. More...
const std::initializer_list< double >	DBARZERON_DMINUSP_SIG
	D̄⁰n -> D⁻p cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dbarzeron_Dminusp_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERON_DMINUSP data. More...
const std::initializer_list< double >	DBARZERON_ELASTIC_SIG
	Elastic D̄⁰n cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dbarzeron_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERON_ELASTIC data. More...
const std::initializer_list< double >	DBARZEROP_ELASTIC_SIG
	Elastic D̄⁰p cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	Dbarzerop_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZEROP_ELASTIC data. More...
const std::initializer_list< double >	DDELTA_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DPLUSDELTAPLUS_ELASTIC_SIG
	Elastic D⁺Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltaplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAPLUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSDELTAPLUS_DZERODELTAPLUSPLUS_SIG
	D⁺Δ⁺ -> D⁰Δ⁺⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltaplus_DzeroDeltaplusplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAPLUS_DZERODELTAPLUSPLUS data. More...
const std::initializer_list< double >	DPLUSDELTAPLUSPLUS_ELASTIC_SIG
	Elastic D⁺Δ⁺⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltaplusplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAPLUSPLUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSDELTAMINUS_ELASTIC_SIG
	Elastic D⁺Δ⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltaminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAMINUS_ELASTIC data. More...
const std::initializer_list< double >	DPLUSDELTAMINUS_DZERODELTAZERO_SIG
	D⁺Δ⁻ -> D⁰Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltaminus_DzeroDeltazero_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAMINUS_DZERODELTAZERO data. More...
const std::initializer_list< double >	DPLUSDELTAZERO_ELASTIC_SIG
	Elastic D⁺Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltazero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAZERO_ELASTIC data. More...
const std::initializer_list< double >	DPLUSDELTAZERO_DZERODELTAPLUS_SIG
	D⁺Δ⁰ -> D⁰Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DplusDeltazero_DzeroDeltaplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DPLUSDELTAZERO_DZERODELTAPLUS data. More...
const std::initializer_list< double >	DZERODELTAPLUS_DPLUSDELTAZERO_SIG
	D⁰Δ⁺ -> D⁺Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltaplus_DplusDeltazero_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAPLUS_DPLUSDELTAZERO data. More...
const std::initializer_list< double >	DZERODELTAPLUS_ELASTIC_SIG
	Elastic D⁰Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltaplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAPLUS_ELASTIC data. More...
const std::initializer_list< double >	DZERODELTAPLUSPLUS_DPLUSDELTAPLUS_SIG
	D⁰Δ⁺⁺ -> D⁺Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltaplusplus_DplusDeltaplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAPLUSPLUS_DPLUSDELTAPLUS data. More...
const std::initializer_list< double >	DZERODELTAPLUSPLUS_ELASTIC_SIG
	Elastic D⁰Δ⁺⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltaplusplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAPLUSPLUS_ELASTIC data. More...
const std::initializer_list< double >	DZERODELTAMINUS_ELASTIC_SIG
	Elastic D⁰Δ⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltaminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAMINUS_ELASTIC data. More...
const std::initializer_list< double >	DZERODELTAZERO_DPLUSDELTAMINUS_SIG
	D⁰Δ⁰ -> D⁺Δ⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltazero_DplusDeltaminus_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAZERO_DPLUSDELTAMINUS data. More...
const std::initializer_list< double >	DZERODELTAZERO_ELASTIC_SIG
	Elastic D⁰Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DzeroDeltazero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DZERODELTAZERO_ELASTIC data. More...
const std::initializer_list< double >	DBARDELTA_SQRTS
	Center-of-mass energy. More...
const std::initializer_list< double >	DMINUSDELTAPLUS_ELASTIC_SIG
	Elastic D⁻Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltaplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAPLUS_ELASTIC data. More...
const std::initializer_list< double >	DMINUSDELTAPLUS_DBARZERODELTAZERO_SIG
	D⁻Δ⁺ -> D̄⁰Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltaplus_DbarzeroDeltazero_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAPLUS_DBARZERODELTAZERO data. More...
const std::initializer_list< double >	DMINUSDELTAPLUSPLUS_ELASTIC_SIG
	Elastic D⁻Δ⁺⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltaplusplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAPLUSPLUS_ELASTIC data. More...
const std::initializer_list< double >	DMINUSDELTAPLUSPLUS_DBARZERODELTAPLUS_SIG
	D⁻Δ⁺⁺ -> D̄⁰Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltaplusplus_DbarzeroDeltaplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAPLUSPLUS_DBARZERODELTAPLUS data. More...
const std::initializer_list< double >	DMINUSDELTAMINUS_ELASTIC_SIG
	Elastic D⁻Δ⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltaminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAMINUS_ELASTIC data. More...
const std::initializer_list< double >	DMINUSDELTAZERO_ELASTIC_SIG
	Elastic D⁻Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltazero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAZERO_ELASTIC data. More...
const std::initializer_list< double >	DMINUSDELTAZERO_DBARZERODELTAMINUS_SIG
	D⁻Δ⁰ -> D̄⁰Δ⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DminusDeltazero_DbarzeroDeltaminus_interpolation = nullptr
	An interpolation that gets lazily filled using the DMINUSDELTAZERO_DBARZERODELTAMINUS data. More...
const std::initializer_list< double >	DBARZERODELTAPLUS_DMINUSDELTAPLUSPLUS_SIG
	D̄⁰Δ⁺ -> D⁻Δ⁺⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltaplus_DminusDeltaplusplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAPLUS_DMINUSDELTAPLUSPLUS data. More...
const std::initializer_list< double >	DBARZERODELTAPLUS_ELASTIC_SIG
	Elastic D̄⁰Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltaplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAPLUS_ELASTIC data. More...
const std::initializer_list< double >	DBARZERODELTAPLUSPLUS_ELASTIC_SIG
	Elastic D̄⁰Δ⁺⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltaplusplus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAPLUSPLUS_ELASTIC data. More...
const std::initializer_list< double >	DBARZERODELTAMINUS_DMINUSDELTAZERO_SIG
	D̄⁰Δ⁻ -> D⁻Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltaminus_DminusDeltazero_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAMINUS_DMINUSDELTAZERO data. More...
const std::initializer_list< double >	DBARZERODELTAMINUS_ELASTIC_SIG
	Elastic D̄⁰Δ⁻ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltaminus_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAMINUS_ELASTIC data. More...
const std::initializer_list< double >	DBARZERODELTAZERO_DMINUSDELTAPLUS_SIG
	D̄⁰Δ⁰ -> D⁻Δ⁺ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltazero_DminusDeltaplus_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAZERO_DMINUSDELTAPLUS data. More...
const std::initializer_list< double >	DBARZERODELTAZERO_ELASTIC_SIG
	Elastic D̄⁰Δ⁰ cross section Tolos:2013kva [69]. More...
static std::unique_ptr< InterpolateDataLinear< double > >	DbarzeroDeltazero_elastic_interpolation = nullptr
	An interpolation that gets lazily filled using the DBARZERODELTAZERO_ELASTIC data. More...
RectangularLattice< FourVector > *	UB_lat_pointer = nullptr
	Pointer to the skyrme potential on the lattice. More...
RectangularLattice< FourVector > *	UI3_lat_pointer = nullptr
	Pointer to the symmmetry potential on the lattice. More...
Potentials *	pot_pointer = nullptr
	Pointer to a Potential class. More...
static constexpr int	LPotentials = LogArea::Potentials::id
static constexpr int	LRootSolver = LogArea::RootSolver::id
static constexpr int	LPythia = LogArea::Pythia::id
template<typename T >
constexpr bool	is_stl_container_v = is_stl_container<T>::value
	Helper alias which is common to be defined next to a type trait. More...
template<typename T >
constexpr bool	is_tuple_like_v = is_tuple_like<T>::value
	Helper alias which is common to be defined next to a type trait. More...
template<typename T >
constexpr bool	is_map_like_v = is_map_like<std::decay_t<T>>::value
	Helper alias which is common to be defined next to a type trait. More...
template<typename S , typename T >
constexpr bool	is_streamable_v = is_streamable<S, T>::value
	Helper alias which is common to be defined next to a type trait. More...
template<typename S , typename T >
constexpr bool	is_writable_to_stream_v
	Helper alias which is common to be defined next to a type trait. More...
template<typename T >
constexpr bool	has_to_string_v = has_to_string<T>::value
	Helper alias which is always defined next to a type trait. More...
static constexpr int	LPauliBlocking = LogArea::PauliBlocking::id
static constexpr int	LBox = LogArea::Box::id
static constexpr int	LScatterAction = LogArea::ScatterAction::id
static constexpr int	LScatterAction = LogArea::ScatterAction::id
static constexpr int	LResonances = LogArea::Resonances::id
static constexpr int	LCollider = LogArea::Collider::id
static constexpr int	LInitialConditions = LogArea::InitialConditions::id
static constexpr int	LConfiguration = LogArea::Configuration::id
static constexpr int	LCrossSections = LogArea::CrossSections::id
static constexpr int	LScatterAction = LogArea::ScatterAction::id
static constexpr int	LCollider = LogArea::Collider::id
static constexpr int	LDecayModes = LogArea::DecayModes::id
static constexpr int	LDecayModes = LogArea::DecayModes::id
std::vector< DecayTypePtr > *	all_decay_types = nullptr
	Global pointer to the decay types list. More...
constexpr size_t	num_tab_pts = 200
	Number of tabulation points. More...
static Integrator	integrate
static Integrator2d	integrate2d (1E7)
static constexpr int	LDistributions = LogArea::Distributions::id
static constexpr int	LFluidization = LogArea::HyperSurfaceCrossing::id
static constexpr int	LTmn = LogArea::Tmn::id
static constexpr int	LFluidization = LogArea::HyperSurfaceCrossing::id
static constexpr int	LFpe = LogArea::Fpe::id
static constexpr int	LGrandcanThermalizer = LogArea::GrandcanThermalizer::id
static constexpr int	LGrid = LogArea::Grid::id
static const std::initializer_list< GridBase::SizeType >	ZERO {0}
static const std::initializer_list< GridBase::SizeType >	ZERO_ONE {0, 1}
static const std::initializer_list< GridBase::SizeType >	MINUS_ONE_ZERO {-1, 0}
static const std::initializer_list< GridBase::SizeType >	MINUS_ONE_ZERO_ONE
static constexpr int	LResonances = LogArea::Resonances::id
static constexpr int	LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id
static constexpr int	LInputParser = LogArea::InputParser::id
static constexpr int	LParticleType = LogArea::ParticleType::id
static IsoParticleTypeList	iso_type_list
static std::vector< const IsoParticleType * >	iso_baryon_resonances
static Integrator	integrate
static Integrator2d	integrate2d
static std::unordered_map< std::string, Tabulation >	NR_tabulations
	Tabulation of all N R integrals. More...
static std::unordered_map< std::string, Tabulation >	piR_tabulations
	Tabulation of all pi R integrals. More...
static std::unordered_map< std::string, Tabulation >	RK_tabulations
	Tabulation of all K R integrals. More...
static std::unordered_map< std::string, Tabulation >	DeltaR_tabulations
	Tabulation of all Delta R integrals. More...
static std::unordered_map< std::string, Tabulation >	rhoR_tabulations
	Tabulation of all rho rho integrals. More...
static constexpr int	LMain = LogArea::Main::id
static constexpr int	LList = LogArea::List::id
static einhard::LogLevel	global_default_loglevel = einhard::ALL
	The default logging level is ALL. More...
static constexpr int	LNucleus = LogArea::Nucleus::id
static constexpr int	LParticleType = LogArea::ParticleType::id
static constexpr int	LResonances = LogArea::Resonances::id
static constexpr int	LPauliBlocking = LogArea::PauliBlocking::id
static constexpr int	LPropagation = LogArea::Propagation::id
static constexpr int	LGrandcanThermalizer = LogArea::GrandcanThermalizer::id
static constexpr int	LScatterAction = LogArea::ScatterAction::id
static constexpr int	LScatterActionMulti = LogArea::ScatterActionMulti::id
static constexpr int	LScatterAction = LogArea::ScatterAction::id
static constexpr int	LFindScatter = LogArea::FindScatter::id
static constexpr int	LSphere = LogArea::Sphere::id
Interpolation objects for π+- + π-+ -> π+- + π-+ + γ processes
(opposite charge incoming pions, charged pions in final state)
static std::unique_ptr< InterpolateDataLinear< double > >	pipi_pipi_opp_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi_pipi_opp_dsigma_dk_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi_pipi_opp_dsigma_dtheta_interpolation = nullptr
Interpolation objects for π+ + π+ -> π+ + π+ + γ and
or π- + π- -> π- + π- + γ processes (same charge incoming pions)
static std::unique_ptr< InterpolateDataLinear< double > >	pipi_pipi_same_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi_pipi_same_dsigma_dk_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi_pipi_same_dsigma_dtheta_interpolation = nullptr
Interpolation objects for π + π0 -> π + π0 + γ processes
static std::unique_ptr< InterpolateDataLinear< double > >	pipi0_pipi0_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi0_pipi0_dsigma_dk_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi0_pipi0_dsigma_dtheta_interpolation = nullptr
Interpolation objects for π+- + π-+ -> π0 + π0 + γ processes
static std::unique_ptr< InterpolateDataLinear< double > >	pipi_pi0pi0_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi_pi0pi0_dsigma_dk_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pipi_pi0pi0_dsigma_dtheta_interpolation = nullptr
Interpolation objects for π0 + π0 -> π+- + π-+ + γ processes
static std::unique_ptr< InterpolateDataLinear< double > >	pi0pi0_pipi_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pi0pi0_pipi_dsigma_dk_interpolation = nullptr
static std::unique_ptr< InterpolateData2DSpline >	pi0pi0_pipi_dsigma_dtheta_interpolation = nullptr

Typedef Documentation

SystemTimePoint

using smash::SystemTimePoint = typedef std::chrono::time_point<std::chrono::system_clock>

Type (alias) that is used to store the current time.

Definition at line 22 of file chrono.h.

SystemClock

using smash::SystemClock = typedef std::chrono::system_clock

Type (alias) used to obtain the current time via SystemClock:Now().

Definition at line 25 of file chrono.h.

SystemTimeSpan

using smash::SystemTimeSpan = typedef SystemClock::duration

The time duration type (alias) used for measuring run times.

Definition at line 28 of file chrono.h.

remove_cvref_t

template<class T >

using smash::remove_cvref_t = typedef typename remove_cvref<T>::type

Helper alias which is always defined next to a type trait.

Definition at line 57 of file cxx17compat.h.

DensityLattice

typedef RectangularLattice<DensityOnLattice> smash::DensityLattice

Conveniency typedef for lattice of density.

Definition at line 516 of file density.h.

FieldsLattice

typedef RectangularLattice<FieldsOnLattice> smash::FieldsLattice

Conveniency typedef for lattice of fields.

Definition at line 122 of file fields.h.

FilePtr

using smash::FilePtr = typedef std::unique_ptr<std::FILE, FileDeleter>

A RAII type to replace std::FILE *.

This is an alias type for std::unique_ptr to automatically free the std::FILE resource after the last reference goes out of scope. It is important to use a custom deleter type, and therefore SMASH code should never use std::unique_ptr directly with std::FILE.

Definition at line 61 of file file.h.

Permutation

using smash::Permutation = typedef std::vector<size_t>

Represent a permutation.

Definition at line 127 of file interpolation.h.

Version

using smash::Version = typedef std::string

Descriptive alias for storing a SMASH version associated to keys metadata.

At the moment simply a std::string .

Definition at line 32 of file key.h.

KeyMetadata

using smash::KeyMetadata = typedef std::initializer_list<std::string_view>

Descriptive alias for storing keys metadata.

At the moment this is only a list of versions.

Definition at line 38 of file key.h.

KeyLabels

using smash::KeyLabels = typedef std::vector<std::string_view>

Descriptive alias for storing key labels, i.e.

the series of strings that identify a key in the input file from the main section. At the moment simply a std::vector<std::string_view> (key labels in the database are meant to be literals and this is why we can work with views here).

Definition at line 46 of file key.h.

Enumeration Type Documentation

ComputationMethod

enum smash::ComputationMethod

strong

Calculation method for the cross sections.

It has only one member at the moment. In the future there will be more options.

Enumerator
Analytic

Definition at line 37 of file crosssectionsphoton.h.

{ Analytic };

HadronClass

enum smash::HadronClass

strong

Specifier to classify the different hadron species according to their quantum numbers.

Enumerator
Baryon	All baryons.
Antibaryon	All anti-baryons.
PositiveSMeson	Mesons with strangeness S > 0.
NegativeSMeson	Mesons with strangeness S < 0.
PositiveQZeroSMeson	Non-strange mesons (S = 0) with electric cherge Q > 0.
NegativeQZeroSMeson	Non-strange mesons (S = 0) with electric cherge Q < 0.
ZeroQZeroSMeson	Neutral non-strange mesons.

Definition at line 154 of file grandcan_thermalizer.h.

                       {
  /// All baryons
  Baryon = 0,
  /// All anti-baryons
  Antibaryon = 1,
  /// Mesons with strangeness S > 0
  PositiveSMeson = 2,
  /// Mesons with strangeness S < 0
  NegativeSMeson = 3,
  /// Non-strange mesons (S = 0) with electric cherge Q > 0
  PositiveQZeroSMeson = 4,
  /// Non-strange mesons (S = 0) with electric cherge Q < 0
  NegativeQZeroSMeson = 5,
  /// Neutral non-strange mesons
  ZeroQZeroSMeson = 6,
};

GridOptions

enum smash::GridOptions : char

strong

Identifies the mode of the Grid.

Enumerator
Normal	Without ghost cells.
PeriodicBoundaries	With ghost cells for periodic boundaries.

Definition at line 25 of file grid.h.

                       : char {
  /// Without ghost cells
  Normal = 0,
  /// With ghost cells for periodic boundaries
  PeriodicBoundaries = 1
};

CellSizeStrategy

enum smash::CellSizeStrategy : char

strong

Indentifies the strategy of determining the cell size.

Enumerator
Optimal	Look for optimal cell size.
Largest	Make cells as large as possible. This means a single cell for normal boundary conditions and 8 cells for periodic boundary conditions.

Definition at line 33 of file grid.h.

                            : char {
  /// Look for optimal cell size.
  Optimal,
 
  /**
   * Make cells as large as possible.
   *
   * This means a single cell for normal boundary conditions and 8 cells
   * for periodic boundary conditions.
   */
  Largest
};

CellNumberLimitation

enum smash::CellNumberLimitation : char

strong

Identifies whether the number of cells should be limited.

For the geometric criterion it makes sense to not have less than 1 particle in each cell, since the grid cell search is an optimization and the cells can be always made larger. For the stochastic collision criterion, the cell size is an important calculation parameter, which should be kept constant. The number of cells therefore cannot be limited as the medium grows even though this might be inefficient for large systems.

Enumerator
None	No cell number limitation.
ParticleNumber	Limit the number of cells to the number of particles.

Definition at line 55 of file grid.h.

                                : char {
  /// No cell number limitation.
  None,
 
  /// Limit the number of cells to the number of particles
  ParticleNumber
};

DefaultType

enum smash::DefaultType

strong

New type to explicit distinguish between mandatory and optional keys.

Enumerator
Null	Default "type" for mandatory keys
Value	Normal default with a value associated to it.
Dependent	Default value which depends on other keys

Definition at line 51 of file key.h.

                       {
  /// %Default "type" for mandatory keys
  Null,
  /// Normal default with a value associated to it
  Value,
  /// %Default value which depends on other keys
  Dependent
};

LatticeUpdate

enum smash::LatticeUpdate

strong

Enumerator option for lattice updates.

Updating the lattice is a costly operation and should be performed only if necessary. Possible needs are:

• output: then it is enough to update lattice just before output,
• physics: update every time step is unavoidable.

Enumerator
AtOutput
EveryTimestep
EveryFixedInterval

Definition at line 38 of file lattice.h.

                         {
  AtOutput = 0,
  EveryTimestep = 1,
  EveryFixedInterval = 2,
};

BelongsTo

enum smash::BelongsTo : uint8_t

strong

Enumerator
Nothing
Projectile
Target

Definition at line 21 of file particledata.h.

                     : uint8_t {
  Nothing = 0,
  Projectile = 1,
  Target = 2,
};

Parity

enum smash::Parity

strong

Represent the parity of a particle type.

Enumerator
Pos	Positive parity.
Neg	Negative parity.

Definition at line 27 of file particletype.h.

                  {
  /// Positive parity.
  Pos,
  /// Negative parity.
  Neg
};

WhichDecaymodes

enum smash::WhichDecaymodes

strong

Decide which decay mode widths are returned in get partical widths.

Enumerator
All	All decay mode widths.
Hadronic	Ignore dilepton decay modes widths.
Dileptons	Only return dilepton decays widths.

Definition at line 35 of file particletype.h.

                           {
  /// All decay mode widths
  All,
  /// Ignore dilepton decay modes widths
  Hadronic,
  /// Only return dilepton decays widths
  Dileptons
};

ProcessType

enum smash::ProcessType

strong

ProcessTypes are used to identify the type of the process.

Corresponding integer numbers are given explicitly, because they appear in the output.

Note

Types (41-45) refers to soft string excitations. Here "soft" means that the process does not involve quark or gluon scattering. A string is formed by quark and antiquark, or quark and diquark, in its ends. Then this string decays. Depending on which quark and anti- (or di-)quarks are selected for string formation, the process has one of the following types.

Attention

Since the process type numbers appear in the output, it is important to have an explanation in the user guide. We therefore do not give here an explicit members description and we simply refer to the user guide. If you add a new process type here, document the new member as the other existing ones and include the corresponding description in the Doxygen page with anchor "doxypage_output_process_types".

Enumerator
None	See here for a short description.
Elastic	See here for a short description.
TwoToOne	See here for a short description.
TwoToTwo	See here for a short description.
TwoToThree	See here for a short description.
TwoToFour	See here for a short description.
TwoToFive	See here for a short description.
Decay	See here for a short description.
Wall	See here for a short description.
Thermalization	See here for a short description.
Fluidization	See here for a short description.
FluidizationNoRemoval	See here for a short description.
BremsstrahlungPhoton	See here for a short description.
BremsstrahlungDilepton	See here for a short description.
MultiParticleThreeMesonsToOne	See here for a short description.
MultiParticleThreeToTwo	See here for a short description.
MultiParticleFourToTwo	See here for a short description.
MultiParticleFiveToTwo	See here for a short description.
StringSoftSingleDiffractiveAX	See here for a short description.
StringSoftSingleDiffractiveXB	See here for a short description.
StringSoftDoubleDiffractive	See here for a short description.
StringSoftAnnihilation	See here for a short description.
StringSoftNonDiffractive	See here for a short description.
StringHardNonDiffractive	See here for a short description.
StringHardSingleDiffractiveAX	See here for a short description.
StringHardSingleDiffractiveXB	See here for a short description.
StringHardDoubleDiffractive	See here for a short description.
FailedString	See here for a short description.
Freeforall	See here for a short description.

Definition at line 39 of file processbranch.h.

                       {
  /// \see_process_type{0}
  None = 0,
  /// \see_process_type{1}
  Elastic = 1,
  /// \see_process_type{2}
  TwoToOne = 2,
  /// \see_process_type{3}
  TwoToTwo = 3,
  /// \see_process_type{4}
  TwoToThree = 4,
  /// \see_process_type{15}
  TwoToFour = 15,
  /// \see_process_type{13}
  TwoToFive = 13,
  /// \see_process_type{5}
  Decay = 5,
  /// \see_process_type{6}
  Wall = 6,
  /// \see_process_type{7}
  Thermalization = 7,
  /// \see_process_type{8}
  Fluidization = 8,
  /// \see_process_type{21}
  FluidizationNoRemoval = 21,
  /// \see_process_type{9}
  BremsstrahlungPhoton = 9,
  /// \see_process_type{16}
  BremsstrahlungDilepton = 16,
  /// \see_process_type{10}
  MultiParticleThreeMesonsToOne = 10,
  /// \see_process_type{11}
  MultiParticleThreeToTwo = 11,
  /// \see_process_type{14}
  MultiParticleFourToTwo = 14,
  /// \see_process_type{12}
  MultiParticleFiveToTwo = 12,
  /// \see_process_type{41}
  StringSoftSingleDiffractiveAX = 41,
  /// \see_process_type{42}
  StringSoftSingleDiffractiveXB = 42,
  /// \see_process_type{43}
  StringSoftDoubleDiffractive = 43,
  /// \see_process_type{44}
  StringSoftAnnihilation = 44,
  /// \see_process_type{45}
  StringSoftNonDiffractive = 45,
  /// \see_process_type{46}
  StringHardNonDiffractive = 46,
  /// \see_process_type{47}
  StringHardSingleDiffractiveAX = 47,
  /// \see_process_type{48}
  StringHardSingleDiffractiveXB = 48,
  /// \see_process_type{49}
  StringHardDoubleDiffractive = 49,
  /// \see_process_type{50}
  FailedString = 50,
  /// \see_process_type{90}
  Freeforall = 90
};

NeedsToWrap

enum smash::NeedsToWrap

strong

The options determining what to do if a particle flies out of the grids PlusLength: Used if a periodic boundary condition is applied and a particle passes through the lower bound of the grid.

No: Used if the boundary condition is not periodic. MinusLength: Used if a periodic boundary condition is applied and a particle passes through the upper bound of the grid.

Enumerator
PlusLength
No
MinusLength

Definition at line 358 of file grid.cc.

{ PlusLength, No, MinusLength };

Function Documentation

operator+=()

std::vector<ActionPtr>& smash::operator+= ( std::vector< ActionPtr > &  lhs, std::vector< ActionPtr > &&  rhs  )

inline

Append vector of action pointers.

Parameters

[in]	lhs	vector of action pointers that is appended to
[in]	rhs	vector of action pointers that is appended

Returns

vector of action pointers containing lhs and rhs

Definition at line 531 of file action.h.

                                                                      {
  if (lhs.size() == 0) {
    lhs = std::move(rhs);
  } else {
    lhs.insert(lhs.end(), std::make_move_iterator(rhs.begin()),
               std::make_move_iterator(rhs.end()));
  }
  return lhs;
}

enforce_periodic_boundaries()

template<typename Iterator >

static bool smash::enforce_periodic_boundaries ( Iterator  begin, const Iterator &  end, typename std::iterator_traits< Iterator >::value_type  length  )

static

Enforces periodic boundaries on the given collection of values.

The values in an arbitrary container, starting from begin and ending at end, will be checked. If the value is less than 0, length will be added to it. If the value is greater than or equal to length, length will be subtracted from it.

The implementation therefore assumes that the values are at most one length away from the 0 to length range.

Template Parameters

Iterator

Type of the iterator.

Parameters

begin	Iterator pointing to the first value to check.
end	End iterator.
length	The length of the valid interval.

Returns

Whether a correction was done.

Definition at line 53 of file algorithms.h.

                                                            {
  bool had_to_wrap = false;
  for (; begin != end; ++begin) {
    auto &x = *begin;
    if (x < 0) {
      had_to_wrap = true;
      x += length;
    } else if (x >= length) {
      had_to_wrap = true;
      x -= length;
    }
  }
  return had_to_wrap;
}

Here is the caller graph for this function:

all_of()

template<typename Container , typename UnaryPredicate >

bool smash::all_of ( Container &&  c, UnaryPredicate &&  p  )

inline

Convenience wrapper for std::all_of that operates on a complete container.

Template Parameters

Container	Type of the container.
UnaryPredicate	Type of the predicate.

Parameters

c	A container of elements to examine.
p	Unary predicate.

Returns

Whether all elements in c return true when passed to p.

Definition at line 80 of file algorithms.h.

                                                      {
  return std::all_of(std::begin(c), std::end(c),
                     std::forward<UnaryPredicate>(p));
}

Here is the caller graph for this function:

for_each()

template<typename Container , typename UnaryFunction >

UnaryFunction smash::for_each ( Container &&  c, UnaryFunction &&  f  )

inline

Convenience wrapper for std::for_each that operates on a complete container.

Template Parameters

Container	Type of the container.
UnaryFunction	Type of the function.

Parameters

c	A container of elements on which to perform the function f
f	A function to apply on all elements of the container c

Returns

The function that was applied to all elements.

Definition at line 96 of file algorithms.h.

                                                                {
  return std::for_each(std::begin(c), std::end(c),
                       std::forward<UnaryFunction>(f));
}

Here is the caller graph for this function:

dedup_avg()

template<typename T >

std::pair<std::vector<T>, std::vector<T> > smash::dedup_avg	(	const std::vector< T > &	x,
		const std::vector< T > &	y
	)

Remove duplicates from data (x, y) by averaging y.

Assumes (x, y) is sorted.

Template Parameters

T	Type of the values (should be floating point).

Parameters

x	x-values.
y	y-values.

Returns

New x and y values as a pair of vectors.

Definition at line 65 of file average.h.

                                                                           {
  if (x.size() != y.size()) {
    std::stringstream ss;
    ss << "x and y have to be of same size: " << x.size() << " != " << y.size();
    throw std::runtime_error(ss.str());
  }
  if (x.size() < 1) {
    throw std::runtime_error("x cannot be empty.");
  }
  std::vector<T> new_x;
  new_x.reserve(x.size());
  std::vector<T> new_y;
  new_y.reserve(y.size());
  Average<T> avg;
  T prev_x = x[0];
  for (size_t i = 0; i < x.size(); i++) {
    if (x[i] == prev_x) {
      avg.add(y[i]);
    } else {
      assert(i != 0);
      new_x.push_back(x[i - 1]);
      new_y.push_back(avg.average());
      avg.clear();
      avg.add(y[i]);
      prev_x = x[i];
    }
  }
  new_x.push_back(x.back());
  new_y.push_back(avg.average());
  return std::make_pair(std::move(new_x), std::move(new_y));
}

Here is the call graph for this function:

Here is the caller graph for this function:

isospin_clebsch_gordan_sqr_2to1()

double smash::isospin_clebsch_gordan_sqr_2to1 ( const ParticleType &  p_a, const ParticleType &  p_b, const ParticleType &  Res  )

inline

Calculate the squared isospin Clebsch-Gordan coefficient for two particles p_a and p_b coupling to a resonance Res.

Parameters

[in]	p_a	Information on spin/isospin of particle a
[in]	p_b	Information on spin/isospin of particle b
[in]	Res	Information on spin/isospin of resonance

Returns

Clebsch-Gordan squared for 2->1 reaction

Definition at line 26 of file clebschgordan.h.

                                                                       {
  const double cg = ClebschGordan::coefficient(p_a.isospin(), p_b.isospin(),
                                               Res.isospin(), p_a.isospin3(),
                                               p_b.isospin3(), Res.isospin3());
  return cg * cg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isospin_clebsch_gordan_sqr_3to1()

double smash::isospin_clebsch_gordan_sqr_3to1	(	const ParticleType &	p_a,
		const ParticleType &	p_b,
		const ParticleType &	p_c,
		const ParticleType &	Res
	)

Calculate the squared isospin Clebsch-Gordan coefficient for three particles p_a, p_b and p_c coupling to a resonance Res.

Parameters

[in]	p_a	Information on spin/isospin of particle a
[in]	p_b	Information on spin/isospin of particle b
[in]	p_c	Information on spin/isospin of particle c
[in]	Res	Information on spin/isospin of resonance

Returns

Clebsch-Gordan squared for 3->1 reaction

Definition at line 37 of file clebschgordan.cc.

                                                                {
  // Calculate allowed isospin range for 3->1 reaction I_ab
  const auto min_I_ab = std::abs(p_a.isospin() - p_b.isospin());
  const auto max_I_ab = p_a.isospin() + p_b.isospin();
  std::vector<int> possible_I_ab(max_I_ab - min_I_ab + 1);
  std::iota(possible_I_ab.begin(), possible_I_ab.end(), min_I_ab);
  std::vector<int> allowed_I_ab;
  allowed_I_ab.reserve(possible_I_ab.size());
  for (const auto Iab : possible_I_ab) {
    const auto min_I = std::abs(Iab - p_c.isospin());
    const auto max_I = Iab + p_c.isospin();
    if (min_I <= Res.isospin() && Res.isospin() <= max_I) {
      allowed_I_ab.push_back(Iab);
    }
  }
  if (allowed_I_ab.size() != 1) {
    throw std::runtime_error(
        "The coupled 3-body isospin state is not uniquely defined for " +
        Res.name() + " -> " + p_a.name() + " " + p_b.name() + " " + p_c.name());
  }
  const auto I_ab = allowed_I_ab[0];
 
  const int I_abz = p_a.isospin3() + p_b.isospin3();
  const double cg =
      ClebschGordan::coefficient(I_ab, p_c.isospin(), Res.isospin(), I_abz,
                                 p_c.isospin3(), Res.isospin3()) *
      ClebschGordan::coefficient(p_a.isospin(), p_b.isospin(), I_ab,
                                 p_a.isospin3(), p_b.isospin3(), I_abz);
  return cg * cg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isospin_clebsch_gordan_sqr_2to2()

double smash::isospin_clebsch_gordan_sqr_2to2	(	const ParticleType &	p_a,
		const ParticleType &	p_b,
		const ParticleType &	p_c,
		const ParticleType &	p_d,
		const int	I = -1
	)

Calculate the squared isospin Clebsch-Gordan coefficient for a 2-to-2 reaction A + B -> C + D.

If a total isospin value I is given (doubled in order to be integer), then only contributions with that total isospin will be counted.

Parameters

[in]	p_a	Information on spin/isospin of particle a
[in]	p_b	Information on spin/isospin of particle b
[in]	p_c	Information on spin/isospin of particle c
[in]	p_d	Information on spin/isospin of particle d
[in]	I	total isospin of the reaction

Returns

Clebsch-Gordan squared for 2->2 reaction

Definition at line 71 of file clebschgordan.cc.

                                                                             {
  const int I_z = p_a.isospin3() + p_b.isospin3();
 
  /* Loop over total isospin in allowed range. */
  double isospin_factor = 0.;
  for (const int I_tot : I_tot_range(p_a, p_b, p_c, p_d)) {
    if (I < 0 || I_tot == I) {
      const double cg_in = isospin_clebsch_gordan_2to1(p_a, p_b, I_tot, I_z);
      const double cg_out = isospin_clebsch_gordan_2to1(p_c, p_d, I_tot, I_z);
      isospin_factor = isospin_factor + cg_in * cg_in * cg_out * cg_out;
    }
  }
  return isospin_factor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cut_off()

double smash::cut_off

(

const double

sigma_mb

)

Cross section after cut off.

Photon cross sections diverge tremendously at the threshold which becomes particularly problematic when running with broad rho mesons. Then the actual photon cross section is used for the weight: W = Sigma_photon/Sigma_hadron. If the photon cross section diverges, the weight becomes huge and we significantly overestimate photon production. This cutoff fixes the problem.

Either the cross section is returned or, if the cross section i larger than the cut off, the cut off value is returned.

Parameters

[in]

sigma_mb

cross section before cut off [mb]

Returns

Cross section after cut off [mb]

Definition at line 55 of file crosssectionsphoton.cc.

                                      {
  constexpr double maximum_cross_section_photon = 200.0;  // [mb]
  return (sigma_mb > maximum_cross_section_photon)
             ? maximum_cross_section_photon
             : sigma_mb;
}

Here is the caller graph for this function:

y_l_m()

double smash::y_l_m	(	int	l,
		int	m,
		double	cosx,
		double	phi
	)

Spherical harmonics Y_2_0, Y_2_2, Y_3_0 and Y_4_0.

Parameters

[in]	l	Angular momentum value (2 and 4 are supported)
[in]	m	projection value (l = 2 and m = 2 are supported)
[in]	cosx	Cosine of the polar angle
[in]	phi	Azimuthal angle

Returns

Value of the corresponding spherical harmonic

Exceptions

domain_error

if unsupported l is encountered

Definition at line 203 of file deformednucleus.cc.

                                                    {
  if (l == 2 && m == 0) {
    return (1. / 4) * std::sqrt(5 / M_PI) * (3. * (cosx * cosx) - 1);
  } else if (l == 2 && m == 2) {
    double sinx2 = 1. - cosx * cosx;
    return (1. / 4) * std::sqrt(15 / (2. * M_PI)) * sinx2 * std::cos(2. * phi);
  } else if (l == 3 && m == 0) {
    return (1. / 4) * std::sqrt(7 / M_PI) *
           (5. * cosx * (cosx * cosx) - 3. * cosx);
  } else if (l == 4 && m == 0) {
    return (3. / 16) * std::sqrt(1 / M_PI) *
           (35. * (cosx * cosx) * (cosx * cosx) - 30. * (cosx * cosx) + 3);
  } else {
    throw std::domain_error(
        "Not a valid angular momentum quantum number in y_l_m.");
  }
}

Here is the caller graph for this function:

operator<<() [1/11]

std::ostream & smash::operator<<	(	std::ostream &	os,
		DensityType	dt
	)

Create the output operator for the densities.

Parameters

[out]	os	Output operator for the densities
[in]	dt	Type of density (e.g. baryon density)

Returns

An output operator for the densities

Definition at line 286 of file density.cc.

                                                              {
  switch (dens_type) {
    case DensityType::Hadron:
      os << "hadron density";
      break;
    case DensityType::Baryon:
      os << "baryon density";
      break;
    case DensityType::BaryonicIsospin:
      os << "baryonic isospin density";
      break;
    case DensityType::Pion:
      os << "pion density";
      break;
    case DensityType::Isospin3_tot:
      os << "total isospin3 density";
      break;
    case DensityType::None:
      os << "none";
      break;
    default:
      os.setstate(std::ios_base::failbit);
  }
  return os;
}

density_factor()

double smash::density_factor	(	const ParticleType &	type,
		DensityType	dens_type
	)

Get the factor that determines how much a particle contributes to the density type that is computed.

E.g. positive pion contributes with factor 1 to total particle density and with factor 0 to baryon density. Proton contributes with factor 1 to baryon density, anti-proton - with factor -1 to baryon density, and so on.

Parameters

[in]	type	type of the particle to be tested
[in]	dens_type	The density type

Returns

The corresponding factor (0 if the particle doesn't contribute at all).

Definition at line 17 of file density.cc.

                                                                       {
  switch (dens_type) {
    case DensityType::Hadron:
      return type.is_hadron() ? 1. : 0.;
    case DensityType::Baryon:
      return static_cast<double>(type.baryon_number());
    case DensityType::BaryonicIsospin:
      return type.is_baryon() || type.is_nucleus() ? type.isospin3_rel() : 0.;
    case DensityType::Pion:
      return type.pdgcode().is_pion() ? 1. : 0.;
    case DensityType::Isospin3_tot:
      return type.is_hadron() ? type.isospin3() : 0.;
    case DensityType::Charge:
      return static_cast<double>(type.charge());
    case DensityType::Strangeness:
      return static_cast<double>(type.strangeness());
    default:
      return 0.;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

smearing_factor_norm()

double smash::smearing_factor_norm ( const double  two_sigma_sqr )

inline

Norm of the Gaussian smearing function.

Parameters

[in]

two_sigma_sqr

\(2 \sigma^2 \) [fm \(^2\)], \( \sigma \) - width of gaussian smearing

Returns

\( (2 \pi \sigma^2)^{3/2}\) [fm \(^3\)]

Definition at line 61 of file density.h.

                                                               {
  const double tmp = two_sigma_sqr * M_PI;
  return tmp * std::sqrt(tmp);
}

Here is the caller graph for this function:

smearing_factor_rcut_correction()

double smash::smearing_factor_rcut_correction ( const double  rcut_in_sigma )

inline

Gaussians used for smearing are cut at radius \(r_{cut} = a \sigma \) for calculation speed-up.

In the limit of \(a \to \infty \) smearing factor is normalized to 1:

\[ \frac{4 \pi}{(2 \pi \sigma^2)^{3/2}} \int_0^{\infty} e^{-r^2/2 \sigma^2} r^2 dr = 1 \]

However, for finite \( a\) integral is less than one:

\[ g(a) \equiv \frac{4 \pi}{(2 \pi \sigma^2)^{3/2}} \int_0^{a \sigma} e^{-r^2/2 \sigma^2} r^2 dr = -\sqrt{\frac{2}{\pi}} a e^{-a^2/2} + Erf[a/\sqrt{2}] \]

This \( g(a) \) is typically close to 1. For example, for \(r_{cut} = 3 \sigma \), and thus \( a=3 \), g(3) = 0.9707; g(4) = 0.9987. The aim of this function is to compensate for this factor.

Parameters

[in]

rcut_in_sigma

\( a = r_{cut} / \sigma\)

Returns

\( g(a) \)

Definition at line 83 of file density.h.

                                                                          {
  const double x = rcut_in_sigma / std::sqrt(2.0);
  return -2.0 / std::sqrt(M_PI) * x * std::exp(-x * x) + std::erf(x);
}

Here is the caller graph for this function:

unnormalized_smearing_factor()

std::pair< double, ThreeVector > smash::unnormalized_smearing_factor	(	const ThreeVector &	r,
		const FourVector &	p,
		const double	m_inv,
		const DensityParameters &	dens_par,
		const bool	compute_gradient = false
	)

Implements gaussian smearing for any quantity.

Computes smearing factor taking Lorentz contraction into account. Integral of unnormalized smearing factor over space should be \( (2 \pi \sigma^2)^{3/2} \). Division over norm is split for efficiency: it is not nice to recalculate the same constant norm at every call.

Parameters

[in]	r	vector from the particle to the point of interest [fm]
[in]	p	particle 4-momentum to account for Lorentz contraction [GeV]
[in]	m_inv	particle mass, \( (E^2 - p^2)^{-1/2} \) [GeV]
[in]	dens_par	object containing precomputed parameters for density calculation.
[in]	compute_gradient	option, true - compute gradient, false - no

Returns

(smearing factor, the gradient of the smearing factor or a zero three vector)

Definition at line 38 of file density.cc.

                                                                    {
  const double r_sqr = r.sqr();
  // Distance from particle to point of interest > r_cut
  if (r_sqr > dens_par.r_cut_sqr()) {
    return std::make_pair(0.0, ThreeVector(0.0, 0.0, 0.0));
  }
 
  const FourVector u = p * m_inv;
  const double u_r_scalar = r * u.threevec();
  const double r_rest_sqr = r_sqr + u_r_scalar * u_r_scalar;
 
  // Lorentz contracted distance from particle to point of interest > r_cut
  if (r_rest_sqr > dens_par.r_cut_sqr()) {
    return std::make_pair(0.0, ThreeVector(0.0, 0.0, 0.0));
  }
  const double sf = std::exp(-r_rest_sqr * dens_par.two_sig_sqr_inv()) * u.x0();
  const ThreeVector sf_grad = compute_gradient
                                  ? sf * (r + u.threevec() * u_r_scalar) *
                                        dens_par.two_sig_sqr_inv() * 2.0
                                  : ThreeVector(0.0, 0.0, 0.0);
 
  return std::make_pair(sf, sf_grad);
}

Here is the call graph for this function:

Here is the caller graph for this function:

current_eckart() [1/2]

std::tuple< double, FourVector, ThreeVector, ThreeVector, FourVector, FourVector, FourVector, FourVector > smash::current_eckart	(	const ThreeVector &	r,
		const ParticleList &	plist,
		const DensityParameters &	par,
		DensityType	dens_type,
		bool	compute_gradient,
		bool	smearing
	)

Calculates Eckart rest frame density and 4-current of a given density type and optionally the gradient of the density in an arbitary frame (grad j0), the curl of the 3-current, and the time, x, y, and z derivatives of the 4-current.

\[ j^{\mu} = (\sqrt{2\pi} \sigma )^{-3} \sum_{i=1}^N C_i u^{\mu}_i \exp \left( - \frac{\bigl[\mathbf{r} - \mathbf{r}_i + \frac{\gamma_i^2}{1 + \gamma_i} \boldsymbol{\beta}_i (\boldsymbol{\beta}_i, \mathbf{r} - \mathbf{r}_i) \bigr]^2}{2\sigma^2} \right) \]

\[ \rho^{Eckart} = \sqrt{j^{\mu} j_{\mu}} \]

Here \( C_i \) is a corresponding value of "charge". If baryon current option is selected then \( C_i \) is 1 for baryons, -1 for antibaryons and 0 otherwise. For proton/neutron current \( C_i = 1\) for proton/neutron and 0 otherwise.

To avoid the problems with Eckart frame definition, densities for positive and negative charges, \(\rho_+ \) and \( \rho_-\), are computed separately and final density is \(\rho_+ - \rho_-\).

Parameters

[in]	r	Arbitrary space point where 4-current is calculated [fm]; ignored if smearing is false
[in]	plist	List of all particles to be used in \(j^{\mu}\) calculation. If smearing is false or if the distance between particle and calculation point r, \( |r-r_i| > r_{cut} \) then particle input to density will be ignored.

Next four values are taken from ExperimentalParameters structure:

Parameters

[in]	par	Set of parameters packed in one structure. From them the cutting radius r_cut \( r_{cut} / \sigma \), number of test-particles ntest and the gaussian width gs_sigma are needed.
[in]	dens_type	type of four-currect to be calculated: baryon, proton or neutron options are currently available
[in]	compute_gradient	true - compute gradient, false - no
[in]	smearing	whether to use gaussian smearing or not. If false, this parameter will use ALL particles equally to calculate the current, and that as such it will not be normalized wrt volume. This should be true for any internal calculation of any quantity and only makes sense to turn off for output purposes in a box.

Returns

(rest frame density in the local Eckart frame [fm \(^{-3}\)], \( j^\mu \) as a 4-vector, \( \boldsymbol{\nabla}\cdot j^0 \) or a 0 3-vector, \( \boldsymbol{\nabla} \times \mathbf{j} \) or a 0 3-vector, \( \partial_t j^\mu \) or a 0 4-vector, \( \partial_x j^\mu \) or a 0 4-vector, \( \partial_y j^\mu \) or a 0 4-vector, \( \partial_z j^\mu \) or a 0 4-vector).

Definition at line 176 of file density.cc.

                                                     {
  return current_eckart_impl(r, plist, par, dens_type, compute_gradient,
                             smearing);
}

Here is the call graph for this function:

Here is the caller graph for this function:

current_eckart() [2/2]

std::tuple< double, FourVector, ThreeVector, ThreeVector, FourVector, FourVector, FourVector, FourVector > smash::current_eckart	(	const ThreeVector &	r,
		const Particles &	plist,
		const DensityParameters &	par,
		DensityType	dens_type,
		bool	compute_gradient,
		bool	smearing
	)

convenience overload of the above (ParticleList -> Particles)

Definition at line 184 of file density.cc.

                                                     {
  return current_eckart_impl(r, plist, par, dens_type, compute_gradient,
                             smearing);
}

Here is the call graph for this function:

update_lattice_with_list_of_particles()

template<typename T >

void smash::update_lattice_with_list_of_particles	(	RectangularLattice< T > *	lat,
		const LatticeUpdate	update,
		const DensityType	dens_type,
		const DensityParameters &	par,
		const ParticleList &	plist,
		const bool	compute_gradient,
		const bool	lattice_reset = true
	)

Updates the contents on the lattice.

Parameters

[in,out]	lat	The lattice on which the content will be updated
[in]	update	tells if called for update at printout or at timestep
[in]	dens_type	density type to be computed on the lattice
[in]	par	a structure containing testparticles number and gaussian smearing parameters.
[in]	plist	the particle list to compute the lattice quantities
[in]	compute_gradient	Whether to compute the gradients
[in]	lattice_reset	Whether to start with a new lattice

Template Parameters

T	LatticeType

Definition at line 532 of file density.h.

                                                                            {
  // Do not proceed if lattice does not exists/update not required
  if (lat == nullptr || lat->when_update() != update) {
    return;
  }
  if (lattice_reset) {
    lat->reset();
  }
  for (const ParticleData &part : plist) {
    if (par.only_participants()) {
      // if this conditions holds, the hadron is a spectator
      if (part.get_history().collisions_per_particle == 0) {
        continue;
      }
    }
    if (par.ignore_unformed()) {
      if (part.xsec_scaling_factor() < 1) {
        continue;
      }
    }
    const double dens_factor = density_factor(part.type(), dens_type);
    if (std::abs(dens_factor) < really_small) {
      continue;
    }
    const FourVector p_mu = part.momentum();
    const ThreeVector pos = part.position().threevec();
 
    // act accordingly to which smearing is used
    if (par.smearing() == SmearingMode::CovariantGaussian) {
      // get the normalization factor for the covariant Gaussian smearing
      const double norm_factor_gaus = par.norm_factor_sf();
      const double m = p_mu.abs();
      if (unlikely(m < really_small)) {
        logg[LDensity].warn("Gaussian smearing is undefined for momentum ",
                            p_mu);
        continue;
      }
      const double m_inv = 1.0 / m;
 
      // unweighted contribution to density
      const double common_weight = dens_factor * norm_factor_gaus;
      lat->iterate_in_cube(
          pos, par.r_cut(), [&](T &node, int ix, int iy, int iz) {
            // find the weight for smearing
            const ThreeVector r = lat->cell_center(ix, iy, iz);
            const auto sf = unnormalized_smearing_factor(pos - r, p_mu, m_inv,
                                                         par, compute_gradient);
            node.add_particle(part, sf.first * common_weight);
            if (par.derivatives() == DerivativesMode::CovariantGaussian) {
              node.add_particle_for_derivatives(part, dens_factor,
                                                sf.second * norm_factor_gaus);
            }
          });
    } else if (par.smearing() == SmearingMode::Discrete) {
      // get the volume of the cell and weights for discrete smearing
      const double V_cell = (lat->cell_sizes())[0] * (lat->cell_sizes())[1] *
                            (lat->cell_sizes())[2];
      // weights for coarse smearing
      const double big = par.central_weight();
      const double small = (1.0 - big) / 6.0;
      // unweighted contribution to density
      const double common_weight =
          dens_factor / (par.ntest() * par.nensembles() * V_cell);
      lat->iterate_nearest_neighbors(
          pos, [&](T &node, int iterated_index, int center_index) {
            node.add_particle(
                part, common_weight *
                          // the contribution to density is weighted depending
                          // on what node it is added to
                          (iterated_index == center_index ? big : small));
          });
    } else if (par.smearing() == SmearingMode::Triangular) {
      // get the radii for triangular smearing
      const std::array<double, 3> triangular_radius = {
          par.triangular_range() * (lat->cell_sizes())[0],
          par.triangular_range() * (lat->cell_sizes())[1],
          par.triangular_range() * (lat->cell_sizes())[2]};
      const double prefactor_triangular =
          1.0 /
          (par.ntest() * par.nensembles() * triangular_radius[0] *
           triangular_radius[0] * triangular_radius[1] * triangular_radius[1] *
           triangular_radius[2] * triangular_radius[2]);
      // unweighted contribution to density
      const double common_weight = dens_factor * prefactor_triangular;
      lat->iterate_in_rectangle(
          pos, triangular_radius, [&](T &node, int ix, int iy, int iz) {
            // compute the position of the node
            const ThreeVector cell_center = lat->cell_center(ix, iy, iz);
            // compute smearing weight
            const double weight_x =
                triangular_radius[0] - std::abs(cell_center[0] - pos[0]);
            const double weight_y =
                triangular_radius[1] - std::abs(cell_center[1] - pos[1]);
            const double weight_z =
                triangular_radius[2] - std::abs(cell_center[2] - pos[2]);
            // add the contribution to the node
            node.add_particle(part,
                              common_weight * weight_x * weight_y * weight_z);
          });
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_lattice_accumulating_ensembles()

template<typename T >

void smash::update_lattice_accumulating_ensembles	(	RectangularLattice< T > *	lat,
		const LatticeUpdate	update,
		const DensityType	dens_type,
		const DensityParameters &	par,
		const std::vector< Particles > &	ensembles,
		const bool	compute_gradient
	)

Updates the contents on the lattice when ensembles are used.

Parameters

[out]	lat	The lattice on which the content will be updated
[in]	update	tells if called for update at printout or at timestep
[in]	dens_type	density type to be computed on the lattice
[in]	par	a structure containing testparticles number and gaussian smearing parameters.
[in]	ensembles	the particles vector for each ensemble
[in]	compute_gradient	Whether to compute the gradients

Template Parameters

T	LatticeType

Definition at line 654 of file density.h.

                                                                        {
  // Do not proceed if lattice does not exists/update not required
  if (lat == nullptr || lat->when_update() != update) {
    return;
  }
  lat->reset();
  for (const Particles &particles : ensembles) {
    update_lattice_with_list_of_particles(lat, update, dens_type, par,
                                          particles.copy_to_vector(),
                                          compute_gradient, false);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_lattice()

void smash::update_lattice	(	RectangularLattice< DensityOnLattice > *	lat,
		RectangularLattice< FourVector > *	old_jmu,
		RectangularLattice< FourVector > *	new_jmu,
		RectangularLattice< std::array< FourVector, 4 >> *	four_grad_lattice,
		const LatticeUpdate	update,
		const DensityType	dens_type,
		const DensityParameters &	par,
		const std::vector< Particles > &	ensembles,
		const double	time_step,
		const bool	compute_gradient
	)

Updates the contents on the lattice of DensityOnLattice type.

Parameters

[out]	lat	The lattice of DensityOnLattice type on which the content will be updated
[in]	old_jmu	Auxiliary lattice, filled with current values at t0, needed for calculating time derivatives
[in]	new_jmu	Auxiliary lattice,filled with current values at t0 + dt, needed for calculating time derivatives
[in]	four_grad_lattice	Auxiliary lattice for calculating the fourgradient of the current
[in]	update	Tells if called for update at printout or at timestep
[in]	dens_type	Density type to be computed on the lattice
[in]	par	a structure containing testparticles number and gaussian smearing parameters.
[in]	ensembles	The particles vector for each ensemble
[in]	time_step	Time step used in the simulation
[in]	compute_gradient	Whether to compute the gradients

Definition at line 191 of file density.cc.

                                                         {
  // Do not proceed if lattice does not exists/update not required
  if (lat == nullptr || lat->when_update() != update) {
    return;
  }
  const std::array<int, 3> lattice_n_cells = lat->n_cells();
  const int number_of_nodes =
      lattice_n_cells[0] * lattice_n_cells[1] * lattice_n_cells[2];
 
  /*
   * Take the provided DensityOnLattice lattice and use the information about
   * the current to create a lattice of current FourVectors. Because the lattice
   * hasn't been updated at this point yet, it provides the t_0 time step
   * information on the currents.
   */
  // copy values of jmu at t_0 onto old_jmu;
  // proceed only if finite difference gradients are calculated
  if (par.derivatives() == DerivativesMode::FiniteDifference) {
    for (int i = 0; i < number_of_nodes; i++) {
      old_jmu->assign_value(i, ((*lat)[i]).jmu_net());
    }
  }
 
  update_lattice_accumulating_ensembles(lat, update, dens_type, par, ensembles,
                                        compute_gradient);
 
  // calculate the gradients for finite difference derivatives
  if (par.derivatives() == DerivativesMode::FiniteDifference) {
    // copy values of jmu FourVectors at t_0 + time_step onto new_jmu
    for (int i = 0; i < number_of_nodes; i++) {
      new_jmu->assign_value(i, ((*lat)[i]).jmu_net());
    }
 
    // compute time derivatives and gradients of all components of jmu
    new_jmu->compute_four_gradient_lattice(*old_jmu, time_step,
                                           *four_grad_lattice);
 
    // substitute new derivatives
    int node_number = 0;
    for (auto &node : *lat) {
      auto tmp = (*four_grad_lattice)[node_number];
      node.overwrite_djmu_dxnu(tmp[0], tmp[1], tmp[2], tmp[3]);
      node_number++;
    }
  }  // if (par.derivatives() == DerivativesMode::FiniteDifference)
 
  // calculate gradients of rest frame density
  if (par.rho_derivatives() == RestFrameDensityDerivativesMode::On) {
    for (auto &node : *lat) {
      // the rest frame density
      double rho = node.rho();
      const int sgn = rho > 0 ? 1 : -1;
      if (std::abs(rho) < very_small_double) {
        rho = sgn * very_small_double;
      }
 
      // the computational frame j^mu
      const FourVector jmu = node.jmu_net();
      // computational frame array of derivatives of j^mu
      const std::array<FourVector, 4> djmu_dxnu = node.djmu_dxnu();
 
      const double drho_dt =
          (1 / rho) *
          (jmu.x0() * djmu_dxnu[0].x0() - jmu.x1() * djmu_dxnu[0].x1() -
           jmu.x2() * djmu_dxnu[0].x2() - jmu.x3() * djmu_dxnu[0].x3());
 
      const double drho_dx =
          (1 / rho) *
          (jmu.x0() * djmu_dxnu[1].x0() - jmu.x1() * djmu_dxnu[1].x1() -
           jmu.x2() * djmu_dxnu[1].x2() - jmu.x3() * djmu_dxnu[1].x3());
 
      const double drho_dy =
          (1 / rho) *
          (jmu.x0() * djmu_dxnu[2].x0() - jmu.x1() * djmu_dxnu[2].x1() -
           jmu.x2() * djmu_dxnu[2].x2() - jmu.x3() * djmu_dxnu[2].x3());
 
      const double drho_dz =
          (1 / rho) *
          (jmu.x0() * djmu_dxnu[3].x0() - jmu.x1() * djmu_dxnu[3].x1() -
           jmu.x2() * djmu_dxnu[3].x2() - jmu.x3() * djmu_dxnu[3].x3());
 
      const FourVector drho_dxnu = {drho_dt, drho_dx, drho_dy, drho_dz};
 
      node.overwrite_drho_dxnu(drho_dxnu);
    }
  }  // if (par.rho_derivatives() == RestFrameDensityDerivatives::On){
}  // void update_lattice()

Here is the call graph for this function:

Here is the caller graph for this function:

breit_wigner()

double smash::breit_wigner	(	double	m,
		double	pole,
		double	width
	)

Returns a relativistic Breit-Wigner distribution.

The normalization is such that the integration over \( \sqrt{s} \) from 0 to infinity yields one.

Parameters

[in]	m	Argument of the Breit-Wigner function (off-shell mass m in GeV)
[in]	pole	Resonance pole mass \( m_0 \) in GeV
[in]	width	Resonance width \( \Gamma \) in GeV

Returns

\( \frac{2}{\pi} \frac{m^2\Gamma}{(m^2-m_0^2)^2 + m^2\Gamma^2} \)

Definition at line 25 of file distributions.cc.

                                                                           {
  const double msqr = m * m;
  const double dmsqr = msqr - pole * pole;
  return 2. * msqr * width / (M_PI * (dmsqr * dmsqr + msqr * width * width));
}

Here is the caller graph for this function:

breit_wigner_nonrel()

double smash::breit_wigner_nonrel	(	double	m,
		double	pole,
		double	width
	)

Returns a non-relativistic Breit-Wigner distribution, which is essentially a Cauchy distribution with half width.

Parameters

[in]	m	Argument of the Breit-Wigner function (off-shell mass m in GeV)
[in]	pole	resonance pole mass \( m_0 \) in GeV
[in]	width	resonance width \( \Gamma \) in GeV

Returns

\( \frac{\Gamma/2}{\pi ((m-m_0)^2+\Gamma^2/4)}\)

Definition at line 32 of file distributions.cc.

                                                                {
  return cauchy(m, pole, width / 2.);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cauchy()

double smash::cauchy	(	double	x,
		double	pole,
		double	width
	)

Returns a Cauchy distribution (sometimes also called Lorentz or non-relativistic Breit-Wigner distribution) with the given parameters.

The normalization is such that integrating over x from -infinity to +infinity yields one.

Parameters

x	Argument of the Cauchy function in GeV.
pole	Pole parameter \( m_0 \) of the Cauchy function in GeV, i.e. location of the peak.
width	Width parameter \( \Gamma \) of the Cauchy function in GeV, determining the sharpness of the peak.

Returns

\( \frac{\Gamma}{\pi ((x-m_0)^2+\Gamma^2)}\)

Definition at line 37 of file distributions.cc.

                                                   {
  const double dm = x - pole;
  return width / (M_PI * (dm * dm + width * width));
}

Here is the caller graph for this function:

density_integrand_mass()

double smash::density_integrand_mass	(	const double	energy,
		const double	momentum_sqr,
		const double	temperature
	)

density_integrand_mass - off_equilibrium distribution for massive particles

Parameters

[in]	energy	\(E\) (in GeV)
[in]	momentum_sqr	squared \(p\) (in GeV \(^2\))
[in]	temperature	\(T\) (in GeV)

Returns

\[f=pe^{-\frac{\sqrt{m^2+p^2}}{T_0}}\]

Definition at line 42 of file distributions.cc.

                                                        {
  return momentum_sqr * std::sqrt(momentum_sqr) *
         std::exp(-energy / temperature);
}

Here is the caller graph for this function:

density_integrand_1M_IC()

double smash::density_integrand_1M_IC	(	const double	energy,
		const double	momentum_sqr,
		const double	temperature
	)

density integrand - 1M_IC massless particles for expanding metric initialization, see Bazow:2016oky [10]

Parameters

[in]	energy	\(E\) (in GeV)
[in]	momentum_sqr	squared \(p\) (in GeV \(^2\))
[in]	temperature	\(T\) (in GeV)

Returns

Value of function 1M_IC

Definition at line 48 of file distributions.cc.

                                                         {
  return ((3.0 / 20.0) * (momentum_sqr / (temperature * temperature)) -
          (6.0 / 5.0) * (energy / temperature) + (14.0 / 5.0)) *
         std::exp(-energy / temperature) * momentum_sqr;
}

Here is the caller graph for this function:

density_integrand_2M_IC()

double smash::density_integrand_2M_IC	(	const double	energy,
		const double	momentum_sqr,
		const double	temperature
	)

density integrand - 2M_IC massless particles for expanding metric initialization, see Bazow:2016oky [10]

Parameters

[in]	energy	\(E\) (in GeV)
[in]	momentum_sqr	squared \(p\) (in GeV \(^2\))
[in]	temperature	\(T\) (in GeV)

Returns

Value of function 2M_IC

Definition at line 55 of file distributions.cc.

                                                         {
  return (0.75 + 0.125 * (momentum_sqr / (temperature * temperature)) -
          (1.0 / 30.0) * (momentum_sqr * energy /
                          (temperature * temperature * temperature)) +
          (1.0 / 480.0) *
              (momentum_sqr * momentum_sqr /
               (temperature * temperature * temperature * temperature))) *
         std::exp(-energy / temperature) * momentum_sqr;
}

Here is the caller graph for this function:

juttner_distribution_func()

double smash::juttner_distribution_func	(	double	momentum_radial,
		double	mass,
		double	temperature,
		double	effective_chemical_potential,
		double	statistics
	)

Relativistic Juttner distribution function is just a convenience wrapper for displaying Fermi, Bose, and Boltzmann distributions in one mathematical form.

Juttner distribution is a unified way of introducing quantum thermal distributions, in which the "statistics" variable controls the type of the distribution used: statistics = 0: Boltzmann distribution statistics = -1: Bose distribution statistics = +1: Fermi distribution.

Parameters

[in]	momentum_radial	length of the momentum vector [GeV]
[in]	mass	(pole) mass of the particle species [GeV]
[in]	temperature	temperature of the system [GeV]
[in]	effective_chemical_potential	effective chemical potential of the system [GeV]
[in]	statistics	quantum statistics of the particles species (+1 for Fermi, -1 for Bose, 0 for Boltzmann)

Returns

the Juttner distribution function

Definition at line 74 of file distributions.cc.

                                                    {
  const double Boltzmann_factor =
      std::exp(-(std::sqrt(momentum_radial * momentum_radial + mass * mass) -
                 effective_chemical_potential) /
               temperature);
  // exp(-x) / [1 + exp(-x)] is numerically more stable than 1 / [exp(x) + 1]
  return Boltzmann_factor / (1 + statistics * Boltzmann_factor);
}

Here is the caller graph for this function:

sample_momenta_non_eq_mass()

double smash::sample_momenta_non_eq_mass	(	const double	temperature,
		const double	mass
	)

Samples a momentum via rejection method from the non-equilibrium distribution.

\[f=pe^{-\frac{\sqrt{m^2+p^2}}{T_0}}\]

See also

density_integrand_mass

Parameters

[in]	temperature	Temperature \(T\) [GeV]
[in]	mass	Mass of the particle: \(m = \sqrt{E^2 - p^2}\) [GeV]

Returns

one possible momentum between mass and 50 GeV

Definition at line 86 of file distributions.cc.

                                                                               {
  logg[LDistributions].debug("Sample momenta with mass ", mass, " and T ",
                             temperature);
 
  /* Calculate range on momentum values to use
   * ideally 0.0 and as large as possible but we want to be efficient! */
  const double mom_min = 0.0;
  const double mom_max =
      std::sqrt(50. * 50. * temperature * temperature - mass * mass);
  /* Calculate momentum and energy values that will give
   * maxima of density_integrand_mass, verified by differentiation */
  const double p_non_eq_sq =
      0.5 * (9 * temperature * temperature +
             temperature *
                 std::sqrt(81 * temperature * temperature + 36 * mass * mass));
  const double e_non_eq = std::sqrt(p_non_eq_sq + mass * mass);
  const double probability_max =
      2. * density_integrand_mass(e_non_eq, p_non_eq_sq, temperature);
 
  /* sample by rejection method: (see numerical recipes for more efficient)
   * random momenta and random probability need to be below the distribution */
  double energy, momentum_radial, probability;
  do {
    // sample uniformly in momentum, DONT sample uniformly in energy!
    momentum_radial = random::uniform(mom_min, mom_max);
    // Energy by on-shell condition
    energy = std::sqrt(momentum_radial * momentum_radial + mass * mass);
    probability = density_integrand_mass(
        energy, momentum_radial * momentum_radial, temperature);
  } while (random::uniform(0., probability_max) > probability);
 
  return momentum_radial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_momenta_1M_IC()

double smash::sample_momenta_1M_IC	(	const double	temperature,
		const double	mass
	)

Samples a momentum from the non-equilibrium distribution 1M_IC from Bazow:2016oky [10].

See also

density_integrand_1M_IC

Parameters

[in]	temperature	Temperature \(T\) [GeV]
[in]	mass	Mass of the particle: \(m = \sqrt{E^2 - p^2}\) [GeV]

Returns

one possible momentum between mass and 50 GeV

Definition at line 120 of file distributions.cc.

                                                                         {
  logg[LDistributions].debug("Sample momenta with mass ", mass, " and T ",
                             temperature);
  // Maxwell-Boltzmann average E <E>=3T + m * K_1(m/T) / K_2(m/T)
  double energy_average;
  if (mass > 0.) {
    // massive particles
    const double m_over_T = mass / temperature;
    energy_average = 3 * temperature + mass * gsl_sf_bessel_K1(m_over_T) /
                                           gsl_sf_bessel_Kn(2, m_over_T);
  } else {
    // massless particles
    energy_average = 3 * temperature;
  }
  const double momentum_average_sqr =
      (energy_average - mass) * (energy_average + mass);
  const double energy_min = mass;
  const double energy_max = 50. * temperature;
  /* 16 * the massless peak value to be well above maximum of the
   * distribution */
  const double probability_max =
      16. * density_integrand_1M_IC(energy_average, momentum_average_sqr,
                                    temperature);
 
  /* sample by rejection method: (see numerical recipes for more efficient)
   * random momenta and random probability need to be below the distribution */
  double momentum_radial_sqr, probability;
  do {
    double energy = random::uniform(energy_min, energy_max);
    momentum_radial_sqr = (energy - mass) * (energy + mass);
    probability =
        density_integrand_1M_IC(energy, momentum_radial_sqr, temperature);
  } while (random::uniform(0., probability_max) > probability);
 
  return std::sqrt(momentum_radial_sqr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_momenta_2M_IC()

double smash::sample_momenta_2M_IC	(	const double	temperature,
		const double	mass
	)

Samples a momentum from the non-equilibrium distribution 2M_IC from Bazow:2016oky [10].

See also

density_integrand_2M_IC

Parameters

[in]	temperature	Temperature \(T\) [GeV]
[in]	mass	Mass of the particle: \(m = \sqrt{E^2 - p^2}\) [GeV]

Returns

one possible momentum between mass and 50 GeV

Definition at line 157 of file distributions.cc.

                                                                         {
  logg[LDistributions].debug("Sample momenta with mass ", mass, " and T ",
                             temperature);
  /* Maxwell-Boltzmann average E <E>=3T + m * K_1(m/T) / K_2(m/T) */
  double energy_average;
  if (mass > 0.) {
    // massive particles
    const double m_over_T = mass / temperature;
    energy_average = 3 * temperature + mass * gsl_sf_bessel_K1(m_over_T) /
                                           gsl_sf_bessel_Kn(2, m_over_T);
  } else {
    // massless particles
    energy_average = 3 * temperature;
  }
  const double momentum_average_sqr =
      (energy_average - mass) * (energy_average + mass);
  const double energy_min = mass;
  const double energy_max = 50. * temperature;
  /* 16 * the massless peak value to be well above maximum of the
   * distribution */
  const double probability_max =
      16. * density_integrand_2M_IC(energy_average, momentum_average_sqr,
                                    temperature);
 
  /* sample by rejection method: (see numerical recipes for more efficient)
   * random momenta and random probability need to be below the distribution */
  double momentum_radial_sqr, probability;
  do {
    double energy = random::uniform(energy_min, energy_max);
    momentum_radial_sqr = (energy - mass) * (energy + mass);
    probability =
        density_integrand_2M_IC(energy, momentum_radial_sqr, temperature);
  } while (random::uniform(0., probability_max) > probability);
 
  return std::sqrt(momentum_radial_sqr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_momenta_from_thermal()

double smash::sample_momenta_from_thermal	(	const double	temperature,
		const double	mass
	)

Samples a momentum from the Maxwell-Boltzmann (thermal) distribution in a faster way, given by Scott Pratt (see Pratt:2014vja [51]) APPENDIX: ALGORITHM FOR GENERATING PARTICLES math trick: for \( x^{n-1}e^{-x} \) distribution, sample x by: \( x = -ln(r_1 r_2 r_3 ... r_n) \) where \( r_i \) are uniform random numbers between [0,1) for \( T/m > 0.6 \): \( p^2 e^{-E/T} = p^2 e^{-p/T} * e^{(p-E)/T} \), where \( e^{(p-E)/T}\) is used as rejection weight.

Since \(T/m > 0.6 \), \( e^{(p-E)/T}\) is close to 1. for \( T/m < 0.6 \), there are many rejections another manipulation is used: \( p^2 e^{-E/T} dp = dE \frac{E}{p} p^2 e^{-E/T} \) \( = dK \frac{p}{E} (K+m)^2 e^{-K/T} e^{-m/T} \) \( = dK (K^2 + 2mK + m^2) e^{-K/T} \frac{p}{E}\) where \( \frac{p}{E} \) is used as rejection weight.

Parameters

[in]	temperature	Temperature \(T\) [GeV]
[in]	mass	Mass of the particle: \(m = \sqrt{E^2 - p^2}\) [GeV]

Returns

one possible momentum

Definition at line 194 of file distributions.cc.

                                                      {
  logg[LDistributions].debug("Sample momenta with mass ", mass, " and T ",
                             temperature);
  double momentum_radial, energy;
  // when temperature/mass
  if (temperature > 0.6 * mass) {
    while (true) {
      const double a = -std::log(random::canonical_nonzero());
      const double b = -std::log(random::canonical_nonzero());
      const double c = -std::log(random::canonical_nonzero());
      momentum_radial = temperature * (a + b + c);
      energy = std::sqrt(momentum_radial * momentum_radial + mass * mass);
      if (random::canonical() <
          std::exp((momentum_radial - energy) / temperature)) {
        break;
      }
    }
  } else {
    while (true) {
      const double r0 = random::canonical();
      const double I1 = mass * mass;
      const double I2 = 2.0 * mass * temperature;
      const double I3 = 2.0 * temperature * temperature;
      const double Itot = I1 + I2 + I3;
      double K;
      if (r0 < I1 / Itot) {
        const double r1 = random::canonical_nonzero();
        K = -temperature * std::log(r1);
      } else if (r0 < (I1 + I2) / Itot) {
        const double r1 = random::canonical_nonzero();
        const double r2 = random::canonical_nonzero();
        K = -temperature * std::log(r1 * r2);
      } else {
        const double r1 = random::canonical_nonzero();
        const double r2 = random::canonical_nonzero();
        const double r3 = random::canonical_nonzero();
        K = -temperature * std::log(r1 * r2 * r3);
      }
      energy = K + mass;
      momentum_radial = std::sqrt((energy + mass) * (energy - mass));
      if (random::canonical() < momentum_radial / energy) {
        break;
      }
    }
  }
  return momentum_radial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_momenta_IC_ES()

double smash::sample_momenta_IC_ES

(

const double

temperature

)

Sample momenta according to the momentum distribution in Bazow:2016oky [10].

Parameters

[in]

temperature

The temperature for the distribution [GeV]

Returns

Radial momentum

Definition at line 243 of file distributions.cc.

                                                      {
  double momentum_radial;
  const double a = -std::log(random::canonical_nonzero());
  const double b = -std::log(random::canonical_nonzero());
  const double c = -std::log(random::canonical_nonzero());
  const double d = -std::log(random::canonical_nonzero());
  momentum_radial = (3.0 / 4.0) * temperature * (a + b + c + d);
 
  return momentum_radial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator+() [1/3]

EnergyMomentumTensor smash::operator+ ( EnergyMomentumTensor  a, const EnergyMomentumTensor &  b  )

inline

Direct addition operator.

Definition at line 162 of file energymomentumtensor.h.

                                                                     {
  a += b;
  return a;
}

operator-() [1/4]

EnergyMomentumTensor smash::operator- ( EnergyMomentumTensor  a, const EnergyMomentumTensor &  b  )

inline

Direct subtraction operator.

Definition at line 176 of file energymomentumtensor.h.

                                                                     {
  a -= b;
  return a;
}

operator*() [1/8]

EnergyMomentumTensor smash::operator* ( EnergyMomentumTensor  a, const double  b  )

inline

Direct multiplication operator.

Definition at line 189 of file energymomentumtensor.h.

                                                                              {
  a *= b;
  return a;
}

operator*() [2/8]

EnergyMomentumTensor smash::operator* ( const double  a, EnergyMomentumTensor  b  )

inline

Direct multiplication operator.

Definition at line 194 of file energymomentumtensor.h.

                                                                              {
  b *= a;
  return b;
}

operator/() [1/3]

EnergyMomentumTensor smash::operator/ ( EnergyMomentumTensor  a, const double  b  )

inline

Direct division operator.

Definition at line 206 of file energymomentumtensor.h.

                                                                              {
  a /= b;
  return a;
}

operator<<() [2/11]

template<typename Modus >

std::ostream & smash::operator<<	(	std::ostream &	out,
		const Experiment< Modus > &	e
	)

Creates a verbose textual description of the setup of the Experiment.

Writes the initial state for the Experiment to the output stream.

It automatically appends the output of the current Modus.

Definition at line 727 of file experiment.h.

                                                                    {
  out << "End time: " << e.end_time_ << " fm\n";
  out << e.modus_;
  return out;
}

create_experiment_parameters()

ExperimentParameters smash::create_experiment_parameters

(

Configuration &

config

)

Gathers all general Experiment parameters.

Parameters

[in,out]

config

Configuration element

Returns

The ExperimentParameters struct filled with values from the Configuration

The maximum around 200 mb occurs in the Delta peak of the pi+p cross section. Many SMASH cross sections diverge at the threshold, these divergent parts are effectively cut off. If deuteron production via d' is considered, then the default should be increased to 2000 mb to function correctly (see Oliinychenko:2018ugs [49]). If the cross sections are globally scaled, the maximum cross section is also scaled.

The maximum around 200 mb occurs in the Delta peak of the pi+p cross section. Many SMASH cross sections diverge at the threshold, these divergent parts are effectively cut off. If deuteron production via d' is considered, then the default should be increased to 2000 mb to function correctly (see Oliinychenko:2018ugs [49]). If the cross sections are globally scaled, the maximum cross section is also scaled.

Definition at line 135 of file experiment.cc.

                                                                         {
  logg[LExperiment].trace() << SMASH_SOURCE_LOCATION;
 
  const int ntest = config.take(InputKeys::gen_testparticles);
 
  // sets whether to consider only participants in thermodynamic outputs or not
  const bool only_participants =
      config.take(InputKeys::output_thermodynamics_onlyParticipants);
 
  const bool ignore_unformed =
      config.take(InputKeys::output_thermodynamics_ignoreUnformed);
 
  if (only_participants && config.has_section(InputSections::potentials)) {
    throw std::invalid_argument(
        "Only_Participants option cannot be "
        "set to True when using Potentials.");
  }
 
  const std::string modus_chooser = config.take(InputKeys::gen_modus);
  // remove config maps of unused Modi
  config.remove_all_entries_in_section_but_one(modus_chooser, {"Modi"});
 
  double box_length = -1.0;
  if (config.has_value(InputKeys::modi_box_length)) {
    box_length = config.read(InputKeys::modi_box_length);
  }
  if (config.has_value(InputKeys::modi_listBox_length)) {
    box_length = config.read(InputKeys::modi_listBox_length);
  }
 
  const double dt = config.take(InputKeys::gen_deltaTime);
  const double t_end = config.read(InputKeys::gen_endTime);
 
  // Enforce a small time step, if the box modus is used
  if (box_length > 0.0 && dt > box_length / 10.0) {
    throw std::invalid_argument(
        "Please decrease the timestep size. "
        "A value of (dt <= l_box / 10) is necessary in the box modus.");
  }
 
  // define output clock
  std::unique_ptr<Clock> output_clock = nullptr;
  if (config.has_value(InputKeys::output_outputTimes)) {
    if (config.has_value(InputKeys::output_outputInterval)) {
      throw std::invalid_argument(
          "Please specify either Output_Interval or Output_Times");
    }
    std::vector<double> output_times =
        config.take(InputKeys::output_outputTimes);
    // Add an output time larger than the end time so that the next time is
    // always defined during the time evolution
    output_times.push_back(t_end + 1.);
    output_clock = std::make_unique<CustomClock>(output_times);
  } else {
    const double output_dt =
        config.take(InputKeys::output_outputInterval, t_end);
    if (output_dt <= 0.) {
      throw std::invalid_argument(
          "Output_Interval cannot be zero or negative.");
    }
    output_clock = std::make_unique<UniformClock>(0.0, output_dt, t_end);
  }
 
  // Add proper error messages if photons are not configured properly.
  // 1) Missing Photon config section.
  if (config.has_section(InputSections::o_photons) &&
      (!config.has_section(InputSections::c_photons))) {
    throw std::invalid_argument(
        "Photon output is enabled although photon production is disabled. "
        "Photon production can be configured in the \"Photon\" subsection "
        "of the \"Collision_Term\".");
  }
 
  // 2) Missing Photon output section.
  if (!(config.has_section(InputSections::o_photons))) {
    const bool missing_output_2to2 =
                   config.read(InputKeys::collTerm_photons_twoToTwoScatterings),
               missing_output_brems =
                   config.read(InputKeys::collTerm_photons_bremsstrahlung);
    if (missing_output_2to2 || missing_output_brems) {
      throw std::invalid_argument(
          "Photon output is disabled although photon production is enabled. "
          "Please enable the photon output.");
    }
  }
 
  // Add proper error messages if dileptons are not configured properly.
  // 1) Missing Dilepton config section.
  if (config.has_section(InputSections::o_dileptons) &&
      (!config.has_section(InputSections::c_dileptons))) {
    throw std::invalid_argument(
        "Dilepton output is enabled although dilepton production is disabled. "
        "Dilepton production can be configured in the \"Dileptons\" subsection "
        "of the \"Collision_Term\".");
  }
 
  // 2) Missing Dilepton output section.
  if (!(config.has_section(InputSections::o_dileptons))) {
    const bool missing_output_decays =
        config.read(InputKeys::collTerm_dileptons_decays);
    if (missing_output_decays) {
      throw std::invalid_argument(
          "Dilepton output is disabled although dilepton production is "
          "enabled. Please enable the dilepton output.");
    }
  }
 
  /* Elastic collisions between the nucleons with the square root s
   * below low_snn_cut are excluded. */
  const double low_snn_cut =
      config.take(InputKeys::collTerm_elasticNNCutoffSqrts);
 
  const bool potential_affect_threshold =
      config.take(InputKeys::lattice_potentialsAffectThreshold);
  const double scale_xs = config.take(InputKeys::collTerm_crossSectionScaling);
 
  const auto criterion = config.take(InputKeys::collTerm_collisionCriterion);
 
  if (config.has_value(InputKeys::collTerm_fixedMinCellLength) &&
      criterion != CollisionCriterion::Stochastic) {
    throw std::invalid_argument(
        "Only use a fixed minimal cell length with the stochastic collision "
        "criterion.");
  }
  if (config.has_value(InputKeys::collTerm_maximumCrossSection) &&
      criterion == CollisionCriterion::Stochastic) {
    throw std::invalid_argument(
        "Only use maximum cross section with the geometric collision "
        "criterion. Use Fixed_Min_Cell_Length to change the grid size for the "
        "stochastic criterion.");
  }
 
  /**
   * The maximum around 200 mb occurs in the Delta peak of the pi+p
   * cross section. Many SMASH cross sections diverge at the threshold,
   * these divergent parts are effectively cut off. If deuteron production
   * via d' is considered, then the default should be increased to 2000 mb
   * to function correctly (see \iref{Oliinychenko:2018ugs}). If the cross
   * sections are globally scaled, the maximum cross section is also scaled.
   */
  const double maximum_cross_section_default =
      ParticleType::exists("d'") ? 2000.0 : 200.0;
 
  double maximum_cross_section = config.take(
      InputKeys::collTerm_maximumCrossSection, maximum_cross_section_default);
  maximum_cross_section *= scale_xs;
  return {std::make_unique<UniformClock>(0.0, dt, t_end),
          std::move(output_clock),
          config.take(InputKeys::gen_ensembles),
          ntest,
          config.take(InputKeys::gen_derivativesMode),
          config.has_section(InputSections::p_vdf)
              ? RestFrameDensityDerivativesMode::On
              : RestFrameDensityDerivativesMode::Off,
          config.take(InputKeys::gen_fieldDerivativesMode),
          config.take(InputKeys::gen_smearingMode),
          config.take(InputKeys::gen_smearingGaussianSigma),
          config.take(InputKeys::gen_smearingGaussCutoffInSigma),
          config.take(InputKeys::gen_smearingDiscreteWeight),
          config.take(InputKeys::gen_smearingTriangularRange),
          criterion,
          config.take(InputKeys::collTerm_twoToOne),
          config.take(InputKeys::collTerm_includedTwoToTwo),
          config.take(InputKeys::collTerm_charmRescatteringMethod),
          config.take(InputKeys::collTerm_multiParticleReactions),
          config.take(InputKeys::collTerm_strings, modus_chooser != "Box"),
          config.take(InputKeys::collTerm_resonanceLifetimeModifier),
          config.take(InputKeys::collTerm_nnbarTreatment),
          low_snn_cut,
          potential_affect_threshold,
          box_length,
          maximum_cross_section,
          config.take(InputKeys::collTerm_fixedMinCellLength),
          scale_xs,
          only_participants,
          ignore_unformed,
          config.take(InputKeys::collTerm_forceDecaysAtEnd),
          config.take(InputKeys::collTerm_ignoreDecayWidthAtTheEnd),
          config.take(InputKeys::collTerm_decayInitial),
          config.take(InputKeys::collTerm_dileptons_pion_form_factor),
          config.take(InputKeys::collTerm_spinInteractions)};
}

Here is the call graph for this function:

Here is the caller graph for this function:

hline()

const std::string smash::hline	(	113	,
		'-'
	)

String representing a horizontal line.

Here is the caller graph for this function:

format_measurements()

std::string smash::format_measurements	(	const std::vector< Particles > &	ensembles,
		uint64_t	scatterings_this_interval,
		const QuantumNumbers &	conserved_initial,
		SystemTimePoint	time_start,
		double	time,
		double	E_mean_field,
		double	E_mean_field_initial
	)

Generate a string which will be printed to the screen when SMASH is running.

Parameters

[in]	ensembles	The simulated particles: one Particles object per ensemble. The information about particles is used to check the conservation of the total energy and momentum as well as print other useful information.
[in]	scatterings_this_interval	Number of the scatterings occur within the current timestep.
[in]	conserved_initial	Initial quantum numbers needed to check the conservations.
[in]	time_start	Moment in the REAL WORLD when SMASH starts to run [s].
[in]	time	Current moment in SMASH [fm].
[in]	E_mean_field	Value of the mean-field contribution to the total energy of the system at the current time.
[in]	E_mean_field_initial	Value of the mean-field contribution to the total energy of the system at t=0.

Returns

'Current time in SMASH [fm]', 'Total kinetic energy in the system [GeV]', 'Total mean field energy in the system [GeV]', 'Total energy in the system [GeV]', 'Total energy per particle [GeV]', 'Deviation of the energy per particle from the initial value [GeV]', 'Number of scatterings that occurred within the timestep', 'Total particle number', 'Computing time consumed'.

Definition at line 318 of file experiment.cc.

                                                             {
  const SystemTimeSpan elapsed_seconds = SystemClock::now() - time_start;
 
  const QuantumNumbers current_values(ensembles);
  const QuantumNumbers difference = current_values - conserved_initial;
  int total_particles = 0;
  for (const Particles &particles : ensembles) {
    total_particles += particles.size();
  }
 
  // Make sure there are no FPEs in case of IC output, were there will
  // eventually be no more particles in the system
  const double current_energy = current_values.momentum().x0();
  const double energy_per_part =
      (total_particles > 0) ? (current_energy + E_mean_field) / total_particles
                            : 0.0;
 
  std::ostringstream ss;
  // clang-format off
  ss << field<7, 3> << time
    // total kinetic energy in the system
     << field<11, 3> << current_energy
    // total mean field energy in the system
     << field<11, 3> << E_mean_field
    // total energy in the system
     << field<12, 3> << current_energy + E_mean_field
    // total energy per particle in the system
     << field<12, 6> << energy_per_part;
    // change in total energy per particle (unless IC output is enabled)
    if (total_particles == 0) {
     ss << field<13, 6> << "N/A";
    } else {
     ss << field<13, 6> << (difference.momentum().x0()
                            + E_mean_field - E_mean_field_initial)
                            / total_particles;
    }
    ss << field<14, 3> << scatterings_this_interval
     << field<10, 3> << total_particles
     << field<9, 3> << elapsed_seconds;
  // clang-format on
  return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_mean_field_energy()

double smash::calculate_mean_field_energy	(	const Potentials &	potentials,
		RectangularLattice< smash::DensityOnLattice > &	jmu_B_lat,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	em_lattice,
		const ExperimentParameters &	parameters
	)

Calculate the total mean field energy of the system; this will be printed to the screen when SMASH is running.

Using the baryon density lattice is necessary.

Parameters

[in]	potentials	Parameters of the potentials used in the simulation.
[in]	jmu_B_lat	Lattice of baryon density and baryon current values as well as their gradients at each lattice node.
[in]	em_lattice	Lattice containing the electric and magnetic field in fm^-2
[in]	parameters	Parameters of the experiment, needed for the access to the number of testparticles.

Returns

Total mean field energy in the Box.

Definition at line 366 of file experiment.cc.

                                            {
  // basic parameters and variables
  const double V_cell = (jmuB_lat.cell_sizes())[0] *
                        (jmuB_lat.cell_sizes())[1] * (jmuB_lat.cell_sizes())[2];
 
  double E_mean_field = 0.0;
  double density_mean = 0.0;
  double density_variance = 0.0;
 
  /*
   * We anticipate having other options, like the vector DFT potentials, in the
   * future, hence we include checking which potentials are used.
   */
  if (potentials.use_skyrme()) {
    /*
     * Calculating the symmetry energy contribution to the total mean field
     * energy in the system is not implemented at this time.
     */
    if (potentials.use_symmetry() &&
        parameters.outputclock->current_time() == 0.0) {
      logg[LExperiment].warn()
          << "Note:"
          << "\nSymmetry energy is not included in the mean field calculation."
          << "\n\n";
    }
 
    /*
     * Skyrme potential parameters:
     * C1GeV are the Skyrme coefficients converted to GeV,
     * b1 are the powers of the baryon number density entering the expression
     * for the energy density of the system. Note that these exponents are
     * larger by 1 than those for the energy of a particle (which are used in
     * Potentials class). The formula for a total mean field energy due to a
     * Skyrme potential is E_MF = \sum_i (C_i/b_i) ( n_B^b_i )/( n_0^(b_i - 1) )
     * where nB is the local rest frame baryon number density and n_0 is the
     * saturation density. Then the single particle potential follows from
     * V = d E_MF / d n_B .
     */
    double C1GeV = (potentials.skyrme_a()) / 1000.0;
    double C2GeV = (potentials.skyrme_b()) / 1000.0;
    double b1 = 2.0;
    double b2 = (potentials.skyrme_tau()) + 1.0;
 
    /*
     * Note: calculating the mean field only works if lattice is used.
     * We iterate over the nodes of the baryon density lattice to sum their
     * contributions to the total mean field.
     */
    int number_of_nodes = 0;
    double lattice_mean_field_total = 0.0;
 
    for (auto &node : jmuB_lat) {
      number_of_nodes++;
      // the rest frame density
      double rhoB = node.rho();
      // the computational frame density
      const double j0B = node.jmu_net().x0();
 
      const double abs_rhoB = std::abs(rhoB);
      if (abs_rhoB < very_small_double) {
        continue;
      }
      density_mean += j0B;
      density_variance += j0B * j0B;
 
      /*
       * The mean-field energy for the Skyrme potential. Note: this expression
       * is only exact in the rest frame, and is expected to significantly
       * deviate from the correct value for systems that are considerably
       * relativistic. Note: symmetry energy is not taken into the account.
       *
       * TODO: Add symmetry energy.
       */
      double mean_field_contribution_1 = (C1GeV / b1) * std::pow(abs_rhoB, b1) /
                                         std::pow(nuclear_density, b1 - 1);
      double mean_field_contribution_2 = (C2GeV / b2) * std::pow(abs_rhoB, b2) /
                                         std::pow(nuclear_density, b2 - 1);
 
      lattice_mean_field_total +=
          V_cell * (mean_field_contribution_1 + mean_field_contribution_2);
    }
 
    // logging statistical properties of the density calculation
    density_mean = density_mean / number_of_nodes;
    density_variance = density_variance / number_of_nodes;
    double density_scaled_variance =
        std::sqrt(density_variance - density_mean * density_mean) /
        density_mean;
    logg[LExperiment].debug() << "\t\t\t\t\t";
    logg[LExperiment].debug()
        << "\n\t\t\t\t\t            density mean = " << density_mean;
    logg[LExperiment].debug()
        << "\n\t\t\t\t\t density scaled variance = " << density_scaled_variance;
    logg[LExperiment].debug()
        << "\n\t\t\t\t\t        total mean_field = "
        << lattice_mean_field_total * parameters.testparticles *
               parameters.n_ensembles
        << "\n";
 
    E_mean_field = lattice_mean_field_total;
  }  // if (potentials.use_skyrme())
 
  if (potentials.use_vdf()) {
    /*
     * Safety check:
     * Calculating the symmetry energy contribution to the total mean field
     * energy in the system is not implemented at this time.
     */
    if (potentials.use_symmetry() &&
        parameters.outputclock->current_time() == 0.0) {
      logg[LExperiment].error()
          << "\nSymmetry energy is not included in the VDF mean-field "
             "calculation"
          << "\nas VDF potentials haven't been fitted with symmetry energy."
          << "\n\n";
    }
 
    /*
     * The total mean-field energy density due to a VDF potential is
     * E_MF = \sum_i C_i rho^(b_i - 2) *
     *                 * [j_0^2 -  rho^2 * (b_i - 1)/b_i] / rho_0^(b_i - 1)
     * where j_0 is the local computational frame baryon density, rho is the
     * local rest frame baryon density, and rho_0 is the saturation density.
     */
 
    // saturation density of nuclear matter specified in the VDF parameters
    double rhoB_0 = potentials.saturation_density();
 
    /*
     * Note: calculating the mean field only works if lattice is used.
     * We iterate over the nodes of the baryon density lattice to sum their
     * contributions to the total mean field.
     */
    int number_of_nodes = 0;
    double lattice_mean_field_total = 0.0;
 
    for (auto &node : jmuB_lat) {
      number_of_nodes++;
      // the rest frame density
      double rhoB = node.rho();
      // the computational frame density
      const double j0B = node.jmu_net().x0();
      double abs_rhoB = std::abs(rhoB);
      density_mean += j0B;
      density_variance += j0B * j0B;
 
      /*
       * The mean-field energy for the VDF potential. This expression is correct
       * in any frame, and in the rest frame conforms to the Skyrme mean-field
       * energy (if same coefficients and powers are used).
       */
      // in order to prevent dividing by zero in case any b_i < 2.0
      if (abs_rhoB < very_small_double) {
        abs_rhoB = very_small_double;
      }
      double mean_field_contribution = 0.0;
      for (int i = 0; i < potentials.number_of_terms(); i++) {
        mean_field_contribution +=
            potentials.coeffs()[i] *
            std::pow(abs_rhoB, potentials.powers()[i] - 2.0) *
            (j0B * j0B -
             ((potentials.powers()[i] - 1.0) / potentials.powers()[i]) *
                 abs_rhoB * abs_rhoB) /
            std::pow(rhoB_0, potentials.powers()[i] - 1.0);
      }
      lattice_mean_field_total += V_cell * mean_field_contribution;
    }
 
    // logging statistical properties of the density calculation
    density_mean = density_mean / number_of_nodes;
    density_variance = density_variance / number_of_nodes;
    double density_scaled_variance =
        std::sqrt(density_variance - density_mean * density_mean) /
        density_mean;
    logg[LExperiment].debug() << "\t\t\t\t\t";
    logg[LExperiment].debug()
        << "\n\t\t\t\t\t            density mean = " << density_mean;
    logg[LExperiment].debug()
        << "\n\t\t\t\t\t density scaled variance = " << density_scaled_variance;
    logg[LExperiment].debug()
        << "\n\t\t\t\t\t        total mean_field = "
        << lattice_mean_field_total * parameters.testparticles *
               parameters.n_ensembles
        << "\n";
 
    E_mean_field = lattice_mean_field_total;
  }
 
  double electromagnetic_potential = 0.0;
  if (potentials.use_coulomb() && em_lattice) {
    // Use cell volume of electromagnetic fields lattice even though it should
    // be the same as for net-baryon density
    double V_cell_em = em_lattice->cell_sizes()[0] *
                       em_lattice->cell_sizes()[1] *
                       em_lattice->cell_sizes()[2];
    for (auto &fields : *em_lattice) {
      // Energy is 0.5 * int E^2 + B^2 dV
      electromagnetic_potential +=
          hbarc * 0.5 * V_cell_em * (fields.first.sqr() + fields.second.sqr());
    }
  }
  logg[LExperiment].debug() << "Total energy in electromagnetic field  = "
                            << electromagnetic_potential;
  E_mean_field += electromagnetic_potential;
  /*
   * E_mean_field is multiplied by the number of testparticles per particle and
   * the number of parallel ensembles because the total kinetic energy tracked
   * is that of all particles in the simulation, including test-particles and/or
   * ensembles, and so this way is more consistent.
   */
  E_mean_field =
      E_mean_field * parameters.testparticles * parameters.n_ensembles;
 
  return E_mean_field;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_event_info()

EventInfo smash::fill_event_info	(	const std::vector< Particles > &	ensembles,
		double	E_mean_field,
		double	modus_impact_parameter,
		const ExperimentParameters &	parameters,
		bool	projectile_target_interact,
		bool	kinematic_cut_for_SMASH_IC
	)

Generate the EventInfo object which is passed to outputs_.

Parameters

[in]	ensembles	The simulated particles: one Particles object per ensemble. Information about all particles (positions, momenta, etc.)is passed to the output.
[in]	E_mean_field	Value of the mean-field contribution to the total energy of the system at the current time.
[in]	modus_impact_parameter	The impact parameter
[in]	parameters	structure that holds various global parameters such as testparticle number, see ExperimentParameters
[in]	projectile_target_interact	true if there was at least one collision
[in]	kinematic_cut_for_SMASH_IC	true if kinematic cuts in y or pT are enabled when exracting initial conditions for hydrodynamics

Definition at line 586 of file experiment.cc.

                                                           {
  const QuantumNumbers current_values(ensembles);
  const double E_kinetic_total = current_values.momentum().x0();
  const double E_total = E_kinetic_total + E_mean_field;
 
  EventInfo event_info{modus_impact_parameter,
                       parameters.box_length,
                       parameters.outputclock->current_time(),
                       E_kinetic_total,
                       E_mean_field,
                       E_total,
                       parameters.testparticles,
                       parameters.n_ensembles,
                       !projectile_target_interact,
                       kinematic_cut_for_SMASH_IC};
  return event_info;
}

Here is the call graph for this function:

Here is the caller graph for this function:

validate_and_adjust_particle_list()

void smash::validate_and_adjust_particle_list

(

ParticleList &

particle_list

)

Validate a particle list adjusting each particle to be a valid SMASH particle.

If the provided particle has an invalid PDG code, it is removed from the list and the user warned. If the particles in the list are adjusted, the function warns the user only the first time this function is called.

See also

create_valid_smash_particle_matching_provided_quantities for more information about which adjustements are made to the particles.

Parameters

[in]

particle_list

The particle list which should be adjusted

Definition at line 608 of file experiment.cc.

                                                                    {
  static bool warn_mass_discrepancy = true;
  static bool warn_off_shell_particle = true;
  for (auto it = particle_list.begin(); it != particle_list.end();) {
    auto &particle = *it;
    auto pdgcode = particle.pdgcode();
    try {
      // Convert Kaon-L or Kaon-S into K0 or Anti-K0 used in SMASH
      if (pdgcode == 0x310 || pdgcode == 0x130) {
        pdgcode = (random::uniform_int(0, 1) == 0) ? pdg::K_z : pdg::Kbar_z;
      }
      /* ATTENTION: It would be wrong to directly assign here the return value
       * to 'particle', because this would potentially also change its id and
       * process number, which in turn, might lead to actions to be discarded.
       * Here, only the particle momentum has to be adjusted and this is done
       * creating a new particle and using its momentum to set 'particle' one.
       * The position and momentum of the particle are checked for nan values.
       */
      auto valid_smash_particle =
          create_valid_smash_particle_matching_provided_quantities(
              pdgcode, particle.effective_mass(), particle.position(),
              particle.momentum(), LExperiment, warn_mass_discrepancy,
              warn_off_shell_particle);
      particle.set_4position(valid_smash_particle.position());
      particle.set_4momentum(valid_smash_particle.momentum());
      particle.set_cross_section_scaling_factor(
          valid_smash_particle.xsec_scaling_factor());
      it++;
    } catch (ParticleType::PdgNotFoundFailure &) {
      logg[LExperiment].warn()
          << "SMASH does not recognize pdg code " << pdgcode
          << " obtained from hadron list. This particle will be ignored.\n";
      it = particle_list.erase(it);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_interactions_total()

void smash::check_interactions_total ( uint64_t  interactions_total )

inline

Make sure interactions_total can be represented as a 32-bit integer.

This is necessary for converting to a id_process. The latter is 32-bit integer, because it is written like this to binary output.

Parameters

[in]

interactions_total

Total interaction number

Definition at line 2757 of file experiment.h.

                                                                  {
  constexpr uint64_t max_uint32 = std::numeric_limits<uint32_t>::max();
  if (interactions_total >= max_uint32) {
    throw std::runtime_error("Integer overflow in total interaction number!");
  }
}

Here is the caller graph for this function:

update_fields_lattice()

void smash::update_fields_lattice	(	RectangularLattice< FieldsOnLattice > *	fields_lat,
		RectangularLattice< FourVector > *	old_fields,
		RectangularLattice< FourVector > *	new_fields,
		RectangularLattice< std::array< FourVector, 4 >> *	fields_four_grad_lattice,
		DensityLattice *	jmu_B_lat,
		const LatticeUpdate	fields_lat_update,
		const Potentials &	potentials,
		const double	time_step
	)

Updates the contents on the lattice of FieldsOnLattice type.

Parameters

[out]	fields_lat	The lattice of FieldsOnLattice type on which the content will be updated
[in]	old_fields	Auxiliary lattice, filled with field values at t0, needed for calculating time derivatives
[in]	new_fields	Auxiliary lattice, filled with field values at t0 + dt, needed for calculating time derivatives
[in]	fields_four_grad_lattice	Auxiliary lattice for calculating the fourgradient of the fields
[in]	jmu_B_lat	Lattice of baryon four-current
[in]	fields_lat_update	Tells if called for update at printout or at timestep
[in]	potentials	mean-field potentials used in the simulation
[in]	time_step	Time step used in the simulation

Definition at line 14 of file fields.cc.

                                                          {
  // Do not proceed if lattice does not exists/update not required
  if (fields_lat == nullptr || fields_lat->when_update() != fields_lat_update) {
    return;
  }
  // get the number of nodes on the fields lattice
  const std::array<int, 3> lattice_n_cells = fields_lat->n_cells();
  const int number_of_nodes =
      lattice_n_cells[0] * lattice_n_cells[1] * lattice_n_cells[2];
 
  /*
   * Take the provided FieldsOnLattice lattice, fields_lat, and use the
   * information about the fields to populate the lattice of A^mu FourVectors at
   * t0, old_fields.
   */
  for (int i = 0; i < number_of_nodes; i++) {
    old_fields->assign_value(i, ((*fields_lat)[i]).A_mu());
  }
 
  /*
   * Update the fields lattice
   */
  fields_lat->reset();
 
  // Get the potential parameters
  const double rhoB_0 = potentials.saturation_density();
 
  // update the fields lattice
  for (int i = 0; i < number_of_nodes; i++) {
    // read values off the jmu_B lattice (which holds values at t0 + Delta t)
    double rhoB_at_i = ((*jmuB_lat)[i]).rho();
    FourVector jmuB_at_i = ((*jmuB_lat)[i]).jmu_net();
 
    double abs_rhoB_at_i = std::abs(rhoB_at_i);
    // this is to prevent nan expressions
    if (abs_rhoB_at_i < very_small_double) {
      abs_rhoB_at_i = very_small_double;
    }
 
    // this needs to be used in order to prevent trying to calculate something
    // an expression like (-rhoB)^{3.4}
    const int sgn = rhoB_at_i > 0 ? 1 : -1;
 
    // field contributions as obtained in the VDF model
    double field_contribution = 0.0;
    for (int j = 0; j < potentials.number_of_terms(); j++) {
      field_contribution +=
          sgn * potentials.coeffs()[j] *
          std::pow(abs_rhoB_at_i / rhoB_0, potentials.powers()[j] - 2.0) /
          rhoB_0;
    }
    FourVector field_at_i = field_contribution * jmuB_at_i;
 
    // fill the A_mu lattice
    ((*fields_lat)[i]).overwrite_A_mu(field_at_i);
  }
 
  /*
   * Use the updated fields lattice, fields_lat, to populate the lattice of A^mu
   * FourVectors at t0 + Delta t, new_fields.
   */
  for (int i = 0; i < number_of_nodes; i++) {
    new_fields->assign_value(i, ((*fields_lat)[i]).A_mu());
  }
 
  /*
   * Compute time derivatives and gradients of all components of A^mu
   */
  new_fields->compute_four_gradient_lattice(*old_fields, time_step,
                                            *fields_four_grad_lattice);
 
  // substitute new derivatives
  for (int i = 0; i < number_of_nodes; i++) {
    auto tmp = (*fields_four_grad_lattice)[i];
    ((*fields_lat)[i]).overwrite_dAmu_dxnu(tmp[0], tmp[1], tmp[2], tmp[3]);
  }
}  // void update_fields_lattice()

Here is the call graph for this function:

Here is the caller graph for this function:

fopen()

FilePtr smash::fopen	(	const std::filesystem::path &	filename,
		const std::string &	mode
	)

Open a file with given mode.

This wraps std::fopen but uses FileDeleter to automatically close the file.

Parameters

[in]	filename	Path to the file.
[in]	mode	The mode in which the file should be opened (see std::fopen).

Returns

The constructed FilePtr.

Definition at line 14 of file file.cc.

                                                                        {
  FilePtr f{std::fopen(filename.c_str(), mode.c_str())};
  return f;
}

Here is the caller graph for this function:

blatt_weisskopf_sqr()

double smash::blatt_weisskopf_sqr ( const double  p_ab, const int  L  )

inline

Returns

the squared Blatt-Weisskopf functions, which influence the mass dependence of the decay widths. See e.g. Effenberger:1999wlg [24], page 28 and https://physique.cuso.ch/fileadmin/physique/document/2015_chung_brfactor1.pdf where the recursive formula used here is given.

Parameters

p_ab	Momentum of outgoing particles A and B in center-of-mass frame [GeV]
L	Angular momentum of outgoing particles A and B.

This is used as a standard form factor for all hadronic decays. Note that all the Blatt-Weisskopf functions approach one for large p_ab and behave like p_ab**L for small p_ab. They are increasing monotonically with p_ab.

Definition at line 36 of file formfactors.h.

                                                                  {
  if (L == 0) {
    return 1.;
  }
  constexpr double R = 1. / hbarc; /* interaction radius = 1 fm */
  const double x = p_ab * R;
  const double x2 = x * x;
  if (L == 1) {
    return x2 / (1. + x2);
  }
  std::complex<double> g_prevprev(1, 0);
  std::complex<double> g_prev(1, -x);
  double numer = x2;
  for (int l = 1; l < L; l++) {
    numer *= x2;
    const auto new_g =
        static_cast<double>(2 * l + 1) * g_prev - x2 * g_prevprev;
    g_prevprev = g_prev;
    g_prev = new_g;
  }
  const double denom = std::norm(g_prev);
  return numer / denom;
}

Here is the caller graph for this function:

post_ff_sqr()

double smash::post_ff_sqr ( double  m, double  M0, double  srts0, double  L  )

inline

An additional form factor for unstable final states as used in GiBUU, according to M.

Post, see eq. (174) in Buss:2011mx [16] or eq. (13) in Post:2003hu [50].

Parameters

m	Actual mass of the decaying resonance [GeV].
M0	Pole mass of the decaying resonance [GeV].
srts0	Threshold of the reaction, i.e. minimum possible sqrt(s) [GeV].
L	Lambda parameter of the form factor [GeV]. This is a cut-off parameter that can be different for baryons and mesons.

Returns

The squared value of the form factor (dimensionless).

This form factor is equal to one at m=M0 and m=srts0. For decreasing values of L, the form factor results in a stronger and stronger suppression of the high-mass tail (m > M0) and a corresponding enhancement of the low-mass tail (m < M0).

Definition at line 78 of file formfactors.h.

                                                                       {
  const auto L4 = L * L * L * L;
  const auto M2 = M0 * M0;
  const auto s0 = srts0 * srts0;
  const auto sminus = (s0 - M2) * 0.5;
  const auto splus = m * m - (s0 + M2) * 0.5;
  const auto FF = (L4 + sminus * sminus) / (L4 + splus * splus);
  return FF * FF;
}

Here is the caller graph for this function:

em_form_factor_ps()

double smash::em_form_factor_ps ( PdgCode  pdg, double  mass  )

inline

Returns

Electromagnetic transition form factor for P → γ e⁺ e⁻, with a pseudoscalar meson P = π⁰,η,η', as a function of the dilepton mass.

For the π⁰ see Landsberg:1985gaz [38]. For the η the Lambda parameter is fitted to NA60 data, see NA60:2009una [6].

Parameters

pdg	PDG code of the decaying meson.
mass	Invariant dilepton mass [GeV].

Definition at line 100 of file formfactors.h.

                                                          {
  switch (pdg.code()) {
    case pdg::pi_z:
      return 1. + 5.5 * mass * mass;
    case pdg::eta: {
      const double lambda_eta = 0.716;
      const double m_over_eta = mass / lambda_eta;
      return 1. / (1. - m_over_eta * m_over_eta);
    }
    default:      /* η' etc */
      return 1.;  // use QED approximation
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

em_form_factor_sqr_vec()

double smash::em_form_factor_sqr_vec ( PdgCode  pdg, double  mass  )

inline

Returns

Squared electromagnetic transition form factor for V → π⁰ e⁺ e⁻, with a vector meson V = ω,φ, as a function of the dilepton mass.

For the ω, see Bratkovskaya:1996qe [14].

Parameters

pdg	PDG code of the decaying meson.
mass	Invariant dilepton mass [GeV].

Definition at line 123 of file formfactors.h.

                                                               {
  switch (pdg.code()) {
    case pdg::omega: {
      constexpr double lambda = 0.65;
      constexpr double gamma = 0.075;
      constexpr double lambda_sqr = lambda * lambda;
      constexpr double gamma_sqr = gamma * gamma;
      const double tmp = lambda_sqr - mass * mass;
      const double denom = tmp * tmp + lambda_sqr * gamma_sqr;
      return lambda_sqr * lambda_sqr / denom;
    }
    default:      /* φ etc */
      return 1.;  // use QED approximation
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

form_factor_delta()

double smash::form_factor_delta ( [[maybe_unused] ] double  m )

inline

Returns

Electromagnetic transition form factor for Delta -> N e+ e- as a function of the dilepton mass m.

Parameters

m	Invariant dilepton mass [GeV].

Currently assumed to be constant, normalized at the real-photon point.

Definition at line 147 of file formfactors.h.

{ return 3.12; }

Here is the caller graph for this function:

pion_em_form_factor_sqr_FF1()

double smash::pion_em_form_factor_sqr_FF1 ( double  m_inv_sqr, double  m_rho, double  gamma_rho  )

inline

Returns

Squared pion electromagnetic form factor \(|F_\pi(m_{inv}^2)|^2\) for the internal pion propagator in \( pn \rightarrow pn e^+ e^- \) bremsstrahlung.

FF1: pure vector-meson dominance, direct \(\rho^0\) coupling

Parameters

m_inv_sqr	Invariant dilepton mass squared m_{inv}^2 [GeV²]
m_rho	\(\rho^0\) pole mass [GeV]
gamma_rho	Energy-dependent \(\rho^0\) width [GeV]

Definition at line 160 of file formfactors.h.

                                                            {
  assert(gamma_rho >= 0.0);
  const double m_rho_sq = m_rho * m_rho;
  const std::complex<double> denom(m_rho_sq - m_inv_sqr, -m_rho * gamma_rho);
  return std::norm(m_rho_sq / denom);
}

Here is the caller graph for this function:

pion_em_form_factor_sqr_FF2()

double smash::pion_em_form_factor_sqr_FF2 ( double  m_inv_sqr, double  m_rho, double  gamma_rho  )

inline

Returns

Squared pion electromagnetic form factor \(|F_\pi(m_{inv}^2)|^2\) for the internal pion propagator in \( pn \rightarrow pn e^+ e^- \) bremsstrahlung.

FF2: mixed direct-quark + \(\rho^0\) coupling (Shyam:2010vr [58], FF2)

Parameters

m_inv_sqr	Invariant dilepton mass squared m_{inv}^2 [GeV²]
m_rho	\(\rho^0\) pole mass [GeV]
gamma_rho	Energy-dependent \(\rho^0\) width [GeV]

Definition at line 179 of file formfactors.h.

                                                            {
  assert(gamma_rho >= 0.0);
  // Lambda² constant (\iref{Shyam:2010vr}, FF2) in GeV².
  constexpr double lambda_sq_FF2 = 1.9;
  const double m_rho_sq = m_rho * m_rho;
  const std::complex<double> denom(m_rho_sq - m_inv_sqr, -m_rho * gamma_rho);
  const std::complex<double> F =
      0.4 / (1.0 - m_inv_sqr / lambda_sq_FF2) +
      0.6 / (1.0 - m_inv_sqr / (2 * m_rho_sq)) * m_rho_sq / denom;
  return std::norm(F);
}

Here is the caller graph for this function:

operator+() [2/3]

FourVector smash::operator+ ( FourVector  a, const FourVector &  b  )

inline

add two FourVectors

Parameters

[in]	a	The first FourVector to add
[in]	b	The second FourVector to add

Returns

\(x^\mu = a^\mu + b^\mu\)

Definition at line 376 of file fourvector.h.

                                                               {
  a += b;
  return a;
}

operator-() [2/4]

FourVector smash::operator- ( FourVector  a, const FourVector &  b  )

inline

subtract two FourVectors

Parameters

[in]	a	The FourVector from which to subtract
[in]	b	The FourVector to subtract

Returns

\(x^\mu = a^\mu - b^\mu\)

Definition at line 397 of file fourvector.h.

                                                               {
  a -= b;
  return a;
}

operator*() [3/8]

FourVector smash::operator* ( FourVector  a, double  b  )

inline

multiply a vector with a scalar

Parameters

[in]	a	The FourVector to multiply
[in]	b	The value with which to multiply

Returns

\(x^\mu = b \cdot a^\mu\)

Definition at line 418 of file fourvector.h.

                                                    {
  a *= b;
  return a;
}

operator*() [4/8]

FourVector smash::operator* ( double  b, FourVector  a  )

inline

multiply a vector with a scalar

Parameters

[in]	b	The value with which to multiply
[in]	a	The FourVector to multiply

Returns

\(x^\mu = b \cdot a^\mu\)

Definition at line 429 of file fourvector.h.

                                                    {
  a *= b;
  return a;
}

operator/() [2/3]

FourVector smash::operator/ ( FourVector  a, const double &  b  )

inline

divide a vector by a scalar

Parameters

[in]	a	The FourVector to divide
[in]	b	The value with which to divide

Returns

\(x^\mu = \frac{1}{b} \cdot a^\mu\)

Definition at line 451 of file fourvector.h.

                                                           {
  a /= b;
  return a;
}

enable_float_traps()

bool smash::enable_float_traps ( int  )

inline

Fallback that fails to set the trap.

Definition at line 40 of file fpenvironment.h.

{ return false; }

Here is the caller graph for this function:

setup_default_float_traps()

void smash::setup_default_float_traps

(

)

Setup the floating-point traps used throughout SMASH.

If possible, this function additionally installs a signal handler that prints what kind of condition triggered the trap. This requires POSIX.1-2001 to work.

Definition at line 69 of file fpenvironment.cc.

                                 {
  {
    // pole error occurred in a floating-point operation:
    if (!enable_float_traps(FE_DIVBYZERO)) {
      logg[LFpe].warn("Failed to setup trap on pole error.");
    }
 
    // domain error occurred in an earlier floating-point operation:
    if (!enable_float_traps(FE_INVALID)) {
      logg[LFpe].warn("Failed to setup trap on domain error.");
    }
 
    /* The result of the earlier floating-point operation was too large to be
     * representable: */
    if (!enable_float_traps(FE_OVERFLOW)) {
      logg[LFpe].warn("Failed to setup trap on overflow.");
    }
 
    /* There's also FE_UNDERFLOW, where the result of the earlier
     * floating-point operation was subnormal with a loss of precision.
     * We do not consider this an error by default.
     * Furthermore, there's FE_INEXACT, but this traps if "rounding was
     * necessary to store the result of an earlier floating-point
     * operation". This is common and not really an error condition. */
  }
 
// Install the signal handler if we have the functionality.
#if (defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 199309L) || \
    (defined _XOPEN_SOURCE && _XOPEN_SOURCE) ||                \
    (defined _POSIX_SOURCE && _POSIX_SOURCE)
/* The missing-fields-initializers warning says that not all fields of this
 * struct were explicitly initialized. That's exactly what is the intention
 * here, because then they are default-initialized, which is zero. */
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
  struct sigaction action = {};
  action.sa_flags = SA_SIGINFO;
  action.sa_sigaction = [](int signal, siginfo_t *info, void *) {
    if (signal == SIGFPE) {
      const char *msg = nullptr;
      switch (info->si_code) {
        case FPE_FLTDIV:
          msg = "Division by Zero (NaN)";
          break;
        case FPE_FLTUND:
          msg = "Underflow (result was subnormal with a loss of precision)";
          break;
        case FPE_FLTOVF:
          msg = "Overflow (result was too large to be representable)";
          break;
        case FPE_FLTINV:
          msg = "Invalid (domain error occurred)";
          break;
        case FPE_FLTRES:
          msg =
              "Inexact Result (rounding was necessary to store the result of "
              "an earlier floating-point operation)";
          break;
        default:
          msg = "unknown";
          break;
      }
      logg[LFpe].fatal(SMASH_SOURCE_LOCATION,
                       "Floating point trap was raised: ", msg);
    } else {
      logg[LFpe].fatal(SMASH_SOURCE_LOCATION, "Unexpected Signal ", signal,
                       " received in the FPE signal handler. Aborting.");
    }
    std::abort();
  };
  sigaction(SIGFPE, &action, nullptr);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

without_float_traps()

template<typename F >

void smash::without_float_traps

(

F &&

f

)

Convenience function to create a scope where all floating point traps are disabled.

Example:

// some code where FPEs will trap
without_float_traps([&] {
  // all code up to the closing brace will not trap anymore.
});
// more code where FPEs will trap

Parameters

f	A functor (e.g. lambda) that is executed in the cleared floating point environment.

Template Parameters

F	type of the functor

Definition at line 129 of file fpenvironment.h.

                                {
  DisableFloatTraps guard;
  f();
}

operator<<() [3/11]

std::ostream & smash::operator<<	(	std::ostream &	s,
		const ThermLatticeNode &	node
	)

This operator writes all the thermodynamic quantities at a certain position to the file out.

Parameters

[in]	s	location of the output
[in]	node	position on the lattice, where the output is generated

Definition at line 97 of file grandcan_thermalizer.cc.

                                                                      {
  return out << "T[mu,0]: " << node.Tmu0() << ", nb: " << node.nb()
             << ", ns: " << node.ns() << ", v: " << node.v()
             << ", e: " << node.e() << ", p: " << node.p()
             << ", T: " << node.T() << ", mub: " << node.mub()
             << ", mus: " << node.mus() << ", muq: " << node.muq();
}

Here is the call graph for this function:

build_error_string()

std::string smash::build_error_string ( std::string  message, const Line &  line  )

inline

Builds a meaningful error message.

Takes the message and quotes the Line where the error occurs

Parameters

[in]	message	Error message
[in]	line	Line object containing line number and line content.

Definition at line 42 of file inputfunctions.h.

                                                                         {
  return message + " (on line " + std::to_string(line.number) + ": \"" +
         line.text + "\")";
}

Here is the call graph for this function:

Here is the caller graph for this function:

line_parser()

std::vector< Line > smash::line_parser

(

const std::string &

input

)

Helper function for parsing particles.txt and decaymodes.txt.

This function goes through an input stream line by line and removes comments and empty lines. The remaining lines will be returned as a vector of strings and linenumber pairs (Line).

Parameters

[in]

input

an lvalue reference to an input stream

Definition at line 21 of file inputfunctions.cc.

                                                    {
  logg[LInputParser].trace() << SMASH_SOURCE_LOCATION << input;
  std::istringstream input_stream(input);
  std::vector<Line> lines;
  lines.reserve(50);
 
  std::string line;
  int line_number = 0;
  while (std::getline(input_stream, line)) {
    ++line_number;
    const auto hash_pos = line.find('#');
    if (hash_pos != std::string::npos) {
      // Found a comment, remove it from the line and look further
      line = line.substr(0, hash_pos);
    }
    if (line.find_first_not_of(" \t") == std::string::npos) {
      // Only whitespace (or nothing) on this line. Next, please.
      continue;
    }
    line = trim(line);
    lines.emplace_back(line_number, std::move(line));
    line = std::string();
  }
  return lines;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_all_read()

void smash::ensure_all_read ( std::istream &  input, const Line &  line  )

inline

Makes sure that nothing is left to read from this line.

Definition at line 59 of file inputfunctions.h.

                                                                 { /*{{{*/
  std::string tmp;
  input >> tmp;
  if (!input.eof()) {
    throw ParticleType::LoadFailure(
        build_error_string("While loading the Particle data:\nGarbage (" + tmp +
                               ") at the remainder of the line.",
                           line));
  }
} /*}}}*/

Here is the call graph for this function:

Here is the caller graph for this function:

read_all()

std::string smash::read_all ( std::istream &&  input )

inline

Utility function to read a complete input stream (e.g.

file) into one string.

Parameters

[in]

input

The input stream. Since it reads until EOF und thus "uses up the whole input stream" the function takes an rvalue reference to the stream object (just pass a temporary).

Note

There's no slicing here: the actual istream object is a temporary that is not destroyed until read_all returns.

Warning

The GNU compiler reports false positive warnings here because of this bug and therefore we temporary manually disable that diagnostic.

Definition at line 88 of file inputfunctions.h.

                                              {
  return {std::istreambuf_iterator<char>{input},
          std::istreambuf_iterator<char>{}};
}

Here is the caller graph for this function:

has_crlf_line_ending()

bool smash::has_crlf_line_ending ( const std::string  in )

inline

Check if a line in the string ends with \r\n.

This may happen when a file was edited on Windows.

Parameters

[in]

in

Input string

Returns

True if \r\n was found, else false

Definition at line 102 of file inputfunctions.h.

                                                     {
  if (in.find("\r\n") != std::string::npos) {
    return true;
  }
  return false;
}

Here is the caller graph for this function:

generate_sort_permutation()

template<typename T , typename Cmp >

Permutation smash::generate_sort_permutation	(	std::vector< T > const &	v,
		Cmp	compare
	)

Calculate the permutations necessary for sorting a vector.

Template Parameters

Cmp	Type of comparison function.

Parameters

v	Vector to be sorted.
compare	Comparison function (see std::sort).

Returns

Vector of indices into the original vector.

Definition at line 138 of file interpolation.h.

                                                                          {
  Permutation p(v.size());
  std::iota(p.begin(), p.end(), 0);
  std::sort(p.begin(), p.end(),
            [&](size_t i, size_t j) { return compare(v[i], v[j]); });
  return p;
}

Here is the caller graph for this function:

apply_permutation()

template<typename T >

std::vector<T> smash::apply_permutation	(	const std::vector< T > &	v,
		const Permutation &	p
	)

Apply a permutation to a vector.

Template Parameters

T	Type of values to be permuted.

Parameters

v	Vector to be permuted.
p	Permutation to be applied.

Returns

Permuted vector.

Definition at line 155 of file interpolation.h.

                                                       {
  std::vector<T> copied_v = v;
  std::transform(p.begin(), p.end(), copied_v.begin(),
                 [&](size_t i) { return v[i]; });
  return copied_v;
}

Here is the caller graph for this function:

check_duplicates()

template<typename T >

void smash::check_duplicates	(	const std::vector< T > &	x,
		const std::string &	error_position
	)

Check whether two components have the same value in a sorted vector x.

Template Parameters

T	Type of values to be checked for duplicates.

Parameters

x	Vector to be checked for duplicates.
error_position	String used in the error message, indicating where the error originated.

Exceptions

std::runtime_error

if duplicates are encountered.

Definition at line 174 of file interpolation.h.

                                                       {
  auto it = std::adjacent_find(x.begin(), x.end());
  if (it != x.end()) {
    std::stringstream error_msg{};
    error_msg << error_position << ": Each x value must be unique. \"" << *it
              << "\" was found twice.";
    throw std::runtime_error(error_msg.str());
  }
}

Here is the caller graph for this function:

find_index()

template<typename T >

size_t smash::find_index	(	const std::vector< T > &	v,
		T	x
	)

Find the index in v that corresponds to the last value strictly smaller than x.

If no such value exists, the first value is returned.

This assumes v is sorted and uses a binary search.

Template Parameters

T	Type of values to be compared to x.

Parameters

v	Vector to be searched.
x	Upper bound for indexed value.

Returns

Largest index corresponding to value below upper bound.

Example:

std::vector<int> x = { 0, 2, 4, 6, 8, 10 }; find_index(x, 2)

0

find_index(x, 3)

1

Definition at line 237 of file interpolation.h.

                                              {
  const auto it = std::lower_bound(v.begin(), v.end(), x);
  if (it == v.begin()) {
    return 0;
  } else {
    return it - 1 - v.begin();
  }
}

Here is the caller graph for this function:

center_of_velocity_v()

double smash::center_of_velocity_v ( double  s, double  ma, double  mb  )

inline

Returns

Velocity in the center of velocities frame of two particles given their Mandelstam s and masses

Parameters

[in]	s	Mandelstam s of the collision [GeV^2]
[in]	ma	Mass of the first particle [GeV]
[in]	mb	Mass of the second particle [GeV]

Definition at line 26 of file kinematics.h.

                                                                   {
  const double m_sum = ma + mb;
  const double m_dif = ma - mb;
  return std::sqrt((s - m_sum * m_sum) / (s - m_dif * m_dif));
}

Here is the caller graph for this function:

fixed_target_projectile_v()

double smash::fixed_target_projectile_v ( double  s, double  ma, double  mb  )

inline

Returns

Velocity of projectile in the fixed target frame given the Mandelstam s of projectile and target and their masses

Parameters

[in]	s	Mandelstam s of the collision [GeV^2]
[in]	ma	Mass of the projectile [GeV]
[in]	mb	Mass of the target [GeV]

Definition at line 39 of file kinematics.h.

                                                                        {
  const double inv_gamma = 2 * ma * mb / (s - ma * ma - mb * mb);
  return std::sqrt(1.0 - inv_gamma * inv_gamma);
}

Here is the caller graph for this function:

pCM_sqr_from_s()

template<typename T >

T smash::pCM_sqr_from_s ( const T  s, const T  mass_a, const T  mass_b  )

noexcept

Returns

The squared center-of-mass momentum of two particles, given s and their masses. [GeV^2]

Parameters

[in]	s	Mandelstam s of the process [GeV^2].
[in]	mass_a	Mass of first particle [GeV].
[in]	mass_b	Mass of second particle [GeV].

Definition at line 52 of file kinematics.h.

                                                                     {
  const auto mass_a_sqr = mass_a * mass_a;
  const auto x = s + mass_a_sqr - mass_b * mass_b;
  return x * x * (T(0.25) / s) - mass_a_sqr;
}

Here is the caller graph for this function:

pCM_from_s()

template<typename T >

T smash::pCM_from_s ( const T  s, const T  mass_a, const T  mass_b  )

noexcept

Returns

The center-of-mass momentum of two particles, given s and their masses. [GeV]

Parameters

[in]	s	Mandelstam s of the process [GeV^2].
[in]	mass_a	Mass of first particle [GeV].
[in]	mass_b	Mass of second particle [GeV].

Definition at line 66 of file kinematics.h.

                                                                 {
  const auto psqr = pCM_sqr_from_s(s, mass_a, mass_b);
  return psqr > T(0.) ? std::sqrt(psqr) : T(0.);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pCM()

template<typename T >

T smash::pCM ( const T  sqrts, const T  mass_a, const T  mass_b  )

noexcept

Returns

The center-of-mass momentum of two particles, given sqrt(s) and their masses. [GeV]

Parameters

[in]	sqrts	sqrt(s) of the process [GeV].
[in]	mass_a	Mass of first particle [GeV].
[in]	mass_b	Mass of second particle [GeV].

Definition at line 79 of file kinematics.h.

                                                              {
  return pCM_from_s(sqrts * sqrts, mass_a, mass_b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pCM_sqr()

template<typename T >

T smash::pCM_sqr ( const T  sqrts, const T  mass_a, const T  mass_b  )

noexcept

Returns

The squared center-of-mass momentum of two particles, given sqrt(s) and their masses.

Parameters

[in]	sqrts	sqrt(s) of the process [GeV].
[in]	mass_a	Mass of first particle [GeV].
[in]	mass_b	Mass of second particle [GeV].

Definition at line 91 of file kinematics.h.

                                                                  {
  return pCM_sqr_from_s(sqrts * sqrts, mass_a, mass_b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_t_range()

template<typename T >

std::array<T, 2> smash::get_t_range	(	const T	sqrts,
		const T	m1,
		const T	m2,
		const T	m3,
		const T	m4
	)

Get the range of Mandelstam-t values allowed in a particular 2->2 process, see PDG 2014 booklet, eq.

(46.34).

Parameters

[in]	sqrts	sqrt(s) of the process [GeV].
[in]	m1	Mass of first incoming particle [GeV].
[in]	m2	Mass of second incoming particle [GeV].
[in]	m3	Mass of first outgoing particle [GeV].
[in]	m4	Mass of second outgoing particle [GeV].

Returns

array consisting of {t_min, t_max}

Note that both t_min and t_max are negative, with |t_min| < |t_max|, i.e. t_min > t_max.

Definition at line 109 of file kinematics.h.

                                         {
  const T p_i = pCM(sqrts, m1, m2);  // initial-state CM momentum
  const T p_f = pCM(sqrts, m3, m4);  // final-state CM momentum
  const T sqrt_t0 = (m1 * m1 - m2 * m2 - m3 * m3 + m4 * m4) / (2. * sqrts);
  const T t0 = sqrt_t0 * sqrt_t0;
  const T t_min = t0 - (p_i - p_f) * (p_i - p_f);
  const T t_max = t0 - (p_i + p_f) * (p_i + p_f);
  assert(t_min >= t_max);
  return {t_min, t_max};
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_energy()

static void smash::check_energy ( double  mandelstam_s, double  m_sum  )

inlinestatic

Helper function for plab_from_s.

Parameters

[in]	mandelstam_s	The Mandelstam variable s [GeV^2]
[in]	m_sum	Sum of masses of target and projectile [GeV] \( m_1 + m_2 \)

Definition at line 127 of file kinematics.h.

                                                                   {
  if (mandelstam_s < m_sum * m_sum) {
    std::stringstream err;
    err << "plab_from_s: s too small: " << mandelstam_s << " < "
        << m_sum * m_sum;
    throw std::runtime_error(err.str());
  }
}

Here is the caller graph for this function:

check_radicand()

static void smash::check_radicand ( double  mandelstam_s, double  radicand  )

inlinestatic

Helper function for plab_from_s.

Parameters

[in]	mandelstam_s	The Mandelstam variable s [GeV^2]
[in]	radicand	\( (s - (m_1 + m_2)^2) * (s - (m_1 - m_2)^2) \) where \( m_1 \) and \( m_2 \) are masses of incoming particles [GeV^4]

Definition at line 142 of file kinematics.h.

                                                                        {
  if (radicand < 0) {
    std::stringstream err;
    err << "plab_from_s: negative radicand: " << mandelstam_s;
    throw std::runtime_error(err.str());
  }
}

Here is the caller graph for this function:

plab_from_s() [1/3]

double smash::plab_from_s ( double  mandelstam_s, double  mass  )

inline

Convert Mandelstam-s to p_lab in a fixed-target collision.

This assumes both particles have the given mass.

Parameters

[in]	mandelstam_s	The Mandelstam variable s [GeV^2]
[in]	mass	Mass of projectile and target [GeV]

Returns

Momentum of the projectile in the lab frame [GeV]

Definition at line 157 of file kinematics.h.

                                                            {
  const double radicand = mandelstam_s * (mandelstam_s - 4 * mass * mass);
#ifndef NDEBUG
  const double m_sum = 2 * mass;
  check_energy(mandelstam_s, m_sum);
  check_radicand(mandelstam_s, radicand);
#endif
  return std::sqrt(radicand) / (2 * mass);
}

Here is the call graph for this function:

Here is the caller graph for this function:

plab_from_s() [2/3]

double smash::plab_from_s ( double  mandelstam_s )

inline

Convert Mandelstam-s to p_lab in a fixed-target collision.

This assumes both particles have the mass of a nucleon.

Parameters

[in]

mandelstam_s

The Mandelstam variable s [GeV^2]

Returns

Momentum of the projectile in the lab frame [GeV]

Definition at line 173 of file kinematics.h.

                                               {
  return plab_from_s(mandelstam_s, nucleon_mass);
}

Here is the call graph for this function:

plab_from_s() [3/3]

double smash::plab_from_s ( double  mandelstam_s, double  m_projectile, double  m_target  )

inline

Convert Mandelstam-s to p_lab in a fixed-target collision.

The mass of the projectile and the mass of the target have to be given.

Parameters

[in]	mandelstam_s	the Mandelstam variable s [GeV^2]
[in]	m_projectile	mass of the projectile [GeV]
[in]	m_target	mass of the target [GeV]

Returns

momentum of the projectile in the lab frame [GeV]

Definition at line 185 of file kinematics.h.

                                           {
  const double m_sum = m_projectile + m_target;
  const double m_diff = m_projectile - m_target;
  const double radicand =
      (mandelstam_s - m_sum * m_sum) * (mandelstam_s - m_diff * m_diff);
/* This is equivalent to:
 * const double radicand
 *     = (mandelstam_s - m_a_sq - m_b_sq) * (mandelstam_s - m_a_sq - m_b_sq)
 *     - 4 * m_a_sq * m_b_sq; */
#ifndef NDEBUG
  check_energy(mandelstam_s, m_sum);
  check_radicand(mandelstam_s, radicand);
#endif
  return std::sqrt(radicand) / (2 * m_target);
}

Here is the call graph for this function:

plab_from_s_heavier_particle_at_rest()

double smash::plab_from_s_heavier_particle_at_rest ( double  mandelstam_s, double  m1, double  m2  )

inline

Convert Mandelstam-s to p_lab in a fixed-target collision.

The mass of the two colliding particles have to be given and the heavier particle is assumed to be the target, i.e. at rest.

Parameters

[in]	mandelstam_s	the Mandelstam variable s [GeV^2]
[in]	m1	mass of first particle [GeV]
[in]	m2	mass of second particle [GeV]

Returns

momentum of the projectile in the lab frame [GeV]

Definition at line 211 of file kinematics.h.

                                                                         {
  return (m1 > m2) ? plab_from_s(mandelstam_s, m2, m1)
                   : plab_from_s(mandelstam_s, m1, m2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

s_from_Etot() [1/2]

double smash::s_from_Etot ( double  e_tot, double  m_P, double  m_T  )

inline

Convert E_tot to Mandelstam-s for a fixed-target setup, with a projectile of mass m_P and a total energy e_tot and a target of mass m_T at rest.

Parameters

[in]	e_tot	energy of the projectile in the lab frame [GeV]
[in]	m_P	mass of the projectile [GeV]
[in]	m_T	mass of the target [GeV]

Returns

The Mandelstam variable s [GeV^2]

Definition at line 226 of file kinematics.h.

                                                                {
  return m_P * m_P + m_T * m_T + 2 * m_T * e_tot;
}

Here is the caller graph for this function:

s_from_Etot() [2/2]

double smash::s_from_Etot ( double  e_tot_p, double  e_tot_t, double  m_p, double  m_t  )

inline

Convert E_tot to Mandelstam-s for two beams with total energies and masses (E,m)

Parameters

[in]	e_tot_p	Total energy of projectile [GeV]
[in]	e_tot_t	Total energy of target [GeV]
[in]	m_p	Mass of projectile [GeV]
[in]	m_t	Mass of target [GeV]

Returns

Mandelstam-s [GeV^2]

Definition at line 239 of file kinematics.h.

                                      {
  double pz_p = std::sqrt(e_tot_p * e_tot_p - m_p * m_p);
  double pz_t = std::sqrt(e_tot_t * e_tot_t - m_t * m_t);
  return std::pow(e_tot_p + e_tot_t, 2) - std::pow(pz_p - pz_t, 2);
}

s_from_Ekin() [1/2]

double smash::s_from_Ekin ( double  e_kin, double  m_P, double  m_T  )

inline

Convert E_kin to Mandelstam-s for a fixed-target setup, with a projectile of mass m_P and a kinetic energy e_kin and a target of mass m_T at rest.

Parameters

[in]	e_kin	kinetic energy of the projectile in the lab frame [GeV]
[in]	m_P	mass of the projectile [GeV]
[in]	m_T	mass of the target [GeV]

Returns

The Mandelstam variable s [GeV^2]

Definition at line 254 of file kinematics.h.

                                                                {
  return s_from_Etot(e_kin + m_P, m_P, m_T);
}

Here is the call graph for this function:

Here is the caller graph for this function:

s_from_Ekin() [2/2]

double smash::s_from_Ekin ( double  e_kin_p, double  e_kin_t, double  m_p, double  m_t  )

inline

Convert E_kin=(E_tot-m) to Mandelstam-s for two beams with total energies and masses (E,m)

Parameters

[in]	e_kin_p	Kinetic energy of projectile [GeV]
[in]	e_kin_t	Kinetic energy of target [GeV]
[in]	m_p	Mass of projectile [GeV]
[in]	m_t	Mass of target [GeV]

Returns

Mandelstam-s [GeV^2]

Definition at line 267 of file kinematics.h.

                                      {
  return s_from_Etot(e_kin_p + m_t, e_kin_t + m_t, m_p, m_t);
}

Here is the call graph for this function:

s_from_plab() [1/2]

double smash::s_from_plab ( double  plab, double  m_P, double  m_T  )

inline

Convert p_lab to Mandelstam-s for a fixed-target setup, with a projectile of mass m_P and momentum plab and a target of mass m_T at rest.

Parameters

[in]	plab	Momentum of the projectile in the lab frame [GeV]
[in]	m_P	Mass of the projectile [GeV]
[in]	m_T	Mass of the target [GeV]

Returns

The Mandelstam variable s [GeV^2]

Definition at line 280 of file kinematics.h.

                                                               {
  return m_P * m_P + m_T * m_T + 2 * m_T * std::sqrt(m_P * m_P + plab * plab);
}

Here is the caller graph for this function:

s_from_plab() [2/2]

double smash::s_from_plab ( double  plab_p, double  plab_t, double  m_p, double  m_t  )

inline

Convert P_lab to Mandelstam-s for two beams with total momenta and masses (P,m) (P_lab gives per nucleon, P=P_lab*A)

Parameters

[in]	plab_p	Kinetic energy of projectile [GeV]
[in]	plab_t	Kinetic energy of target [GeV]
[in]	m_p	Mass of projectile [GeV]
[in]	m_t	Mass of target [GeV]

Returns

Mandelstam-s [GeV^2]

Definition at line 293 of file kinematics.h.

                                      {
  return s_from_Etot(std::sqrt(m_p * m_p + plab_p * plab_p),
                     std::sqrt(m_t * m_t + plab_t * plab_t), plab_p, plab_t);
}

Here is the call graph for this function:

setup_config_and_logging()

Configuration smash::setup_config_and_logging	(	const std::string &	config_file,
		const std::string &	particles_file = {},
		const std::string &	decaymodes_file = {},
		const std::vector< std::string > &	extra_config = {}
	)

Set up configuration and logging from input files and extra config.

Parameters

[in]	config_file	Path to config input file
[in]	particles_file	Path to particles input file.
[in]	decaymodes_file	Path to decaymodes input file.
[in]	extra_config	Extra config entries.

Returns

Configuration object with particles, decaymodes and extra configs included.

If no particles and decaymodes files are given the default files in the input directory are used.

Definition at line 34 of file library.cc.

                                              {
  Configuration configuration = create_configuration(config_file, extra_config);
  fully_validate_configuration(configuration);
  setup_logging(configuration);
  read_particles_and_decaymodes_files_setting_keys_in_configuration(
      particles_file, decaymodes_file, configuration);
  return configuration;
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_particles_decays_and_tabulations()

void smash::initialize_particles_decays_and_tabulations	(	Configuration &	configuration,
		const std::string &	version,
		const std::string &	tabulations_dir = {}
	)

Wrapper over a function that initializes the particles and decays from the given configuration, and over another that tabulates the resonance integrals.

Parameters

[in]	configuration	Fully-setup configuration i.e. including particles and decaymodes.
[in]	version	Current version of SMASH.
[in]	tabulations_dir	Path where tabulations should be stored.

Definition at line 46 of file library.cc.

                                      {
  const auto hash =
      initialize_particles_decays_and_return_hash(configuration, version);
  tabulate_resonance_integrals(hash, tabulations_dir);
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_particles_decays_and_return_hash()

sha256::Hash smash::initialize_particles_decays_and_return_hash	(	Configuration &	configuration,
		const std::string &	version
	)

Initialize the particles and decays from the given configuration.

Parameters

[in]	configuration	Fully-setup configuration i.e. including particles and decaymodes.
[in]	version	Current version of SMASH.

Returns

hash of the version, particle list, and decay modes.

Definition at line 54 of file library.cc.

                                                            {
  logg[LMain].trace(SMASH_SOURCE_LOCATION,
                    " create ParticleType and DecayModes");
  const std::string particles_string = configuration.take(InputKeys::particles);
  const std::string decaymodes_string =
      configuration.take(InputKeys::decaymodes);
  ParticleType::create_type_list(particles_string);
  DecayModes::load_decaymodes(decaymodes_string);
  ParticleType::check_consistency();
 
  // Calculate a hash of the SMASH version, the particles and decaymodes.
  sha256::Context hash_context;
  hash_context.update(version);
  hash_context.update(particles_string);
  hash_context.update(decaymodes_string);
  const auto hash = hash_context.finalize();
  logg[LMain].info() << "Config hash: " << sha256::hash_to_string(hash);
  return hash;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tabulate_resonance_integrals()

void smash::tabulate_resonance_integrals	(	const sha256::Hash &	hash,
		const std::string &	tabulations_dir
	)

Tabulate the resonance integrals.

Parameters

[in]	hash	Hash of the SMASH version, particle list, and decay modes.
[in]	tabulations_dir	Path where tabulations should be stored.

Definition at line 75 of file library.cc.

                                                                    {
  logg[LMain].info("Tabulating cross section integrals...");
  std::filesystem::path tabulations_path(tabulations_dir);
  if (!tabulations_path.empty()) {
    // Store tabulations on disk
    std::filesystem::create_directories(tabulations_path);
    logg[LMain].info() << "Tabulations path: " << tabulations_path;
  }
  IsoParticleType::tabulate_integrals(hash, tabulations_path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

smooth()

template<typename T >

std::vector<T> smash::smooth	(	const std::vector< T > &	x,
		const std::vector< T > &	y,
		T	span = 2. / 3,
		size_t	iter = 3,
		T	delta = 0
	)

Apply the LOWESS smoother (see the reference below) to the given data (x, y).

Parameters

x	x-values.
y	y-values.
span	The smoother span. This gives the proportion of points in the plot which influence the smoothness at each value. Larger values give more smoothness.
iter	The number of robustifying iterations which should be performed. Using smaller values of iter will make lowess run faster.
delta	Values of x which lie within delta of each other replaced by a single value in the output from lowess. For delta = 0, delta will be calculated.

Returns

Smoothed y-values.

References:

• Cleveland, W. S. (1979) Robust locally weighted regression and smoothing scatterplots. J. Amer. Statist. Assoc. 74, 829-836.
• Cleveland, W. S. (1981) LOWESS: A program for smoothing scatterplots by robust locally weighted regression. The American Statistician, 35, 54.

Definition at line 289 of file lowess.h.

                                                                     {
  assert(x.size() == y.size());
  std::vector<T> result;
  result.resize(x.size());
  std::vector<T> rw;
  rw.resize(x.size());
  std::vector<T> res;
  res.resize(x.size());
  lowess::lowess(&x.front(), &y.front(), x.size(), &result.front(), span, iter,
                 delta, &rw.front(), &res.front());
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

has_projectile_or_target()

bool smash::has_projectile_or_target

(

const Configuration &

config

)

Find out whether a configuration has a projectile or a target sub-section.

Parameters

config

The configuration to be checked.

Definition at line 588 of file nucleus.cc.

                                                           {
  const bool is_projectile = config.has_section(InputSections::m_c_projectile);
  const bool is_target = config.has_section(InputSections::m_c_target);
  return is_projectile || is_target;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_about_projectile()

bool smash::is_about_projectile

(

const Configuration &

config

)

Find out whether a configuration is about projectile or target.

Parameters

config

The configuration to be checked.

Exceptions

An	std::logic_error if there is neither a projectile nor a target subsection or if both are present.

Definition at line 594 of file nucleus.cc.

                                                      {
  const bool is_projectile = config.has_section(InputSections::m_c_projectile);
  const bool is_target = config.has_section(InputSections::m_c_target);
  if (is_projectile == is_target) {
    throw std::logic_error(
        "Error parsing configuration of EITHER projectile OR target.\n"
        "Configuration tested for it contains the following:\n------------\n" +
        config.to_string() + "\n------------\n");
  }
  return is_projectile;
}

Here is the call graph for this function:

Here is the caller graph for this function:

numeric_cast()

template<typename To , class From , typename std::enable_if_t< std::is_arithmetic_v< To >, bool > = true>

constexpr To smash::numeric_cast ( From  from )

constexprnoexcept

Function template to perform a safe numeric conversion between types.

Template Parameters

To	Destination type
From	Source type
unnamed	The last template parameter makes such that this function template participates in function overload only if the destination type To is an arithmetic type (typical usage of SFINAE).

Parameters

[in]

from

Input value to be converted

Returns

The input value converted to the new type To .

Exceptions

std::domain_error

If the value to be converted cannot be represented by any value of the destination type.

Note

This is adapted from the Microsoft implementation of narrow function in the C++ Guidelines Support Library, which is released under MIT license.

Definition at line 74 of file numeric_cast.h.

                                                     {
  /* While this is technically undefined behavior in some cases (i.e., if the
  source value is of floating-point type and cannot fit into the destination
  integral type), the resultant behavior is benign on the platforms that we
  target (i.e., no hardware trap representations are hit). */
  const To to = static_cast<To>(from);
 
  /*
   * NOTE 1: NaN will always throw, since NaN != NaN
   *
   * NOTE 2: The first condition in the if-clause below is not enough because it
   * might happen that the cast back is matching the initial value when casting
   * signed to unsigned numbers or vice-versa because of the "wrapping around"
   * behaviour. See https://stackoverflow.com/a/52863884 for more information.
   */
  constexpr const bool is_different_signedness =
      (std::is_signed_v<To> != std::is_signed_v<From>);
  if (static_cast<From>(to) != from ||
      (is_different_signedness && ((to < To{}) != (from < From{})))) {
    throw std::domain_error("Numeric cast failed converting '" +
                            detail::type_name<From>() + "' to '" +
                            detail::type_name<To>() + "'.");
  }
 
  return to;
}

almost_equal()

template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>

bool smash::almost_equal	(	const N	x,
		const N	y
	)

Checks whether two floating-point numbers are almost equal.

This is done using smash::really_small as relative tolerance. All numbers are tested for equality, no matter which order of magnitude they have.

See also

detail::almost_equal_knuthish for more information.

Definition at line 89 of file numerics.h.

                                        {
  return detail::almost_equal_knuthish<N>(x, y, static_cast<N>(really_small));
}

Here is the caller graph for this function:

almost_equal_physics()

template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>

bool smash::almost_equal_physics	(	const N	x,
		const N	y
	)

Like smash::almost_equal, but using a less strict tolerance, smash::small_number.

Furthermore, numbers smaller than a given threshold, smash::really_small, are now considered equal (in the sense that, for SMASH physics, their difference has no physical effect).

Definition at line 100 of file numerics.h.

                                                {
  const auto threshold = static_cast<N>(really_small);
  const auto epsilon = static_cast<N>(small_number);
  return detail::almost_equal_knuthish<N>(x, y, epsilon, threshold);
}

Here is the caller graph for this function:

is_any_nan()

template<typename T = std::initializer_list<double>>

bool smash::is_any_nan

(

const T &

collection

)

Returns whether any element in a collection is NaN.

This function iterates through the elements of a collection and checks if any of them is NaN using std::isnan. NaN is a special floating-point value that represents undefined or unrepresentable values.

Template Parameters

T	Iterable container of numeric values (defaults to std::initializer_list<double>).

Parameters

[in]

collection

The collection to be checked for NaN values.

Returns

true if any element in the collection is NaN,

false otherwise.

Definition at line 121 of file numerics.h.

                                     {
  for (const auto& number : collection) {
    if (unlikely(std::isnan(number)))
      return true;
  }
  return false;
}

Here is the caller graph for this function:

write_in_chunk()

template<typename Converter , class Range , std::enable_if_t< std::is_same_v< Range, Particles >||std::is_same_v< Range, ParticleList >, bool > = true>

void smash::write_in_chunk	(	const Range &	particles,
		const OutputFormatter< Converter > &	formatter,
		std::function< void(const typename Converter::type &)>	write
	)

User-facing wrapper for chunked particle writing.

Forwards the call to the internal implementation.

See also

detail::write_in_chunk_impl

Definition at line 755 of file outputformatter.h.

                                                            {
  detail::write_in_chunk_impl(particles, formatter, write);
}

Here is the call graph for this function:

parametrization_exists()

bool smash::parametrization_exists	(	const PdgCode &	pdg_a,
		const PdgCode &	pdg_b
	)

Checks if supplied codes have existing parametrizations of total cross sections.

Parameters

[in]	pdg_a	PDG code of first incoming particle
[in]	pdg_b	PDG code of second incoming particle

Returns

Whether the parametrization exists

Definition at line 30 of file parametrizations.cc.

                                                                        {
  const bool two_nucleons = pdg_a.is_nucleon() && pdg_b.is_nucleon();
  const bool nucleon_and_kaon = (pdg_a.is_nucleon() && pdg_b.is_kaon()) ||
                                (pdg_a.is_kaon() && pdg_b.is_nucleon());
  const bool nucleon_and_pion = (pdg_a.is_nucleon() && pdg_b.is_pion()) ||
                                (pdg_a.is_pion() && pdg_b.is_nucleon());
  const bool two_pions = pdg_a.is_pion() && pdg_b.is_pion();
  return two_nucleons || nucleon_and_kaon || nucleon_and_pion || two_pions;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xs_high_energy()

double smash::xs_high_energy	(	double	mandelstam_s,
		bool	is_opposite_charge,
		double	ma,
		double	mb,
		double	P,
		double	R1,
		double	R2
	)

total hadronic cross sections at high energies parametrized in the 2016 PDG book (http://pdg.lbl.gov/2016/reviews/rpp2016-rev-cross-section-plots.pdf)

This function is a utility function called from specific parametrizations.

Parameters

[in]	mandelstam_s	the rest frame total energy squared [GeV^2]
[in]	is_opposite_charge	whether the particles being collided have opposite charges
[in]	ma	mass of first particle [GeV]
[in]	mb	mass of second particle [GeV]
[in]	P	Pomeranchuk's constant term [mb]
[in]	R1	intensity of the first Regge pole contribution [mb]
[in]	R2	intensity of the second Regge pole contribution [mb]

Returns

the parametrized cross-section [mb]

Definition at line 40 of file parametrizations.cc.

                                                                 {
  const double M = 2.1206;
  const double H = 0.272;
  const double eta1 = 0.4473;
  const double eta2 = 0.5486;
  const double s_sab = mandelstam_s / (ma + mb + M) / (ma + mb + M);
  double xs =
      H * std::log(s_sab) * std::log(s_sab) + P + R1 * std::pow(s_sab, -eta1);
  xs = is_opposite_charge ? xs + R2 * std::pow(s_sab, -eta2)
                          : xs - R2 * std::pow(s_sab, -eta2);
  return xs;
}

Here is the caller graph for this function:

pp_high_energy()

double smash::pp_high_energy

(

double

mandelstam_s

)

pp total cross section at high energies

See also

xs_high_energy

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 54 of file parametrizations.cc.

                                           {
  return xs_high_energy(mandelstam_s, false, 0.939, 0.939, 34.41, 13.07, 7.394);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ppbar_high_energy()

double smash::ppbar_high_energy

(

double

mandelstam_s

)

ppbar total cross section at high energies

See also

xs_high_energy

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 58 of file parametrizations.cc.

                                              {
  return xs_high_energy(mandelstam_s, true, 0.939, 0.939, 34.41, 13.07, 7.394);
}

Here is the call graph for this function:

Here is the caller graph for this function:

np_high_energy()

double smash::np_high_energy

(

double

mandelstam_s

)

np total cross section at high energies

See also

xs_high_energy

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 62 of file parametrizations.cc.

                                           {
  return xs_high_energy(mandelstam_s, false, 0.939, 0.939, 34.41, 12.52, 6.66);
}

Here is the call graph for this function:

Here is the caller graph for this function:

npbar_high_energy()

double smash::npbar_high_energy

(

double

mandelstam_s

)

npbar total cross section at high energies

See also

xs_high_energy

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 66 of file parametrizations.cc.

                                              {
  return xs_high_energy(mandelstam_s, true, 0.939, 0.939, 34.41, 12.52, 6.66);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piplusp_high_energy()

double smash::piplusp_high_energy

(

double

mandelstam_s

)

pi+p total cross section at high energies

See also

xs_high_energy

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 70 of file parametrizations.cc.

                                                {
  return xs_high_energy(mandelstam_s, false, 0.939, 0.138, 18.75, 9.56, 1.767);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_high_energy()

double smash::piminusp_high_energy

(

double

mandelstam_s

)

pi-p total cross section at high energies

See also

xs_high_energy

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 74 of file parametrizations.cc.

                                                 {
  return xs_high_energy(mandelstam_s, true, 0.939, 0.138, 18.75, 9.56, 1.767);
}

Here is the call graph for this function:

Here is the caller graph for this function:

xs_ppbar_annihilation()

double smash::xs_ppbar_annihilation

(

double

mandelstam_s

)

parametrized cross-section for proton-antiproton annihilation used in the UrQMD model

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 78 of file parametrizations.cc.

                                                  {
  const double xs_ref = 120.;
  const double s_ref = 4. * nucleon_mass * nucleon_mass;
  const double constant_a = 0.05;
  const double constant_b = 0.6;
  const double factor = constant_a * constant_a * s_ref /
                            ((mandelstam_s - s_ref) * (mandelstam_s - s_ref) +
                             constant_a * constant_a * s_ref) +
                        constant_b;
  return xs_ref * (s_ref / mandelstam_s) * factor;
}

Here is the caller graph for this function:

xs_string_hard()

double smash::xs_string_hard	(	double	mandelstam_s,
		double	xs_0,
		double	e_0,
		double	lambda_pow
	)

Utility function called by specific other parametrizations Parametrized hard scattering cross section (with partonic scattering) This parametrization is a direct fit to cross sections in PYTHIA See Sjostrand:1987su [59].

Parameters

[in]	mandelstam_s	the rest frame total energy squared [GeV^2]
[in]	xs_0	a fit parameter [mb]
[in]	e_0	a fit parameter [GeV]
[in]	lambda_pow	a fit parameter

Returns

the parametrized cross-section [mb]

Definition at line 90 of file parametrizations.cc.

                                         {
  const double sqrts = std::sqrt(mandelstam_s);
  if (sqrts < e_0) {
    return 0.;
  } else {
    double xs = xs_0 * std::pow(std::log(sqrts / e_0), lambda_pow);
    return xs;
  }
}

Here is the caller graph for this function:

NN_string_hard()

double smash::NN_string_hard

(

double

mandelstam_s

)

nucleon-nucleon hard scattering cross section (with partonic scattering)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

See also

xs_string_hard

Definition at line 101 of file parametrizations.cc.

                                           {
  return xs_string_hard(mandelstam_s, 0.087, 4.1, 3.8);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Npi_string_hard()

double smash::Npi_string_hard

(

double

mandelstam_s

)

nucleon-pion hard scattering cross section (with partonic scattering)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

See also

xs_string_hard

Definition at line 105 of file parametrizations.cc.

                                            {
  return xs_string_hard(mandelstam_s, 0.042, 3.5, 4.2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pipi_string_hard()

double smash::pipi_string_hard

(

double

mandelstam_s

)

pion-pion hard scattering cross section (with partonic scattering)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

See also

xs_string_hard

Definition at line 109 of file parametrizations.cc.

                                             {
  return xs_string_hard(mandelstam_s, 0.013, 2.3, 4.7);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pipluspiminus_total()

double smash::pipluspiminus_total

(

double

sqrts

)

pi+ pi- total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm.

If the requested energy is out of the interpolation bounds, the hard string value is returned.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 113 of file parametrizations.cc.

                                         {
  if (pipluspiminus_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIPLUSPIMINUS_TOT_SQRTS, PIPLUSPIMINUS_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.01, 10);
    pipluspiminus_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double last = *(PIPLUSPIMINUS_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*pipluspiminus_total_interpolation)(sqrts);
  else
    return pipi_string_hard(sqrts * sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pizeropizero_total()

double smash::pizeropizero_total

(

double

sqrts

)

pi0 pi0 total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm.

If the requested energy is out of the interpolation bounds, the hard string value is returned.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 129 of file parametrizations.cc.

                                        {
  if (pizeropizero_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIZEROPIZERO_TOT_SQRTS, PIZEROPIZERO_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.01, 10);
    pizeropizero_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double last = *(PIZEROPIZERO_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*pizeropizero_total_interpolation)(sqrts);
  else
    return pipi_string_hard(sqrts * sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piplusp_total()

double smash::piplusp_total

(

double

sqrts

)

pi+ p total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm.

If the requested energy is out of the interpolation bounds, the high energy cross section is returned.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 145 of file parametrizations.cc.

                                   {
  if (piplusp_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIPLUSP_TOT_SQRTS, PIPLUSP_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.01, 10);
    piplusp_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double last = *(PIPLUSP_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*piplusp_total_interpolation)(sqrts);
  else
    return piplusp_high_energy(sqrts * sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piplusp_elastic_AQM()

double smash::piplusp_elastic_AQM	(	double	mandelstam_s,
		double	m1,
		double	m2
	)

pi+p elactic cross section parametrization.

Source: GiBUU:parametrizationBarMes_HighEnergy.f90 Elastic contributions from decays are not subtracted, high energy parametrization used at all energies (useful for AQM).

The very low part is replaced by a flat 7.5 mb cross section; used for meson-meson interactions.

Parameters

[in]	mandelstam_s	the rest frame total energy squared [GeV^2]
[in]	m1	the mass of the first particle [GeV]
[in]	m2	the mass of the second particle [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 179 of file parametrizations.cc.

                                                                      {
  const double p_lab =
      plab_from_s_heavier_particle_at_rest(mandelstam_s, m1, m2);
  if (p_lab < 3.05) {  // the plab from which the param starts to explode
    return 7.5;        // this will be scaled down by 2/3 for meson-meson
  } else {
    const auto logp = std::log(p_lab);
    return 11.4 * std::pow(p_lab, -0.4) + 0.079 * logp * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

piplusp_elastic()

double smash::piplusp_elastic

(

double

mandelstam_s

)

pi+p elastic cross section parametrization, PDG data.

Source: GiBUU:parametrizationBarMes_HighEnergy.f90

The parametrizations of the elastic pion+nucleon cross sections are still under tuning. The parametrizaton is employed to give a non-zero cross section at high energies. To make sure it doesn't affect the cross section at the low energies, I truncate the parametrization at p_lab = 8 GeV, which correspons to square root of s equal to 4 GeV.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 190 of file parametrizations.cc.

                                            {
  double sigma;
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  if (mandelstam_s < 2.25) {
    sigma = really_small;
  } else if (mandelstam_s > 4.84) {
    const auto logp = std::log(p_lab);
    sigma = 11.4 * std::pow(p_lab, -0.4) + 0.079 * logp * logp;
  } else {
    sigma = piplusp_elastic_pdg(mandelstam_s);
  }
 
  // The elastic contributions from decays still need to be subtracted.
  if (piplusp_elastic_res_interpolation == nullptr) {
    std::vector<double> x = PIPLUSP_RES_SQRTS;
    for (auto& i : x) {
      i = i * i;
    }
    std::vector<double> y = PIPLUSP_RES_SIG;
    piplusp_elastic_res_interpolation = std::make_unique<InterpolateDataSpline>(
        x, y, ExtrapolationType::Constant);
  }
  sigma -= (*piplusp_elastic_res_interpolation)(mandelstam_s);
  if (sigma < 0) {
    sigma = really_small;
  }
  return sigma;
}

Here is the call graph for this function:

Here is the caller graph for this function:

piplusp_sigmapluskplus_pdg()

double smash::piplusp_sigmapluskplus_pdg

(

double

mandelstam_s

)

pi+ p to Sigma+ K+ cross section parametrization, PDG data.

The PDG data is smoothed using the LOWESS algorithm. If more than one cross section was given for one p_lab value, the corresponding cross sections are averaged.

Definition at line 224 of file parametrizations.cc.

                                                       {
  if (piplusp_sigmapluskplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(PIPLUSP_SIGMAPLUSKPLUS_P_LAB,
                                                PIPLUSP_SIGMAPLUSKPLUS_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.2, 5);
    piplusp_sigmapluskplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  /* If p_lab is beyond the upper bound of the linear interpolation,
   * InterpolateDataLinear will return the value at the upper bound if
   * ExtrapolationType::Constant is set and this is what we want here. */
  return (*piplusp_sigmapluskplus_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_total()

double smash::piminusp_total

(

double

sqrts

)

pi- p total cross section parametrized from PDG2018, smoothed using the LOWESS algorithm.

If the requested energy is out of the interpolation bounds, the high energy cross section is returned.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 240 of file parametrizations.cc.

                                    {
  if (piminusp_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIMINUSP_TOT_SQRTS, PIMINUSP_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.01, 6);
    piminusp_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double last = *(PIMINUSP_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*piminusp_total_interpolation)(sqrts);
  else
    return piminusp_high_energy(sqrts * sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_elastic()

double smash::piminusp_elastic

(

double

mandelstam_s

)

pi-p elastic cross section parametrization Source: GiBUU:parametrizationBarMes_HighEnergy.f90

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 274 of file parametrizations.cc.

                                             {
  double sigma;
  if (mandelstam_s < 1.69) {
    sigma = really_small;
  } else if (mandelstam_s > 4.84) {
    const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
    /* std::log(0) = -∞ and std::pow(0, negative) = +∞ both raise FE_DIVBYZERO.
     * Handle this case explicitly to preserve the mathematical result without
     * raising a floating-point exception. */
    if (p_lab == 0.0) {
      sigma = std::numeric_limits<double>::infinity();
    } else {
      const auto logp = std::log(p_lab);
      sigma = 1.76 + 11.2 * std::pow(p_lab, -0.64) + 0.043 * logp * logp;
    }
  } else {
    sigma = piminusp_elastic_pdg(mandelstam_s);
  }
  /* Tune down the elastic cross section when sqrt s is between 1.8 GeV
   * and 1.97 GeV so that the total cross section can fit the data. The
   * scaling factor is chosen so that the it's equal to one and its
   * derivate vanishes at the both ends. The minimum scaling factor in this
   * region is 0.88-0.12=0.76. */
  if (mandelstam_s > 3.24 && mandelstam_s < 3.8809) {
    sigma *= (0.12 * std::cos(2 * M_PI * (std::sqrt(mandelstam_s) - 1.8) /
                              (1.97 - 1.8)) +
              0.88);
  }
  // The elastic contributions from decays still need to be subtracted.
  if (piminusp_elastic_res_interpolation == nullptr) {
    std::vector<double> x = PIMINUSP_RES_SQRTS;
    for (auto& i : x) {
      i = i * i;
    }
    std::vector<double> y = PIMINUSP_RES_SIG;
    auto [dedup_x, dedup_y] = dedup_avg(x, y);
    piminusp_elastic_res_interpolation =
        std::make_unique<InterpolateDataSpline>(dedup_x, dedup_y,
                                                ExtrapolationType::Constant);
  }
  sigma -= (*piminusp_elastic_res_interpolation)(mandelstam_s);
  if (sigma < 0) {
    sigma = really_small;
  }
  return sigma;
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_lambdak0_pdg()

double smash::piminusp_lambdak0_pdg

(

double

mandelstam_s

)

pi- p -> Lambda K0 cross section parametrization, PDG data.

The PDG data is smoothed using the LOWESS algorithm. If more than one cross section was given for one p_lab value, the corresponding cross sections are averaged.

Definition at line 326 of file parametrizations.cc.

                                                  {
  if (piminusp_lambdak0_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIMINUSP_LAMBDAK0_P_LAB, PIMINUSP_LAMBDAK0_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
    piminusp_lambdak0_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piminusp_lambdak0_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_sigmaminuskplus_pdg()

double smash::piminusp_sigmaminuskplus_pdg

(

double

mandelstam_s

)

pi- p -> Sigma- K+ cross section parametrization, PDG data.

The PDG data is smoothed using the LOWESS algorithm. If more than one cross section was given for one p_lab value, the corresponding cross sections are averaged.

Definition at line 344 of file parametrizations.cc.

                                                         {
  if (piminusp_sigmaminuskplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(PIMINUSP_SIGMAMINUSKPLUS_P_LAB,
                                                PIMINUSP_SIGMAMINUSKPLUS_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
    piminusp_sigmaminuskplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piminusp_sigmaminuskplus_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_sigma0k0_res()

double smash::piminusp_sigma0k0_res

(

double

mandelstam_s

)

pi- p -> Sigma0 K0 cross section parametrization, resonance contribution.

The data is smoothed using the LOWESS algorithm. If more than one cross section was given for one sqrts value, the corresponding cross sections are averaged.

Definition at line 362 of file parametrizations.cc.

                                                  {
  if (piminusp_sigma0k0_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(PIMINUSP_SIGMA0K0_RES_SQRTS,
                                                PIMINUSP_SIGMA0K0_RES_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
    piminusp_sigma0k0_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double sqrts = std::sqrt(mandelstam_s);
  return (*piminusp_sigma0k0_interpolation)(sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pp_elastic()

double smash::pp_elastic

(

double

mandelstam_s

)

pp elastic cross section parametrization Source: Weil:2013mya [72], eq.

(44)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 375 of file parametrizations.cc.

                                       {
  const double p_lab = plab_from_s(mandelstam_s);
  if (p_lab < 0.435) {
    return 5.12 * nucleon_mass /
               (mandelstam_s - 4 * nucleon_mass * nucleon_mass) +
           1.67;
  } else if (p_lab < 0.8) {
    return 23.5 + 1000 * pow_int(p_lab - 0.7, 4);
  } else if (p_lab < 2.0) {
    return 1250 / (p_lab + 50) - 4 * (p_lab - 1.3) * (p_lab - 1.3);
  } else if (p_lab < 2.776) {
    return 77 / (p_lab + 1.5);
  } else {
    const auto logp = std::log(p_lab);
    return 11.9 + 26.9 * std::pow(p_lab, -1.21) + 0.169 * logp * logp -
           1.85 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pp_elastic_high_energy()

double smash::pp_elastic_high_energy	(	double	mandelstam_s,
		double	m1,
		double	m2
	)

pp elastic cross section parametrization, with only the high energy part generalized to all energy regimes (used for AQM) Source: Weil:2013mya [72], eq.

(44)

Parameters

[in]	mandelstam_s	the rest frame total energy squared [GeV^2]
[in]	m1	the mass of the first particle [GeV]
[in]	m2	the mass of the second particle [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 394 of file parametrizations.cc.

                                                                         {
  const double p_lab =
      plab_from_s_heavier_particle_at_rest(mandelstam_s, m1, m2);
  /* std::log(0) = -∞ and std::pow(0, negative) = +∞ both raise FE_DIVBYZERO.
   * Handle this case explicitly to preserve the mathematical result without
   * raising a floating-point exception. */
  if (p_lab == 0.0) {
    return std::numeric_limits<double>::infinity();
  } else {
    const auto logp = std::log(p_lab);
    return 11.9 + 26.9 * std::pow(p_lab, -1.21) + 0.169 * logp * logp -
           1.85 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pp_total()

double smash::pp_total

(

double

mandelstam_s

)

pp total cross section parametrization Sources: low-p: Cugnon:1996kh [21] highest-p: Buss:2011mx [16]

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 409 of file parametrizations.cc.

                                     {
  const double p_lab = plab_from_s(mandelstam_s);
  if (p_lab < 0.4) {
    return 34 * std::pow(p_lab / 0.4, -2.104);
  } else if (p_lab < 0.8) {
    return 23.5 + 1000 * pow_int(p_lab - 0.7, 4);
  } else if (p_lab < 1.5) {
    return 23.5 + 24.6 / (1 + std::exp(-(p_lab - 1.2) / 0.1));
  } else if (p_lab < 5.0) {
    return 41 + 60 * (p_lab - 0.9) * std::exp(-1.2 * p_lab);
  } else {
    const auto logp = std::log(p_lab);
    return 48.0 + 0.522 * logp * logp - 4.51 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

np_elastic()

double smash::np_elastic

(

double

mandelstam_s

)

np elastic cross section parametrization Source: Weil:2013mya [72], eq.

(45)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 425 of file parametrizations.cc.

                                       {
  const double p_lab = plab_from_s(mandelstam_s);
  if (p_lab < 0.525) {
    return 17.05 * nucleon_mass /
               (mandelstam_s - 4 * nucleon_mass * nucleon_mass) -
           6.83;
  } else if (p_lab < 0.8) {
    return 33 + 196 * std::pow(std::abs(p_lab - 0.95), 2.5);
  } else if (p_lab < 2.0) {
    return 31 / std::sqrt(p_lab);
  } else if (p_lab < 2.776) {
    return 77 / (p_lab + 1.5);
  } else {
    const auto logp = std::log(p_lab);
    return 11.9 + 26.9 * std::pow(p_lab, -1.21) + 0.169 * logp * logp -
           1.85 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

np_total()

double smash::np_total

(

double

mandelstam_s

)

np total cross section parametrization Sources: low-p: Cugnon:1996kh [21] highest-p: Buss:2011mx [16]

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 444 of file parametrizations.cc.

                                     {
  const double p_lab = plab_from_s(mandelstam_s);
  const auto logp = std::log(p_lab);
  if (p_lab < 0.4) {
    return 6.3555 * std::pow(p_lab, -3.2481) * std::exp(-0.377 * logp * logp);
  } else if (p_lab < 1.0) {
    return 33 + 196 * std::pow(std::abs(p_lab - 0.95), 2.5);
  } else if (p_lab < 2.0) {
    return 24.2 + 8.9 * p_lab;
  } else if (p_lab < 5.0) {
    return 42;
  } else {
    return 48.0 + 0.522 * logp * logp - 4.51 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ppbar_elastic()

double smash::ppbar_elastic

(

double

mandelstam_s

)

ppbar elastic cross section parametrization Source: Bass:1998ca [8]

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 460 of file parametrizations.cc.

                                          {
  if (mandelstam_s < 4 * nucleon_mass * nucleon_mass) {
    // Needed, since called directly from p_52
    return 0.0;
  }
  const double p_lab = plab_from_s(mandelstam_s);
  if (p_lab < 0.3) {
    return 78.6;
  } else if (p_lab < 5.0) {
    return 31.6 + 18.3 / p_lab - 1.1 / (p_lab * p_lab) - 3.8 * p_lab;
  } else {
    const auto logp = std::log(p_lab);
    return 10.2 + 52.7 * std::pow(p_lab, -1.16) + 0.125 * logp * logp -
           1.28 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ppbar_total()

double smash::ppbar_total

(

double

mandelstam_s

)

ppbar total cross section parametrization Source: Bass:1998ca [8]

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 477 of file parametrizations.cc.

                                        {
  if (mandelstam_s < 4 * nucleon_mass * nucleon_mass) {
    // Needed, since called directly from p_52
    return 0.0;
  }
  const double p_lab = plab_from_s(mandelstam_s);
  if (p_lab < 0.3) {
    return 271.6 * std::exp(-1.1 * p_lab * p_lab);
  } else if (p_lab < 5.0) {
    return 75.0 + 43.1 / p_lab + 2.6 / (p_lab * p_lab) - 3.9 * p_lab;
  } else {
    const auto logp = std::log(p_lab);
    return 38.4 + 77.6 * std::pow(p_lab, -0.64) + 0.26 * logp * logp -
           1.2 * logp;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

deuteron_pion_elastic()

double smash::deuteron_pion_elastic

(

double

mandelstam_s

)

Deuteron pion elastic cross-section [mb] parametrized to fit pi-d elastic scattering data (the data collection was be obtained from SAID data base, gwdac.phys.gwu.edu)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 494 of file parametrizations.cc.

                                                  {
  const double tmp = std::sqrt(mandelstam_s) - 2.172;
  return 4.0 + 0.27 / (tmp * tmp + 0.065 * 0.065);
}

Here is the caller graph for this function:

deuteron_nucleon_elastic()

double smash::deuteron_nucleon_elastic

(

double

mandelstam_s

)

Deuteron nucleon elastic cross-section [mb] parametrized by Oh:2009gx [46].

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 499 of file parametrizations.cc.

                                                     {
  const double excess = (mandelstam_s - 7.93);
  const double excess_sqr = excess * excess;
  return 2500.0 * std::exp(-excess_sqr / 0.003) +
         600.0 * std::exp(-excess_sqr / 0.1) + 10.0;
}

Here is the caller graph for this function:

deuteron_pion_inelastic()

double smash::deuteron_pion_inelastic

(

double

pion_kinetic_energy

)

Parametrization of deuteron-pion inelastic cross section.

Parameters

[in]

pion_kinetic_energy

pion kinetic energy [GeV] in the deuteron rest frame

Returns

cross section [mb]

Definition at line 506 of file parametrizations.cc.

                                                           {
  const double x = pion_kinetic_energy;
  return x * (4.3 + 10.0 * x) / ((x - 0.16) * (x - 0.16) + 0.007);
}

Here is the caller graph for this function:

deuteron_nucleon_inelastic()

double smash::deuteron_nucleon_inelastic

(

double

N_kinetic_energy

)

Parametrization of deuteron-nucleon inelastic cross section.

Parameters

[in]

N_kinetic_energy

Nucleon kinetic energy [GeV] in the deuteron rest frame

Returns

cross section [mb]

Definition at line 511 of file parametrizations.cc.

                                                           {
  const double x = N_kinetic_energy;
  return x * (1.0 + 50 * x) / (x * x + 0.01) +
         4 * x / ((x - 0.008) * (x - 0.008) + 0.0004);
}

Here is the caller graph for this function:

deuteron_antinucleon_inelastic()

double smash::deuteron_antinucleon_inelastic

(

double

aN_kinetic_energy

)

Parametrization of deuteron-antinucleon inelastic cross section.

Parameters

[in]

aN_kinetic_energy

[GeV] Anti-nucleon kinetic energy in the deuteron rest frame

Returns

cross section [mb]

Definition at line 517 of file parametrizations.cc.

                                                                {
  return 55.0 / (aN_kinetic_energy + 0.17);
}

Here is the caller graph for this function:

kplusp_total()

double smash::kplusp_total

(

double

mandelstam_s

)

K+ p total cross section parametrization.

Source: Buss:2011mx [16], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Note

In total parametrizations of KN processes, if the interaction energy exceeds the bounds of the interpolation, the last value available is returned, which is desired behavior.

Definition at line 521 of file parametrizations.cc.

                                         {
  if (kplusp_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KPLUSP_TOT_PLAB, KPLUSP_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
    kplusp_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusp_total_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kplusn_total()

double smash::kplusn_total

(

double

mandelstam_s

)

K+ n total cross section parametrization.

Source: Buss:2011mx [16], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Note

See this note about the return value.

Definition at line 534 of file parametrizations.cc.

                                         {
  if (kplusn_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KPLUSN_TOT_PLAB, KPLUSN_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.05, 5);
    kplusn_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusn_total_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusn_total()

double smash::kminusn_total

(

double

mandelstam_s

)

K- n total cross section parametrization.

Source: Buss:2011mx [16], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Note

See this note about return value.

Definition at line 561 of file parametrizations.cc.

                                          {
  if (kminusn_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KMINUSN_TOT_PLAB, KMINUSN_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.05, 5);
    kminusn_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kminusn_total_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusp_total()

double smash::kminusp_total

(

double

mandelstam_s

)

K- p total cross section parametrization.

Source: Buss:2011mx [16], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Note

See this note about return value.

Definition at line 547 of file parametrizations.cc.

                                          {
  if (kminusp_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KMINUSP_TOT_PLAB, KMINUSP_TOT_SIG);
    // Parametrization data KMINUSP_TOT_PLAB, KMINUSP_TOT_SIG is pre-smoothed
    dedup_y = smooth(dedup_x, dedup_y, 0.01, 5);
    kminusp_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kminusp_total_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kplusp_elastic_background()

double smash::kplusp_elastic_background

(

double

mandelstam_s

)

K+ p elastic background cross section parametrization.

sigma(K+n->K+n) = sigma(K+n->K0p) = 0.5 * sigma(K+p->K+p) Source: Buss:2011mx [16], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 574 of file parametrizations.cc.

                                                      {
  constexpr double a0 = 10.508;  // mb
  constexpr double a1 = -3.716;  // mb/GeV
  constexpr double a2 = 1.845;   // mb/GeV^2
  constexpr double a3 = -0.764;  // GeV^-1
  constexpr double a4 = 0.508;   // GeV^-2
 
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  const double p_lab2 = p_lab * p_lab;
 
  return (a0 + a1 * p_lab + a2 * p_lab2) / (1 + a3 * p_lab + a4 * p_lab2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kplusn_elastic_background()

double smash::kplusn_elastic_background

(

double

mandelstam_s

)

K+ n elastic background cross section parametrization sigma(K+n->K+n) = sigma(K+n->K0p) = 0.5 * sigma(K+p->K+p) Source: Buss:2011mx [16], B.3.8.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 587 of file parametrizations.cc.

                                                      {
  return 0.25 * kplusp_elastic_background(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kplusn_k0p()

double smash::kplusn_k0p

(

double

mandelstam_s

)

K+ n charge exchange cross section parametrization.

sigma(K+n->K+n) = sigma(K+n->K0p) = 0.5 * sigma(K+p->K+p) Source: Buss:2011mx [16], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 591 of file parametrizations.cc.

                                       {
  return 0.25 * kplusp_elastic_background(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusp_elastic_background()

double smash::kminusp_elastic_background

(

double

mandelstam_s

)

K- p elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 613 of file parametrizations.cc.

                                                       {
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  double sigma;
  if (std::sqrt(mandelstam_s) < 1.68) {
    /* The parametrization here also works for anti-K0 n, Lambda pi0,
     * Sigma+ pi-, Sigma- pi+, Sigma0 pi0 with different parameters a0, a1, a2.
     *
     * The values of the parameters are *not* taken from the source above,
     * they come from a fit to PDG data. */
    constexpr double a0 = 186.03567644;  // mb GeV^2
    constexpr double a1 = 0.22002795;    // Gev
    constexpr double a2 = 0.64907116;
 
    /* In sigma a ratio p_i/p_f is omitted as both are set to p_lab. Keeping it
     * is unnecessary and it would trigger a FPE if p_lab were zero. */
    const double ratio = a1 * a1 / (a1 * a1 + p_lab * p_lab);
    sigma = a0 / mandelstam_s * std::pow(ratio, a2);
  } else {
    sigma = kminusp_elastic_pdg(mandelstam_s);
  }
  // The elastic contributions from decays still need to be subtracted.
  if (kminusp_elastic_res_interpolation == nullptr) {
    std::vector<double> x = KMINUSP_RES_SQRTS;
    for (auto& i : x) {
      i = plab_from_s(i * i, kaon_mass, nucleon_mass);
    }
    std::vector<double> y = KMINUSP_RES_SIG;
    kminusp_elastic_res_interpolation = std::make_unique<InterpolateDataSpline>(
        x, y, ExtrapolationType::Constant);
  }
  const auto old_sigma = sigma;
  sigma -= (*kminusp_elastic_res_interpolation)(p_lab);
  if (sigma < 0) {
    std::cout << "NEGATIVE SIGMA: sigma=" << sigma
              << ", sqrt(s)=" << std::sqrt(mandelstam_s)
              << ", sig_el_exp=" << old_sigma
              << ", sig_el_res=" << (*kminusp_elastic_res_interpolation)(p_lab)
              << std::endl;
  }
  assert(sigma >= 0);
  return sigma;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusn_elastic_background()

double smash::kminusn_elastic_background

(

double

mandelstam_s

)

K- n elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 656 of file parametrizations.cc.

{ return 4.0; }

Here is the caller graph for this function:

k0p_elastic_background()

double smash::k0p_elastic_background

(

double

mandelstam_s

)

K0 p elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 658 of file parametrizations.cc.

                                                   {
  // by isospin symmetry
  return kplusn_elastic_background(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

k0n_elastic_background()

double smash::k0n_elastic_background

(

double

mandelstam_s

)

K0 n elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 663 of file parametrizations.cc.

                                                   {
  // by isospin symmetry
  return kplusp_elastic_background(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kbar0p_elastic_background()

double smash::kbar0p_elastic_background

(

double

mandelstam_s

)

Kbar0 p elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 668 of file parametrizations.cc.

                                                      {
  // by isospin symmetry
  return kminusn_elastic_background(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kbar0n_elastic_background()

double smash::kbar0n_elastic_background

(

double

mandelstam_s

)

Kbar0 n elastic background cross section parametrization Source: Buss:2011mx [16], B.3.9.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 673 of file parametrizations.cc.

                                                      {
  // by isospin symmetry
  return kminusp_elastic_background(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kplusp_inelastic_background()

double smash::kplusp_inelastic_background

(

double

mandelstam_s

)

K+ p inelastic background cross section parametrization Source: Buss:2011mx [16], B.3.8.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 678 of file parametrizations.cc.

                                                        {
  if (kplusp_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KPLUSP_TOT_PLAB, KPLUSP_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
    kplusp_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusp_total_interpolation)(p_lab)-kplusp_elastic_background(
      mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kplusn_inelastic_background()

double smash::kplusn_inelastic_background

(

double

mandelstam_s

)

K+ n inelastic background cross section parametrization Source: Buss:2011mx [16], B.3.8.

This interpolates the experimental data of the total cross section and subtracts the elastic and charge exchange cross section.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 692 of file parametrizations.cc.

                                                        {
  if (kplusn_total_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KPLUSN_TOT_PLAB, KPLUSN_TOT_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.05, 5);
    kplusn_total_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusn_total_interpolation)(p_lab)-kplusn_elastic_background(
             mandelstam_s) -
         kplusn_k0p(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusp_kbar0n()

double smash::kminusp_kbar0n

(

double

mandelstam_s

)

K- p <-> Kbar0 n cross section parametrization.

Source: Buss:2011mx [16], B.3.9

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 811 of file parametrizations.cc.

                                           {
  constexpr double a0 = 100;   // mb GeV^2
  constexpr double a1 = 0.15;  // GeV
  constexpr unsigned a2 = 2;
 
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
 
  /* In this expression a ratio p_i/p_f is omitted as both are set to p_lab.
   * Keeping it is unnecessary and it would trigger a FPE if p_lab were zero. */
  return a0 / mandelstam_s * pow_int(a1 * a1 / (a1 * a1 + p_lab * p_lab), a2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusp_piminussigmaplus()

double smash::kminusp_piminussigmaplus

(

double

sqrts

)

K- p <-> pi- Sigma+ cross section parametrization Taken from UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 823 of file parametrizations.cc.

                                              {
  return 0.0788265 / ((sqrts - 1.38841) * (sqrts - 1.38841));
}

Here is the caller graph for this function:

kminusp_piplussigmaminus()

double smash::kminusp_piplussigmaminus

(

double

sqrts

)

K- p <-> pi+ Sigma- cross section parametrization Taken from UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 827 of file parametrizations.cc.

                                              {
  return 0.0196741 / ((sqrts - 1.42318) * (sqrts - 1.42318));
}

Here is the caller graph for this function:

kminusp_pi0sigma0()

double smash::kminusp_pi0sigma0

(

double

sqrts

)

K- p <-> pi0 Sigma0 cross section parametrization Fit to Landolt-Börnstein instead of UrQMD values.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 831 of file parametrizations.cc.

                                       {
  return 0.0403364 / ((sqrts - 1.39830305) * (sqrts - 1.39830305));
}

Here is the caller graph for this function:

kminusp_pi0lambda()

double smash::kminusp_pi0lambda

(

double

sqrts

)

K- p <-> pi0 Lambda cross section parametrization Fit to Landolt-Börnstein instead of UrQMD values.

Todo:

clarify this

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 835 of file parametrizations.cc.

                                       {
  return 0.05932562 / ((sqrts - 1.38786692) * (sqrts - 1.38786692));
}

Here is the caller graph for this function:

kminusn_piminussigma0()

double smash::kminusn_piminussigma0

(

double

sqrts

)

K- n <-> pi- Sigma0 cross section parametrization Follow from the parametrization with the same strange product via isospin symmetry.

K- n <-> pi0 Sigma- cross section parametrization is also handled with this.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 839 of file parametrizations.cc.

                                           {
  return kminusp_piminussigmaplus(sqrts) + kminusp_piplussigmaminus(sqrts) -
         2. * kminusp_pi0sigma0(sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusn_piminuslambda()

double smash::kminusn_piminuslambda

(

double

sqrts

)

K- n <-> pi- Lambda cross section parametrization Follow from the parametrization with the same strange product via isospin symmetry.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 844 of file parametrizations.cc.

                                           {
  return 2. * kminusp_pi0lambda(sqrts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

lambdalambda_ximinusp()

double smash::lambdalambda_ximinusp	(	double	sqrts_sqrts0,
		double	p_N,
		double	p_lambda
	)

Lambda Lambda <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]	sqrts_sqrts0	the rest frame total energy minus threshold energy [GeV]
[in]	p_N	momentum of outgoing nucleon in center of mass frame [GeV]
[in]	p_lambda	momentum of incoming lambda in center of mass frame [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 850 of file parametrizations.cc.

                                                                               {
  assert(p_lambda != 0);
  assert(sqrts_sqrts0 >= 0);
  return 37.15 / 2 * p_N / p_lambda * std::pow(sqrts_sqrts0, -0.16);
}

Here is the caller graph for this function:

lambdalambda_xi0n()

double smash::lambdalambda_xi0n	(	double	sqrts_sqrts0,
		double	p_N,
		double	p_lambda
	)

Lambda Lambda <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]	sqrts_sqrts0	the rest frame total energy minus threshold energy [GeV]
[in]	p_N	momentum of outgoing nucleon in center of mass frame [GeV]
[in]	p_lambda	momentum of incoming lambda in center of mass frame [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 856 of file parametrizations.cc.

                                                                           {
  return lambdalambda_ximinusp(sqrts_sqrts0, p_N, p_lambda);
}

Here is the call graph for this function:

lambdasigmaplus_xi0p()

double smash::lambdasigmaplus_xi0p

(

double

sqrts_sqrts0

)

Lambda Sigma+ <-> Xi0 p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 860 of file parametrizations.cc.

                                                 {
  assert(sqrts_sqrts0 >= 0);
  return 24.3781 * std::pow(sqrts_sqrts0, -0.479);
}

Here is the caller graph for this function:

lambdasigmaminus_ximinusn()

double smash::lambdasigmaminus_ximinusn

(

double

sqrts_sqrts0

)

Lambda Sigma- <-> Xi- n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 865 of file parametrizations.cc.

                                                      {
  return lambdasigmaplus_xi0p(sqrts_sqrts0);
}

Here is the call graph for this function:

lambdasigma0_ximinusp()

double smash::lambdasigma0_ximinusp

(

double

sqrts_sqrts0

)

Lambda Sigma0 <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 869 of file parametrizations.cc.

                                                  {
  assert(sqrts_sqrts0 >= 0);
  if (sqrts_sqrts0 < 0.03336) {
    return 6.475 * std::pow(sqrts_sqrts0, -0.4167);
  } else {
    return 14.5054 * std::pow(sqrts_sqrts0, -0.1795);
  }
}

Here is the caller graph for this function:

lambdasigma0_xi0n()

double smash::lambdasigma0_xi0n

(

double

sqrts_sqrts0

)

Lambda Sigma0 <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 878 of file parametrizations.cc.

                                              {
  return lambdasigma0_ximinusp(sqrts_sqrts0);
}

Here is the call graph for this function:

sigma0sigma0_ximinusp()

double smash::sigma0sigma0_ximinusp

(

double

sqrts_sqrts0

)

Sigma0 Sigma0 <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 882 of file parametrizations.cc.

                                                  {
  assert(sqrts_sqrts0 >= 0);
  if (sqrts_sqrts0 < 0.09047) {
    return 5.625 * std::pow(sqrts_sqrts0, -0.318);
  } else {
    return 4.174 * std::pow(sqrts_sqrts0, -0.4421);
  }
}

Here is the caller graph for this function:

sigma0sigma0_xi0n()

double smash::sigma0sigma0_xi0n

(

double

sqrts_sqrts0

)

Sigma0 Sigma0 <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Note that there is a typo in the paper in equation (6): "Lambda Sigma0 -> Xi0 n" should be "Sigma0 Sigma0 -> Xi0 n".

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 891 of file parametrizations.cc.

                                              {
  return sigma0sigma0_ximinusp(sqrts_sqrts0);
}

Here is the call graph for this function:

sigmaplussigmaminus_xi0p()

double smash::sigmaplussigmaminus_xi0p

(

double

sqrts_sqrts0

)

Sigma+ Sigma- <-> Xi0 p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 895 of file parametrizations.cc.

                                                     {
  return 4 * sigma0sigma0_ximinusp(sqrts_sqrts0);
}

Here is the call graph for this function:

sigma0sigmaminus_ximinusn()

double smash::sigma0sigmaminus_ximinusn

(

double

sqrts_sqrts0

)

Sigma0 Sigma- <-> Xi- n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 899 of file parametrizations.cc.

                                                      {
  return 4 * sigma0sigma0_ximinusp(sqrts_sqrts0);
}

Here is the call graph for this function:

sigmaplussigmaminus_ximinusp()

double smash::sigmaplussigmaminus_ximinusp

(

double

sqrts_sqrts0

)

Sigma+ Sigma- <-> Xi- p cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 903 of file parametrizations.cc.

                                                         {
  return 14.194 * std::pow(sqrts_sqrts0, -0.442);
}

Here is the caller graph for this function:

sigmaplussigmaminus_xi0n()

double smash::sigmaplussigmaminus_xi0n

(

double

sqrts_sqrts0

)

Sigma+ Sigma- <-> Xi0 n cross section parametrization Two hyperon exchange, based on effective model by Feng Li, as in UrQMD (Graef:2014mra [28]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 907 of file parametrizations.cc.

                                                     {
  return sigmaplussigmaminus_ximinusp(sqrts_sqrts0);
}

Here is the call graph for this function:

Dzeropiplus_elastic()

std::optional< double > smash::Dzeropiplus_elastic

(

double

sqrts

)

D⁰π⁺ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰π⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 911 of file parametrizations.cc.

                                                      {
  if (sqrts > *(DPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dzeropiplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DPI_SQRTS, DZEROPIPLUS_ELASTIC_SIG);
      Dzeropiplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dzeropiplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dzeropiplus_Dpluspizero()

double smash::Dzeropiplus_Dpluspizero

(

double

sqrts

)

D⁰π⁺ -> D⁺π⁰ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰π⁻ -> D⁻π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 926 of file parametrizations.cc.

                                             {
  if (Dzeropiplus_Dpluspizero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DPI_SQRTS, DZEROPIPLUS_DPLUSPIZERO_SIG);
    Dzeropiplus_Dpluspizero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dzeropiplus_Dpluspizero_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dzeropiminus_elastic()

std::optional< double > smash::Dzeropiminus_elastic

(

double

sqrts

)

D⁰π⁻ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰π⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 937 of file parametrizations.cc.

                                                       {
  if (sqrts > *(DPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dzeropiminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DPI_SQRTS, DZEROPIMINUS_ELASTIC_SIG);
      Dzeropiminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dzeropiminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dzeropizero_elastic()

std::optional< double > smash::Dzeropizero_elastic

(

double

sqrts

)

D⁰π⁰ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 952 of file parametrizations.cc.

                                                      {
  if (sqrts > *(DPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dzeropizero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DPI_SQRTS, DZEROPIZERO_ELASTIC_SIG);
      Dzeropizero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dzeropizero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dzeropizero_Dpluspiminus()

double smash::Dzeropizero_Dpluspiminus

(

double

sqrts

)

D⁰π⁰ -> D⁺π⁻ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰π⁰ -> D⁻π⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 967 of file parametrizations.cc.

                                              {
  if (Dzeropizero_Dpluspiminus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DPI_SQRTS, DZEROPIZERO_DPLUSPIMINUS_SIG);
    Dzeropizero_Dpluspiminus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dzeropizero_Dpluspiminus_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dpluspiplus_elastic()

std::optional< double > smash::Dpluspiplus_elastic

(

double

sqrts

)

D⁺π⁺ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻π⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 978 of file parametrizations.cc.

                                                      {
  if (sqrts > *(DPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dpluspiplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DPI_SQRTS, DPLUSPIPLUS_ELASTIC_SIG);
      Dpluspiplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dpluspiplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dpluspiminus_elastic()

std::optional< double > smash::Dpluspiminus_elastic

(

double

sqrts

)

D⁺π⁻ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻π⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 993 of file parametrizations.cc.

                                                       {
  if (sqrts > *(DPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dpluspiminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DPI_SQRTS, DPLUSPIMINUS_ELASTIC_SIG);
      Dpluspiminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dpluspiminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dpluspiminus_Dzeropizero()

double smash::Dpluspiminus_Dzeropizero

(

double

sqrts

)

D⁺π⁻ -> D⁰π⁰ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻π⁺ -> D̄⁰π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1008 of file parametrizations.cc.

                                              {
  if (Dpluspiminus_Dzeropizero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DPI_SQRTS, DPLUSPIMINUS_DZEROPIZERO_SIG);
    Dpluspiminus_Dzeropizero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dpluspiminus_Dzeropizero_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dpluspizero_elastic()

std::optional< double > smash::Dpluspizero_elastic

(

double

sqrts

)

D⁺π⁰ elastic cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1019 of file parametrizations.cc.

                                                      {
  if (sqrts > *(DPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dpluspizero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DPI_SQRTS, DPLUSPIZERO_ELASTIC_SIG);
      Dpluspizero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dpluspizero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dpluspizero_Dzeropiplus()

double smash::Dpluspizero_Dzeropiplus

(

double

sqrts

)

D⁺π⁰ -> D⁰π⁺ cross section (Abreu:2011ic [1], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻π⁰ -> D̄⁰π⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1034 of file parametrizations.cc.

                                             {
  if (Dpluspizero_Dzeropiplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DPI_SQRTS, DPLUSPIZERO_DZEROPIPLUS_SIG);
    Dpluspizero_Dzeropiplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dpluspizero_Dzeropiplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dpluseta_elastic()

std::optional< double > smash::Dpluseta_elastic

(

double

sqrts

)

D⁺η elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻η is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1045 of file parametrizations.cc.

                                                   {
  if (sqrts > *(DETA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dpluseta_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DETA_SQRTS, DPLUSETA_ELASTIC_SIG);
      Dpluseta_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dpluseta_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dzeroeta_elastic()

std::optional< double > smash::Dzeroeta_elastic

(

double

sqrts

)

D⁰η elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰η is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1060 of file parametrizations.cc.

                                                   {
  if (sqrts > *(DETA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dzeroeta_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DETA_SQRTS, DZEROETA_ELASTIC_SIG);
      Dzeroeta_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dzeroeta_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusKplus_elastic()

std::optional< double > smash::DplusKplus_elastic

(

double

sqrts

)

D⁺K⁺ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻K⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1075 of file parametrizations.cc.

                                                     {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusKplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DPLUSKPLUS_ELASTIC_SIG);
      DplusKplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusKplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusKzero_elastic()

std::optional< double > smash::DplusKzero_elastic

(

double

sqrts

)

D⁺K⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻K̄⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1090 of file parametrizations.cc.

                                                     {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusKzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DPLUSKZERO_ELASTIC_SIG);
      DplusKzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusKzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusKzero_DzeroKplus()

double smash::DplusKzero_DzeroKplus

(

double

sqrts

)

D⁺K⁰ -> D⁰K⁺ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻K̄⁰ -> D̄⁰K⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1105 of file parametrizations.cc.

                                           {
  if (DplusKzero_DzeroKplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DKAON_SQRTS, DPLUSKZERO_DZEROKPLUS_SIG);
    DplusKzero_DzeroKplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DplusKzero_DzeroKplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroKplus_DplusKzero()

double smash::DzeroKplus_DplusKzero

(

double

sqrts

)

D⁰K⁺ -> D⁺K⁰ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰K⁻ -> D⁻K̄⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1116 of file parametrizations.cc.

                                           {
  if (DzeroKplus_DplusKzero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DKAON_SQRTS, DZEROKPLUS_DPLUSKZERO_SIG);
    DzeroKplus_DplusKzero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DzeroKplus_DplusKzero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroKplus_elastic()

std::optional< double > smash::DzeroKplus_elastic

(

double

sqrts

)

D⁰K⁺ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰K⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1127 of file parametrizations.cc.

                                                     {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroKplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DZEROKPLUS_ELASTIC_SIG);
      DzeroKplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroKplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DzeroKzero_elastic()

std::optional< double > smash::DzeroKzero_elastic

(

double

sqrts

)

D⁰K⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰K̄⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1142 of file parametrizations.cc.

                                                     {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroKzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DZEROKZERO_ELASTIC_SIG);
      DzeroKzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroKzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusKbarzero_elastic()

std::optional< double > smash::DplusKbarzero_elastic

(

double

sqrts

)

D⁺K̄⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻K⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1157 of file parametrizations.cc.

                                                        {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusKbarzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DPLUSKBARZERO_ELASTIC_SIG);
      DplusKbarzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusKbarzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusKminus_elastic()

std::optional< double > smash::DplusKminus_elastic

(

double

sqrts

)

D⁺K⁻ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻K⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1172 of file parametrizations.cc.

                                                      {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusKminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DPLUSKMINUS_ELASTIC_SIG);
      DplusKminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusKminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusKminus_DzeroKbarzero()

double smash::DplusKminus_DzeroKbarzero

(

double

sqrts

)

D⁺K⁻ -> D⁰K̄⁰ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D⁻K⁺ -> D̄⁰K⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1187 of file parametrizations.cc.

                                               {
  if (DplusKminus_DzeroKbarzero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DKAON_SQRTS, DPLUSKMINUS_DZEROKBARZERO_SIG);
    DplusKminus_DzeroKbarzero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DplusKminus_DzeroKbarzero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroKbarzero_DplusKminus()

double smash::DzeroKbarzero_DplusKminus

(

double

sqrts

)

D⁰K̄⁰ -> D⁺K⁻ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰K⁰ -> D⁻K⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1198 of file parametrizations.cc.

                                               {
  if (DzeroKbarzero_DplusKminus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DKAON_SQRTS, DZEROKBARZERO_DPLUSKMINUS_SIG);
    DzeroKbarzero_DplusKminus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DzeroKbarzero_DplusKminus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroKbarzero_elastic()

std::optional< double > smash::DzeroKbarzero_elastic

(

double

sqrts

)

D⁰K̄⁰ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰K⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1209 of file parametrizations.cc.

                                                        {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroKbarzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DZEROKBARZERO_ELASTIC_SIG);
      DzeroKbarzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroKbarzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DzeroKminus_elastic()

std::optional< double > smash::DzeroKminus_elastic

(

double

sqrts

)

D⁰K⁻ elastic cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄⁰K⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1224 of file parametrizations.cc.

                                                      {
  if (sqrts > *(DKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroKminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DKAON_SQRTS, DZEROKMINUS_ELASTIC_SIG);
      DzeroKminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroKminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarpluspiplus_elastic()

std::optional< double > smash::Dstarpluspiplus_elastic

(

double

sqrts

)

D*(2010)⁺π⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻π⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1239 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DSTARPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarpluspiplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARPI_SQRTS, DSTARPLUSPIPLUS_ELASTIC_SIG);
      Dstarpluspiplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarpluspiplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarpluspiminus_elastic()

std::optional< double > smash::Dstarpluspiminus_elastic

(

double

sqrts

)

D*(2010)⁺π⁻ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻π⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1254 of file parametrizations.cc.

                                                           {
  if (sqrts > *(DSTARPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarpluspiminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARPI_SQRTS, DSTARPLUSPIMINUS_ELASTIC_SIG);
      Dstarpluspiminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarpluspiminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarpluspiminus_Dstarzeropizero()

double smash::Dstarpluspiminus_Dstarzeropizero

(

double

sqrts

)

D*(2010)⁺π⁻ -> D*(2007)⁰π⁰ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻π⁺ -> D̄*(2007)⁰π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1269 of file parametrizations.cc.

                                                      {
  if (Dstarpluspiminus_Dstarzeropizero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DSTARPI_SQRTS, DSTARPLUSPIMINUS_DSTARZEROPIZERO_SIG);
    Dstarpluspiminus_Dstarzeropizero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dstarpluspiminus_Dstarzeropizero_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dstarpluspizero_elastic()

std::optional< double > smash::Dstarpluspizero_elastic

(

double

sqrts

)

D*(2010)⁺π⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1280 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DSTARPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarpluspizero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARPI_SQRTS, DSTARPLUSPIZERO_ELASTIC_SIG);
      Dstarpluspizero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarpluspizero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarpluspizero_Dstarzeropiplus()

double smash::Dstarpluspizero_Dstarzeropiplus

(

double

sqrts

)

D*(2010)⁺π⁰ -> D*(2007)⁰π⁺ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻π⁰ -> D̄*(2007)⁰π⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1295 of file parametrizations.cc.

                                                     {
  if (Dstarpluspizero_Dstarzeropiplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DSTARPI_SQRTS, DSTARPLUSPIZERO_DSTARZEROPIPLUS_SIG);
    Dstarpluspizero_Dstarzeropiplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dstarpluspizero_Dstarzeropiplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dstarzeropiplus_Dstarpluspizero()

double smash::Dstarzeropiplus_Dstarpluspizero

(

double

sqrts

)

D*(2007)⁰π⁺ -> D*(2010)⁺π⁰ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰π⁻ -> D*(2010)⁻π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1306 of file parametrizations.cc.

                                                     {
  if (Dstarzeropiplus_Dstarpluspizero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DSTARPI_SQRTS, DSTARZEROPIPLUS_DSTARPLUSPIZERO_SIG);
    Dstarzeropiplus_Dstarpluspizero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dstarzeropiplus_Dstarpluspizero_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dstarzeropiplus_elastic()

std::optional< double > smash::Dstarzeropiplus_elastic

(

double

sqrts

)

D*(2007)⁰π⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰π⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1317 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DSTARPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarzeropiplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARPI_SQRTS, DSTARZEROPIPLUS_ELASTIC_SIG);
      Dstarzeropiplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarzeropiplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarzeropiminus_elastic()

std::optional< double > smash::Dstarzeropiminus_elastic

(

double

sqrts

)

D*(2007)⁰π- elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰π⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1332 of file parametrizations.cc.

                                                           {
  if (sqrts > *(DSTARPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarzeropiminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARPI_SQRTS, DSTARZEROPIMINUS_ELASTIC_SIG);
      Dstarzeropiminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarzeropiminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarzeropizero_Dstarpluspiminus()

double smash::Dstarzeropizero_Dstarpluspiminus

(

double

sqrts

)

D*(2007)⁰π⁰ -> D*(2010)⁺π⁻ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰π⁰ -> D*(2010)⁻π⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1347 of file parametrizations.cc.

                                                      {
  if (Dstarzeropizero_Dstarpluspiminus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DSTARPI_SQRTS, DSTARZEROPIZERO_DSTARPLUSPIMINUS_SIG);
    Dstarzeropizero_Dstarpluspiminus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dstarzeropizero_Dstarpluspiminus_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dstarzeropizero_elastic()

std::optional< double > smash::Dstarzeropizero_elastic

(

double

sqrts

)

D*(2007)⁰π⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰π⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1358 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DSTARPI_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarzeropizero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARPI_SQRTS, DSTARZEROPIZERO_ELASTIC_SIG);
      Dstarzeropizero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarzeropizero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarpluseta_elastic()

std::optional< double > smash::Dstarpluseta_elastic

(

double

sqrts

)

D*(2010)⁺η elastic cross section (data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻η is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1373 of file parametrizations.cc.

                                                       {
  if (sqrts > *(DSTARETA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarpluseta_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARETA_SQRTS, DSTARPLUSETA_ELASTIC_SIG);
      Dstarpluseta_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarpluseta_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dstarzeroeta_elastic()

std::optional< double > smash::Dstarzeroeta_elastic

(

double

sqrts

)

D*(2007)⁰η elastic cross section (data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰η is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1388 of file parametrizations.cc.

                                                       {
  if (sqrts > *(DSTARETA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dstarzeroeta_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARETA_SQRTS, DSTARZEROETA_ELASTIC_SIG);
      Dstarzeroeta_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dstarzeroeta_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarplusKplus_elastic()

std::optional< double > smash::DstarplusKplus_elastic

(

double

sqrts

)

D*(2010)⁺K⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻K⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1403 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarplusKplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARPLUSKPLUS_ELASTIC_SIG);
      DstarplusKplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarplusKplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarplusKzero_elastic()

std::optional< double > smash::DstarplusKzero_elastic

(

double

sqrts

)

D*(2010)⁺K⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻K̄⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1418 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarplusKzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARPLUSKZERO_ELASTIC_SIG);
      DstarplusKzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarplusKzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarplusKzero_DstarzeroKplus()

double smash::DstarplusKzero_DstarzeroKplus

(

double

sqrts

)

D*(2010)⁺K⁰ -> D*(2007)⁰K⁺ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻K̄⁰ -> D̄*(2007)⁰K⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1433 of file parametrizations.cc.

                                                   {
  if (DstarplusKzero_DstarzeroKplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DSTARKAON_SQRTS, DSTARPLUSKZERO_DSTARZEROKPLUS_SIG);
    DstarplusKzero_DstarzeroKplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DstarplusKzero_DstarzeroKplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DstarzeroKplus_DstarplusKzero()

double smash::DstarzeroKplus_DstarplusKzero

(

double

sqrts

)

D*(2007)⁰K⁺ -> D*(2010)⁺K⁰ cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰K⁻ -> D*(2010)⁻K̄⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1444 of file parametrizations.cc.

                                                   {
  if (DstarzeroKplus_DstarplusKzero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DSTARKAON_SQRTS, DSTARZEROKPLUS_DSTARPLUSKZERO_SIG);
    DstarzeroKplus_DstarplusKzero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DstarzeroKplus_DstarplusKzero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DstarzeroKplus_elastic()

std::optional< double > smash::DstarzeroKplus_elastic

(

double

sqrts

)

D*(2007)⁰K⁺ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰K⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1455 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarzeroKplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARZEROKPLUS_ELASTIC_SIG);
      DstarzeroKplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarzeroKplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarzeroKzero_elastic()

std::optional< double > smash::DstarzeroKzero_elastic

(

double

sqrts

)

D*(2007)⁰K⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰K̄⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1470 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarzeroKzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARZEROKZERO_ELASTIC_SIG);
      DstarzeroKzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarzeroKzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarplusKbarzero_elastic()

std::optional< double > smash::DstarplusKbarzero_elastic

(

double

sqrts

)

D*(2010)⁺K̄⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻K⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1485 of file parametrizations.cc.

                                                            {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarplusKbarzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARPLUSKBARZERO_ELASTIC_SIG);
      DstarplusKbarzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarplusKbarzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarplusKminus_elastic()

std::optional< double > smash::DstarplusKminus_elastic

(

double

sqrts

)

D*(2010)⁺K⁻ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻K⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1500 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarplusKminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARPLUSKMINUS_ELASTIC_SIG);
      DstarplusKminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarplusKminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarplusKminus_DstarzeroKbarzero()

double smash::DstarplusKminus_DstarzeroKbarzero

(

double

sqrts

)

D*(2010)⁺K⁻ -> D*(2007)⁰K̄⁰ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D*(2010)⁻K⁺ -> D̄*(2007)⁰K⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1515 of file parametrizations.cc.

                                                       {
  if (DstarplusKminus_DstarzeroKbarzero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DSTARKAON_SQRTS, DSTARPLUSKMINUS_DSTARZEROKBARZERO_SIG);
    DstarplusKminus_DstarzeroKbarzero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DstarplusKminus_DstarzeroKbarzero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DstarzeroKbarzero_DstarplusKminus()

double smash::DstarzeroKbarzero_DstarplusKminus

(

double

sqrts

)

D*(2007)⁰K̄⁰ -> D*(2010)⁺K⁻ cross section (Tolos:2013kva [69], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰K⁰ -> D*(2010)⁻K⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1526 of file parametrizations.cc.

                                                       {
  if (DstarzeroKbarzero_DstarplusKminus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DSTARKAON_SQRTS, DSTARZEROKBARZERO_DSTARPLUSKMINUS_SIG);
    DstarzeroKbarzero_DstarplusKminus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DstarzeroKbarzero_DstarplusKminus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DstarzeroKbarzero_elastic()

std::optional< double > smash::DstarzeroKbarzero_elastic

(

double

sqrts

)

D*(2007)⁰K̄⁰ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰K⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1537 of file parametrizations.cc.

                                                            {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarzeroKbarzero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARZEROKBARZERO_ELASTIC_SIG);
      DstarzeroKbarzero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarzeroKbarzero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DstarzeroKminus_elastic()

std::optional< double > smash::DstarzeroKminus_elastic

(

double

sqrts

)

D*(2007)⁰K⁻ elastic cross section (closest reference Song:2015sfa [62], data provided by Juan Torres-Rincon).

Charge conjugated cross section D̄*(2007)⁰K⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1552 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DSTARKAON_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DstarzeroKminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DSTARKAON_SQRTS, DSTARZEROKMINUS_ELASTIC_SIG);
      DstarzeroKminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DstarzeroKminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dplusn_elastic()

std::optional< double > smash::Dplusn_elastic

(

double

sqrts

)

D⁺n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻n̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1567 of file parametrizations.cc.

                                                 {
  if (sqrts > *(DN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dplusn_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] = dedup_avg<double>(DN_SQRTS, DPLUSN_ELASTIC_SIG);
      Dplusn_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dplusn_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dplusn_Dzerop()

double smash::Dplusn_Dzerop

(

double

sqrts

)

D⁺n -> D⁰p cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻n̄ -> D̄⁰p̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1581 of file parametrizations.cc.

                                   {
  if (Dplusn_Dzerop_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(DN_SQRTS, DPLUSN_DZEROP_SIG);
    Dplusn_Dzerop_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dplusn_Dzerop_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dplusp_elastic()

std::optional< double > smash::Dplusp_elastic

(

double

sqrts

)

D⁺p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻p̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1591 of file parametrizations.cc.

                                                 {
  if (sqrts > *(DN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dplusp_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] = dedup_avg<double>(DN_SQRTS, DPLUSP_ELASTIC_SIG);
      Dplusp_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dplusp_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dzeron_elastic()

std::optional< double > smash::Dzeron_elastic

(

double

sqrts

)

D⁰n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰n̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1605 of file parametrizations.cc.

                                                 {
  if (sqrts > *(DN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dzeron_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] = dedup_avg<double>(DN_SQRTS, DZERON_ELASTIC_SIG);
      Dzeron_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dzeron_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dzerop_Dplusn()

double smash::Dzerop_Dplusn

(

double

sqrts

)

D⁰p -> D⁺n cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰p̄ -> D⁻n̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1619 of file parametrizations.cc.

                                   {
  if (Dzerop_Dplusn_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(DN_SQRTS, DZEROP_DPLUSN_SIG);
    Dzerop_Dplusn_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dzerop_Dplusn_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dzerop_elastic()

std::optional< double > smash::Dzerop_elastic

(

double

sqrts

)

D⁰p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰p̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1629 of file parametrizations.cc.

                                                 {
  if (sqrts > *(DN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dzerop_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] = dedup_avg<double>(DN_SQRTS, DZEROP_ELASTIC_SIG);
      Dzerop_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dzerop_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dminusn_elastic()

std::optional< double > smash::Dminusn_elastic

(

double

sqrts

)

D⁻n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺n̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1643 of file parametrizations.cc.

                                                  {
  if (sqrts > *(DBARN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dminusn_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARN_SQRTS, DMINUSN_ELASTIC_SIG);
      Dminusn_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dminusn_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dminusp_elastic()

std::optional< double > smash::Dminusp_elastic

(

double

sqrts

)

D⁻p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺p̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1658 of file parametrizations.cc.

                                                  {
  if (sqrts > *(DBARN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dminusp_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARN_SQRTS, DMINUSP_ELASTIC_SIG);
      Dminusp_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dminusp_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dminusp_Dbarzeron()

double smash::Dminusp_Dbarzeron

(

double

sqrts

)

D⁻p -> D̄⁰n cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺p̄ -> D⁰n̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1673 of file parametrizations.cc.

                                       {
  if (Dminusp_Dbarzeron_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DBARN_SQRTS, DMINUSP_DBARZERON_SIG);
    Dminusp_Dbarzeron_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dminusp_Dbarzeron_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dbarzeron_Dminusp()

double smash::Dbarzeron_Dminusp

(

double

sqrts

)

D̄⁰n -> D⁻p cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰n̄ -> D⁺p̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1684 of file parametrizations.cc.

                                       {
  if (Dbarzeron_Dminusp_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DBARN_SQRTS, DBARZERON_DMINUSP_SIG);
    Dbarzeron_Dminusp_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*Dbarzeron_Dminusp_interpolation)(sqrts);
}

Here is the caller graph for this function:

Dbarzeron_elastic()

std::optional< double > smash::Dbarzeron_elastic

(

double

sqrts

)

D̄⁰n elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰n̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1695 of file parametrizations.cc.

                                                    {
  if (sqrts > *(DBARN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dbarzeron_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARN_SQRTS, DBARZERON_ELASTIC_SIG);
      Dbarzeron_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dbarzeron_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

Dbarzerop_elastic()

std::optional< double > smash::Dbarzerop_elastic

(

double

sqrts

)

D̄⁰p elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰p̄ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1710 of file parametrizations.cc.

                                                    {
  if (sqrts > *(DBARN_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (Dbarzerop_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARN_SQRTS, DBARZEROP_ELASTIC_SIG);
      Dbarzerop_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*Dbarzerop_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusDeltaplus_elastic()

std::optional< double > smash::DplusDeltaplus_elastic

(

double

sqrts

)

D⁺Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1725 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusDeltaplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAPLUS_ELASTIC_SIG);
      DplusDeltaplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusDeltaplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusDeltaplus_DzeroDeltaplusplus()

double smash::DplusDeltaplus_DzeroDeltaplusplus

(

double

sqrts

)

D⁺Δ⁺ -> D⁰Δ⁺⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁻ -> D̄⁰Δ̅⁻⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1740 of file parametrizations.cc.

                                                       {
  if (DplusDeltaplus_DzeroDeltaplusplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAPLUS_DZERODELTAPLUSPLUS_SIG);
    DplusDeltaplus_DzeroDeltaplusplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DplusDeltaplus_DzeroDeltaplusplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DplusDeltaplusplus_elastic()

std::optional< double > smash::DplusDeltaplusplus_elastic

(

double

sqrts

)

D⁺Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁻⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1751 of file parametrizations.cc.

                                                             {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusDeltaplusplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAPLUSPLUS_ELASTIC_SIG);
      DplusDeltaplusplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusDeltaplusplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusDeltaminus_elastic()

std::optional< double > smash::DplusDeltaminus_elastic

(

double

sqrts

)

D⁺Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1766 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusDeltaminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAMINUS_ELASTIC_SIG);
      DplusDeltaminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusDeltaminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusDeltaminus_DzeroDeltazero()

double smash::DplusDeltaminus_DzeroDeltazero

(

double

sqrts

)

D⁺Δ⁻ -> D⁰Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁺ -> D̄⁰Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1781 of file parametrizations.cc.

                                                    {
  if (DplusDeltaminus_DzeroDeltazero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAMINUS_DZERODELTAZERO_SIG);
    DplusDeltaminus_DzeroDeltazero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DplusDeltaminus_DzeroDeltazero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DplusDeltazero_elastic()

std::optional< double > smash::DplusDeltazero_elastic

(

double

sqrts

)

D⁺Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1792 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DplusDeltazero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAZERO_ELASTIC_SIG);
      DplusDeltazero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DplusDeltazero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DplusDeltazero_DzeroDeltaplus()

double smash::DplusDeltazero_DzeroDeltaplus

(

double

sqrts

)

D⁺Δ⁰ -> D⁰Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁻Δ̅⁰ -> D̄⁰Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1807 of file parametrizations.cc.

                                                   {
  if (DplusDeltazero_DzeroDeltaplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DDELTA_SQRTS, DPLUSDELTAZERO_DZERODELTAPLUS_SIG);
    DplusDeltazero_DzeroDeltaplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DplusDeltazero_DzeroDeltaplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroDeltaplus_DplusDeltazero()

double smash::DzeroDeltaplus_DplusDeltazero

(

double

sqrts

)

D⁰Δ⁺ -> D⁺Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁻ -> D⁻Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1818 of file parametrizations.cc.

                                                   {
  if (DzeroDeltaplus_DplusDeltazero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DDELTA_SQRTS, DZERODELTAPLUS_DPLUSDELTAZERO_SIG);
    DzeroDeltaplus_DplusDeltazero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DzeroDeltaplus_DplusDeltazero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroDeltaplus_elastic()

std::optional< double > smash::DzeroDeltaplus_elastic

(

double

sqrts

)

D⁰Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1829 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroDeltaplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DZERODELTAPLUS_ELASTIC_SIG);
      DzeroDeltaplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroDeltaplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DzeroDeltaplusplus_DplusDeltaplus()

double smash::DzeroDeltaplusplus_DplusDeltaplus

(

double

sqrts

)

D⁰Δ⁺⁺ -> D⁺Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁻⁻ -> D⁻Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1844 of file parametrizations.cc.

                                                       {
  if (DzeroDeltaplusplus_DplusDeltaplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DDELTA_SQRTS, DZERODELTAPLUSPLUS_DPLUSDELTAPLUS_SIG);
    DzeroDeltaplusplus_DplusDeltaplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DzeroDeltaplusplus_DplusDeltaplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroDeltaplusplus_elastic()

std::optional< double > smash::DzeroDeltaplusplus_elastic

(

double

sqrts

)

D⁰Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁻⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1855 of file parametrizations.cc.

                                                             {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroDeltaplusplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DZERODELTAPLUSPLUS_ELASTIC_SIG);
      DzeroDeltaplusplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroDeltaplusplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DzeroDeltaminus_elastic()

std::optional< double > smash::DzeroDeltaminus_elastic

(

double

sqrts

)

D⁰Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1870 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroDeltaminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DZERODELTAMINUS_ELASTIC_SIG);
      DzeroDeltaminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroDeltaminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DzeroDeltazero_DplusDeltaminus()

double smash::DzeroDeltazero_DplusDeltaminus

(

double

sqrts

)

D⁰Δ⁰ -> D⁺Δ⁻ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁰ -> D⁻Δ̅⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1885 of file parametrizations.cc.

                                                    {
  if (DzeroDeltazero_DplusDeltaminus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(DDELTA_SQRTS, DZERODELTAZERO_DPLUSDELTAMINUS_SIG);
    DzeroDeltazero_DplusDeltaminus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DzeroDeltazero_DplusDeltaminus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DzeroDeltazero_elastic()

std::optional< double > smash::DzeroDeltazero_elastic

(

double

sqrts

)

D⁰Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D̄⁰Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1896 of file parametrizations.cc.

                                                         {
  if (sqrts > *(DDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DzeroDeltazero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DDELTA_SQRTS, DZERODELTAZERO_ELASTIC_SIG);
      DzeroDeltazero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DzeroDeltazero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DminusDeltaplus_elastic()

std::optional< double > smash::DminusDeltaplus_elastic

(

double

sqrts

)

D⁻Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1911 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DminusDeltaplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DMINUSDELTAPLUS_ELASTIC_SIG);
      DminusDeltaplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DminusDeltaplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DminusDeltaplus_DbarzeroDeltazero()

double smash::DminusDeltaplus_DbarzeroDeltazero

(

double

sqrts

)

D⁻Δ⁺ -> D̄⁰Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁻ -> D⁰Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1926 of file parametrizations.cc.

                                                       {
  if (DminusDeltaplus_DbarzeroDeltazero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DBARDELTA_SQRTS, DMINUSDELTAPLUS_DBARZERODELTAZERO_SIG);
    DminusDeltaplus_DbarzeroDeltazero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DminusDeltaplus_DbarzeroDeltazero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DminusDeltaplusplus_elastic()

std::optional< double > smash::DminusDeltaplusplus_elastic

(

double

sqrts

)

D⁻Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁻⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1937 of file parametrizations.cc.

                                                              {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DminusDeltaplusplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DMINUSDELTAPLUSPLUS_ELASTIC_SIG);
      DminusDeltaplusplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DminusDeltaplusplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DminusDeltaplusplus_DbarzeroDeltaplus()

double smash::DminusDeltaplusplus_DbarzeroDeltaplus

(

double

sqrts

)

D⁻Δ⁺⁺ -> D̄⁰Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁻⁻ -> D⁰Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1952 of file parametrizations.cc.

                                                           {
  if (DminusDeltaplusplus_DbarzeroDeltaplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DBARDELTA_SQRTS, DMINUSDELTAPLUSPLUS_DBARZERODELTAPLUS_SIG);
    DminusDeltaplusplus_DbarzeroDeltaplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DminusDeltaplusplus_DbarzeroDeltaplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DminusDeltaminus_elastic()

std::optional< double > smash::DminusDeltaminus_elastic

(

double

sqrts

)

D⁻Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1963 of file parametrizations.cc.

                                                           {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DminusDeltaminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DMINUSDELTAMINUS_ELASTIC_SIG);
      DminusDeltaminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DminusDeltaminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DminusDeltazero_elastic()

std::optional< double > smash::DminusDeltazero_elastic

(

double

sqrts

)

D⁻Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1978 of file parametrizations.cc.

                                                          {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DminusDeltazero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DMINUSDELTAZERO_ELASTIC_SIG);
      DminusDeltazero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DminusDeltazero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DminusDeltazero_DbarzeroDeltaminus()

double smash::DminusDeltazero_DbarzeroDeltaminus

(

double

sqrts

)

D⁻Δ⁰ -> D̄⁰Δ⁻ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁺Δ̅⁰ -> D⁰Δ̅⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 1993 of file parametrizations.cc.

                                                        {
  if (DminusDeltazero_DbarzeroDeltaminus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DBARDELTA_SQRTS, DMINUSDELTAZERO_DBARZERODELTAMINUS_SIG);
    DminusDeltazero_DbarzeroDeltaminus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DminusDeltazero_DbarzeroDeltaminus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DbarzeroDeltaplus_DminusDeltaplusplus()

double smash::DbarzeroDeltaplus_DminusDeltaplusplus

(

double

sqrts

)

D̄⁰Δ⁺ -> D⁻Δ⁺⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁻ -> D⁺Δ̅⁻⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2004 of file parametrizations.cc.

                                                           {
  if (DbarzeroDeltaplus_DminusDeltaplusplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DBARDELTA_SQRTS, DBARZERODELTAPLUS_DMINUSDELTAPLUSPLUS_SIG);
    DbarzeroDeltaplus_DminusDeltaplusplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DbarzeroDeltaplus_DminusDeltaplusplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DbarzeroDeltaplus_elastic()

std::optional< double > smash::DbarzeroDeltaplus_elastic

(

double

sqrts

)

D̄⁰Δ⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2015 of file parametrizations.cc.

                                                            {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DbarzeroDeltaplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DBARZERODELTAPLUS_ELASTIC_SIG);
      DbarzeroDeltaplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DbarzeroDeltaplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DbarzeroDeltaplusplus_elastic()

std::optional< double > smash::DbarzeroDeltaplusplus_elastic

(

double

sqrts

)

D̄⁰Δ⁺⁺ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁻⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2030 of file parametrizations.cc.

                                                                {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DbarzeroDeltaplusplus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DBARZERODELTAPLUSPLUS_ELASTIC_SIG);
      DbarzeroDeltaplusplus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DbarzeroDeltaplusplus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DbarzeroDeltaminus_DminusDeltazero()

double smash::DbarzeroDeltaminus_DminusDeltazero

(

double

sqrts

)

D̄⁰Δ⁻ -> D⁻Δ⁰ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁺ -> D⁺Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2045 of file parametrizations.cc.

                                                        {
  if (DbarzeroDeltaminus_DminusDeltazero_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DBARDELTA_SQRTS, DBARZERODELTAMINUS_DMINUSDELTAZERO_SIG);
    DbarzeroDeltaminus_DminusDeltazero_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DbarzeroDeltaminus_DminusDeltazero_interpolation)(sqrts);
}

Here is the caller graph for this function:

DbarzeroDeltaminus_elastic()

std::optional< double > smash::DbarzeroDeltaminus_elastic

(

double

sqrts

)

D̄⁰Δ⁻ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁺ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2056 of file parametrizations.cc.

                                                             {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DbarzeroDeltaminus_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DBARZERODELTAMINUS_ELASTIC_SIG);
      DbarzeroDeltaminus_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DbarzeroDeltaminus_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

DbarzeroDeltazero_DminusDeltaplus()

double smash::DbarzeroDeltazero_DminusDeltaplus

(

double

sqrts

)

D̄⁰Δ⁰ -> D⁻Δ⁺ cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁰ -> D⁺Δ̅⁻ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2071 of file parametrizations.cc.

                                                       {
  if (DbarzeroDeltazero_DminusDeltaplus_interpolation == nullptr) {
    auto [dedup_x, dedup_y] = dedup_avg<double>(
        DBARDELTA_SQRTS, DBARZERODELTAZERO_DMINUSDELTAPLUS_SIG);
    DbarzeroDeltazero_DminusDeltaplus_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  return (*DbarzeroDeltazero_DminusDeltaplus_interpolation)(sqrts);
}

Here is the caller graph for this function:

DbarzeroDeltazero_elastic()

std::optional< double > smash::DbarzeroDeltazero_elastic

(

double

sqrts

)

D̄⁰Δ⁰ elastic cross section (Tolos:2013kva [69]), data provided by Juan Torres-Rincon.

Charge conjugated cross section D⁰Δ̅⁰ is also handled with this function.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 2082 of file parametrizations.cc.

                                                            {
  if (sqrts > *(DBARDELTA_SQRTS.end() - 1)) {
    return std::nullopt;
  } else {
    if (DbarzeroDeltazero_elastic_interpolation == nullptr) {
      auto [dedup_x, dedup_y] =
          dedup_avg<double>(DBARDELTA_SQRTS, DBARZERODELTAZERO_ELASTIC_SIG);
      DbarzeroDeltazero_elastic_interpolation =
          std::make_unique<InterpolateDataLinear<double>>(
              dedup_x, dedup_y, ExtrapolationType::Zero);
    }
    return (*DbarzeroDeltazero_elastic_interpolation)(sqrts);
  }
}

Here is the caller graph for this function:

create_valid_smash_particle_matching_provided_quantities()

ParticleData smash::create_valid_smash_particle_matching_provided_quantities	(	PdgCode	pdgcode,
		double	mass,
		const FourVector &	four_position,
		const FourVector &	four_momentum,
		int	log_area,
		bool &	mass_warning,
		bool &	on_shell_warning
	)

This function creates a SMASH particle validating the provided information.

• The input position and momentum is checked for nan values.
• A particle is first created using the given PDG code, setting its 4-momentum to the given one.
• Afterwards, if stable, its mass is compared to the given one and, if these do not match (up to numeric rounding), the internal SMASH value (i.e. that from the particles file) is used to put the particle on the SMASH mass shell.
• Finally, for unstable particles or if the previous mass check passed, the particle is checked to be on its mass shell and, if not, its energy is adjusted to put the particle on its mass shell.

This function possibly warns the user, if requested.

Parameters

[in]	pdgcode	PdgCode of the particle which is supposed to be checked
[in]	mass	Mass of the new particle
[in]	four_position	Position four vector of the new particle
[in]	four_momentum	Momentum four vector of the new particle
[in]	log_area	Logging area for the warning
[in,out]	mass_warning	Whether to warn about mass discrepancies
[in,out]	on_shell_warning	Whether to warn about off-shell particles

Returns

Valid SMASH particle matching all given input quantities

Note

The boolean flags are passed by reference, since we want to allow client code to warn the user only once per flag. Hence, this function is turning the flags to false after having warned the user.

Definition at line 214 of file particledata.cc.

                            {
  // Check input position and momentum for nan values
  if (is_any_nan(four_position) || is_any_nan(four_momentum)) {
    logg[log_area].fatal() << "Input particle has at least one nan value in "
                              "position and/or momentum four vector.";
    throw std::invalid_argument(
        "Invalid input (nan) for particle position or momentum.");
  }
 
  // Some preliminary tool to avoid duplication later
  static const auto emph = einhard::Yellow_t_::ANSI();
  static const auto restore_default = einhard::NoColor_t_::ANSI();
  auto prepare_needed_warnings = [&mass_warning, &on_shell_warning, &mass,
                                  &four_momentum](const ParticleData &p) {
    std::array<std::optional<std::string>, 2> warnings{};
    if (mass_warning) {
      warnings[0] = "Provided mass of stable particle " + p.type().name() +
                    " = " + std::to_string(mass) +
                    " [GeV] is inconsistent with value = " +
                    std::to_string(p.pole_mass()) + " [GeV] from " +
                    "particles file.\nForcing E = sqrt(p^2 + m^2)" +
                    ", where m is the mass contained in the particles file." +
                    "\nFurther warnings about discrepancies between the " +
                    "input mass and the mass contained in the particles file" +
                    " will be suppressed.\n" + emph + "Please make sure" +
                    " that changing input particle properties is an " +
                    "acceptable behavior." + restore_default;
    }
    if (on_shell_warning) {
      std::stringstream ss{};
      ss << four_momentum;
      warnings[1] =
          "Provided 4-momentum " + ss.str() + " [GeV] and mass " +
          std::to_string(mass) + " [GeV] do not satisfy E^2 - p^2 = m^2.\n" +
          "This may originate from the lack of numerical" +
          " precision in the input. Setting E to sqrt(p^2 + " +
          "m^2).\nFurther warnings about E != sqrt(p^2 + m^2) will" +
          " be suppressed.\n" + emph + "Please make sure that setting " +
          "particles back on the mass shell is an acceptable behavior." +
          restore_default;
    }
    return warnings;
  };
  auto warn_if_needed = [&log_area](bool &flag,
                                    const std::optional<std::string> &message) {
    if (flag) {
      logg[log_area].warn(message.value());
      flag = false;
    }
  };
  auto is_particle_stable_and_with_invalid_mass =
      [&mass](const ParticleData &p) {
        return p.type().is_stable() &&
               std::abs(mass - p.pole_mass()) > really_small;
      };
  auto is_particle_off_its_mass_shell = [&mass](const ParticleData &p) {
    return std::abs(p.momentum().sqr() - mass * mass) > really_small;
  };
 
  // Actual implementation
  ParticleData smash_particle{ParticleType::find(pdgcode)};
  const auto warnings = prepare_needed_warnings(smash_particle);
  if (is_particle_stable_and_with_invalid_mass(smash_particle)) {
    warn_if_needed(mass_warning, warnings[0]);
    smash_particle.set_4momentum(smash_particle.pole_mass(),
                                 four_momentum.threevec());
  } else {
    smash_particle.set_4momentum(four_momentum);
    if (is_particle_off_its_mass_shell(smash_particle)) {
      warn_if_needed(on_shell_warning, warnings[1]);
      smash_particle.set_4momentum(mass, four_momentum.threevec());
    }
  }
 
  // Set spatial coordinates, they will later be backpropagated if needed
  smash_particle.set_4position(four_position);
  smash_particle.set_formation_time(four_position.x0());
  smash_particle.set_cross_section_scaling_factor(1.0);
 
  return smash_particle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

are_particles_identical_at_given_time()

bool smash::are_particles_identical_at_given_time	(	const ParticleData &	p1,
		const ParticleData &	p2,
		double	time
	)

Utility function to compare two ParticleData instances with respect to their PDG code, 4-position and 4-momenta.

The particles are propagated to the given time before being compared. 4-vectors are compared using the FourVector::operator== overload.

Parameters

p1	The first particle
p2	The second particle
time	The time at which the comparison should take place

Returns

true if the two particles have the same PDG codes, 4-position and 4-momentum;

false otherwise.

Definition at line 299 of file particledata.cc.

                                                        {
  if (p1.pdgcode() != p2.pdgcode()) {
    return false;
  } else {
    if (p1.momentum() != p2.momentum()) {
      return false;
    }
    auto get_propagated_position = [&time](const ParticleData &p) {
      const double t = p.position().x0();
      const FourVector u(1.0, p.velocity());
      return p.position() + u * (time - t);
    };
    return get_propagated_position(p1) == get_propagated_position(p2);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator-() [3/4]

Parity smash::operator- ( Parity  p )

inline

Parameters

p	Given parity.

Returns

Inverted parity.

Definition at line 48 of file particletype.h.

                                  {
  switch (p) {
    case Parity::Pos:
      return Parity::Neg;
    case Parity::Neg:
      return Parity::Pos;
  }
  // This is unreachable and should be optimized away.
  // It is required to silence a compiler warning.
  throw std::runtime_error("unreachable");
}

operator*() [5/8]

Parity smash::operator* ( Parity  x, Parity  y  )

inline

Parameters

x	Left-hand parity
y	Right-hand parity

Returns

Product of x and y.

Definition at line 65 of file particletype.h.

                                            {
  if (x == y) {
    return Parity::Pos;
  } else {
    return Parity::Neg;
  }
}

operator*=()

void smash::operator*= ( Parity &  x, Parity  y  )

inline

Parameters

x	Left-hand parity
y	Right-hand parity

Returns

Product of x and y.

Definition at line 78 of file particletype.h.

                                            {
  if (x == y) {
    x = Parity::Pos;
  } else {
    x = Parity::Neg;
  }
}

list_possible_resonances()

ParticleTypePtrList smash::list_possible_resonances	(	const ParticleTypePtr	type_a,
		const ParticleTypePtr	type_b
	)

Lists the possible resonances that decay into two particles.

Parameters

[in]	type_a	first incoming particle.
[in]	type_b	second incoming particle.

Returns

list of possible resonances.

Note

Internally, a static std::map is used as a caching mechanism and is filled the first time this function is called, such that calling it again just returns the same list.

Definition at line 842 of file particletype.cc.

                                                                           {
  static std::map<std::set<ParticleTypePtr>, ParticleTypePtrList>
      map_possible_resonances_of;
  std::set<ParticleTypePtr> incoming{type_a, type_b};
  const ParticleTypePtrList incoming_types = {type_a, type_b};
  // Fill map if set is not yet present
  if (map_possible_resonances_of.count(incoming) == 0) {
    logg[LResonances].debug()
        << "Filling map of compatible resonances for ptypes " << type_a->name()
        << " " << type_b->name();
    ParticleTypePtrList resonance_list{};
    // The tests below are redundant as the decay modes already obey them, but
    // they are quicker to check and so improve performance.
    for (const ParticleType &resonance : ParticleType::list_all()) {
      /* Not a resonance, go to next type of particle */
      if (resonance.is_stable()) {
        continue;
      }
      // Same resonance as in the beginning, ignore
      if ((resonance.pdgcode() == type_a->pdgcode()) ||
          (resonance.pdgcode() == type_b->pdgcode())) {
        continue;
      }
      // Check for charge conservation.
      if (resonance.charge() != type_a->charge() + type_b->charge()) {
        continue;
      }
      // Check for baryon-number conservation.
      if (resonance.baryon_number() !=
          type_a->baryon_number() + type_b->baryon_number()) {
        continue;
      }
      // Check for strangeness conservation.
      if (resonance.strangeness() !=
          type_a->strangeness() + type_b->strangeness()) {
        continue;
      }
      const auto &decaymodes = resonance.decay_modes().decay_mode_list();
      for (const auto &mode : decaymodes) {
        if (mode->type().has_particles(incoming_types)) {
          resonance_list.push_back(&resonance);
          break;
        }
      }
    }
    // Here `resonance_list` can be empty, corresponding to the case where there
    // are no possible resonances.
    map_possible_resonances_of[incoming] = resonance_list;
  }
 
  return map_possible_resonances_of[incoming];
}

Here is the call graph for this function:

Here is the caller graph for this function:

sample_two_resonance_masses()

std::pair< double, double > smash::sample_two_resonance_masses	(	const ParticleType &	t1,
		const ParticleType &	t2,
		const double	cms_energy,
		int	L = 0
	)

Resonance mass sampling for 2-particle final state with two resonances.

Parameters

[in]	t1	Type of the first resonance
[in]	t2	Type of the second resonance.
[in]	cms_energy	center-of-mass energy of the 2-particle final state.
[in]	L	relative angular momentum of the final-state particles

Returns

The masses of the resonance particles.

Definition at line 719 of file particletype.cc.

                                                             {
  /* Sample resonance mass from the distribution
   * used for calculating the cross section. */
  const double max_mass_1 =
      std::nextafter(cms_energy - t2.min_mass_spectral(), 0.);
  const double max_mass_2 =
      std::nextafter(cms_energy - t1.min_mass_spectral(), 0.);
  // largest possible cm momentum (from smallest mass)
  const double pcm_max =
      pCM(cms_energy, t1.min_mass_spectral(), t2.min_mass_spectral());
  const double sf_ratio_max =
      std::max(t1.max_ratio_spectral_full_to_breit_wigner(),
               t1.ratio_spectral_full_to_breit_wigner(max_mass_1)) *
      std::max(t2.max_ratio_spectral_full_to_breit_wigner(),
               t2.ratio_spectral_full_to_breit_wigner(max_mass_2));
 
  int max_trials_outer = 10, max_trials_inner = 20;
  double mass_1, mass_2, acceptance, fudge_factor = 1;
  double max_acceptance =
      sf_ratio_max * pcm_max * blatt_weisskopf_sqr(pcm_max, L);
  // Rejection sampling
  do {
    max_acceptance *= fudge_factor;
    do {
      // sample mass from a simple Breit-Wigner (aka Cauchy) distribution
      mass_1 = t1.sample_breit_wigner_spectral_function(max_mass_1);
      mass_2 = t2.sample_breit_wigner_spectral_function(max_mass_2);
      // determine cm momentum for this case
      const double pcm = pCM(cms_energy, mass_1, mass_2);
      const double sf_ratio = t1.ratio_spectral_full_to_breit_wigner(mass_1) *
                              t2.ratio_spectral_full_to_breit_wigner(mass_2);
      // determine ratios of full to simple spectral function
      acceptance = sf_ratio * pcm * blatt_weisskopf_sqr(pcm, L);
    } while (acceptance < random::uniform(0., max_acceptance) &&
             --max_trials_inner > 0);
    fudge_factor *= acceptance / max_acceptance;
  } while (acceptance > max_acceptance && --max_trials_outer > 0);
 
  if (max_trials_inner == 0) {
    /*
     * This fallback is necessary for when the inner loop fails to find an
     * acceptable mass combination. This can happen when the cms_energy is much
     * smaller than the sum of pole masses of the two resonances.
     *
     */
    logg[LResonances].debug(
        "Could not sample a valid mass combination for the resonances ",
        t1.name(), " and ", t2.name(), " with energy ", cms_energy,
        " GeV. Using bisection fallback to find valid masses.");
    while (mass_1 + mass_2 > cms_energy) {
      mass_1 = (t1.min_mass_spectral() + mass_1) / 2;
      mass_2 = (t2.min_mass_spectral() + mass_2) / 2;
    }
  }
 
  if (acceptance > max_acceptance && max_trials_outer == 0) {
    logg[LResonances].fatal(
        "Maximum acceptance should be increased in sample_resonance_masses: ",
        acceptance / max_acceptance, " ", t1.pdgcode(), " ", t2.pdgcode(), " ",
        cms_energy, " ", mass_1, " ", mass_2);
    throw std::runtime_error(
        "Precomputation of maximum spectral function is not working properly. "
        "Please contact the developers.");
  }
  return {mass_1, mass_2};
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator>>()

std::istream & smash::operator>>	(	std::istream &	is,
		PdgCode &	code
	)

Sets the PDG code from the textual representation in the input stream.

istream >> PdgCode assigns the PDG Code from an istream.

Parameters

[in]	is	input string
[out]	code	PdgCode to be set

Definition at line 14 of file pdgcode.cc.

                                                      {
  std::string codestring("");
  is >> codestring;
  if (!is) {
    code = PdgCode::invalid();
    return is;
  }
  try {
    // set the fields from the string:
    code.set_from_string(codestring);
  } catch (PdgCode::InvalidPdgCode&) {
    is.setstate(std::ios::failbit);
    code = PdgCode::invalid();
  }
  return is;
}

is_dilepton()

bool smash::is_dilepton ( const PdgCode  pdg1, const PdgCode  pdg2  )

inline

Returns

if two given particles represent a lepton pair (e+e- or mu+mu-).

Definition at line 1222 of file pdgcode.h.

                                                                {
  const auto c1 = pdg1.code();
  const auto c2 = pdg2.code();
  const auto min = std::min(c1, c2);
  const auto max = std::max(c1, c2);
  return (max == 0x11 && min == -0x11) || (max == 0x13 && min == -0x13) ||
         (max == 0x12 && min == -0x11) || (max == 0x11 && min == -0x12);
}

Here is the call graph for this function:

Here is the caller graph for this function:

has_lepton_pair()

bool smash::has_lepton_pair ( const PdgCode  pdg1, const PdgCode  pdg2, const PdgCode  pdg3  )

inline

Returns

if two of the three given particles represent a lepton pair (e+e- or mu+mu-).

Definition at line 1235 of file pdgcode.h.

                                                {
  return is_dilepton(pdg1, pdg2) || is_dilepton(pdg1, pdg3) ||
         is_dilepton(pdg2, pdg3);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pack()

constexpr uint64_t smash::pack ( int32_t  x, int32_t  y  )

constexpr

Pack two int32_t into an uint64_t.

This is useful for switch statements on pairs.

Parameters

x	First integer to be packed.
y	Second integer to be packed.

Returns

Combined integer.

Definition at line 160 of file pdgcode_constants.h.

                                              {
  return (static_cast<uint64_t>(static_cast<uint32_t>(x)) << 32) |
         static_cast<uint64_t>(static_cast<uint32_t>(y));
  // Casting to an intermediate 32-bit integer is important!
}

Here is the caller graph for this function:

pow_int()

template<class T >

constexpr T smash::pow_int ( const T  base, unsigned const  exponent  )

inlineconstexpr

Efficient template for calculating integer powers using squaring.

Template Parameters

T	Type that implements multiplication.

Parameters

[in]	base
[in]	exponent

Returns

base^exponent

Definition at line 23 of file pow.h.

                                                                  {
  return (exponent == 0) ? 1
         : (exponent % 2 == 0)
             ? pow_int(base, exponent / 2) * pow_int(base, exponent / 2)
             : base * pow_int(base, exponent - 1);
}

Here is the caller graph for this function:

is_valid_process_type()

bool smash::is_valid_process_type ( int  v )

inline

Definition at line 100 of file processbranch.h.

                                         {
  // NOTE: There must NOT be a default case in the following switch, to let the
  // compiler warn about missing cases.
  switch (static_cast<ProcessType>(v)) {
    case ProcessType::None:
    case ProcessType::Elastic:
    case ProcessType::TwoToOne:
    case ProcessType::TwoToTwo:
    case ProcessType::TwoToThree:
    case ProcessType::TwoToFour:
    case ProcessType::TwoToFive:
    case ProcessType::Decay:
    case ProcessType::Wall:
    case ProcessType::Thermalization:
    case ProcessType::Fluidization:
    case ProcessType::FluidizationNoRemoval:
    case ProcessType::BremsstrahlungPhoton:
    case ProcessType::BremsstrahlungDilepton:
    case ProcessType::MultiParticleThreeMesonsToOne:
    case ProcessType::MultiParticleThreeToTwo:
    case ProcessType::MultiParticleFourToTwo:
    case ProcessType::MultiParticleFiveToTwo:
    case ProcessType::StringSoftSingleDiffractiveAX:
    case ProcessType::StringSoftSingleDiffractiveXB:
    case ProcessType::StringSoftDoubleDiffractive:
    case ProcessType::StringSoftAnnihilation:
    case ProcessType::StringSoftNonDiffractive:
    case ProcessType::StringHardNonDiffractive:
    case ProcessType::StringHardSingleDiffractiveAX:
    case ProcessType::StringHardSingleDiffractiveXB:
    case ProcessType::StringHardDoubleDiffractive:
    case ProcessType::FailedString:
    case ProcessType::Freeforall:
      return true;
  }
  return false;
}

Here is the caller graph for this function:

is_string_soft_process()

bool smash::is_string_soft_process

(

ProcessType

p

)

Check if a given process type is a soft string excitation.

Parameters

[in]

p

The process type

Definition at line 18 of file processbranch.cc.

                                              {
  return type == ProcessType::StringSoftSingleDiffractiveAX ||
         type == ProcessType::StringSoftSingleDiffractiveXB ||
         type == ProcessType::StringSoftDoubleDiffractive ||
         type == ProcessType::StringSoftAnnihilation ||
         type == ProcessType::StringSoftNonDiffractive;
}

Here is the caller graph for this function:

is_string_hard_process()

bool smash::is_string_hard_process

(

ProcessType

p

)

Check if a given process type is a hard string excitation.

Parameters

[in]

p

The process type

Definition at line 25 of file processbranch.cc.

                                              {
  return type == ProcessType::StringHardSingleDiffractiveAX ||
         type == ProcessType::StringHardSingleDiffractiveXB ||
         type == ProcessType::StringHardDoubleDiffractive ||
         type == ProcessType::StringHardNonDiffractive;
}

Here is the caller graph for this function:

is_string_process()

bool smash::is_string_process

(

ProcessType

p

)

Check if a given process type is a string excitation.

Parameters

[in]

p

The process type

Definition at line 32 of file processbranch.cc.

                                         {
  return is_string_soft_process(type) || is_string_hard_process(type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

calc_hubble()

double smash::calc_hubble	(	double	time,
		const ExpansionProperties &	metric
	)

Calculate the Hubble parameter \(H(t)\), which describes how large the expansion flow is.

The flow \(\mathbf{v}=H(t)\:\mathbf{x}\) Tindall:2016try [68]

Parameters

[in]	time	time in the computational frame. [fm]
[in]	metric	Struct containing the parameters needed to calculate the metric.

Returns

Hubble parameter [fm^ \({-1}\)]

Definition at line 21 of file propagation.cc.

                                                                   {
  double h;  // Hubble parameter
 
  switch (metric.mode_) {
    case ExpansionMode::NoExpansion:
      h = 0.;
      break;
    case ExpansionMode::MasslessFRW:
      h = metric.b_ / (2 * (metric.b_ * time + 1));
      break;
    case ExpansionMode::MassiveFRW:
      h = 2 * metric.b_ / (3 * (metric.b_ * time + 1));
      break;
    case ExpansionMode::Exponential:
      h = metric.b_ * time;
      break;
    default:
      h = 0.;
  }
 
  return h;
}

Here is the caller graph for this function:

propagate_straight_line()

double smash::propagate_straight_line	(	Particles *	particles,
		double	to_time,
		const std::vector< FourVector > &	beam_momentum
	)

Propagates the positions of all particles on a straight line to a given moment.

For each particle, the position is shifted:

\[ \mathbf{x}^\prime = \mathbf{x} + \mathbf{v}\:\Delta t \]

where \(\mathbf{x}\) is the current position, \(\mathbf{v}\) its velocity and \(\Delta t\) the duration of this timestep.

Parameters

[out]	particles	The particle list in the event
[in]	to_time	final time [fm]
[in]	beam_momentum	This vector of 4-momenta should have non-zero size only if "frozen Fermi motion" is on. The the Fermi momenta are only used for collisions, but not for propagation. In this case beam_momentum is used for propagating the initial nucleons. [GeV]

Returns

dt time interval of propagation which is equal to the difference between the final time and the initial time read from the 4-position of the particle.

Definition at line 44 of file propagation.cc.

                                                                           {
  bool negative_dt_error = false;
  double dt = 0.0;
  for (ParticleData &data : *particles) {
    const double t0 = data.position().x0();
    dt = to_time - t0;
    if (dt < 0.0 && !negative_dt_error) {
      // Print error message once, not for every particle
      negative_dt_error = true;
      logg[LPropagation].error("propagate_straight_line - negative dt = ", dt);
    }
    assert(dt >= 0.0);
    /* "Frozen Fermi motion": Fermi momenta are only used for collisions,
     * but not for propagation. This is done to avoid nucleus flying apart
     * even if potentials are off. Initial nucleons before the first collision
     * are propagated only according to beam momentum.
     * Initial nucleons are distinguished by data.id() < the size of
     * beam_momentum, which is by default zero except for the collider modus
     * with the fermi motion == frozen.
     * todo(m. mayer): improve this condition (see comment #11 issue #4213)*/
    assert(data.id() >= 0);
    const bool avoid_fermi_motion =
        (static_cast<uint64_t>(data.id()) <
         static_cast<uint64_t>(beam_momentum.size())) &&
        (data.get_history().collisions_per_particle == 0);
    ThreeVector v;
    if (avoid_fermi_motion) {
      const FourVector vbeam = beam_momentum[data.id()];
      v = vbeam.velocity();
    } else {
      v = data.velocity();
    }
    const FourVector distance = FourVector(0.0, v * dt);
    logg[LPropagation].debug("Particle ", data, " motion: ", distance);
    FourVector position = data.position() + distance;
    position.set_x0(to_time);
    data.set_4position(position);
  }
  return dt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

backpropagate_straight_line()

void smash::backpropagate_straight_line	(	Particles *	particles,
		double	to_time
	)

Definition at line 86 of file propagation.cc.

                                                                       {
  bool positive_dt_error = false;
  for (ParticleData &data : *particles) {
    const double t = data.position().x0();
    if (t < to_time && !positive_dt_error) {
      // Print error message once, not for every particle
      positive_dt_error = true;
      logg[LPropagation].error(
          to_time,
          " in backpropagate_straight_line is after the earliest particle.");
    }
    assert(t >= to_time);
    const double dt = to_time - t;
    const ThreeVector r = data.position().threevec() + dt * data.velocity();
    data.set_4position(FourVector(to_time, r));
    data.set_formation_time(t);
    data.set_cross_section_scaling_factor(0.0);
  }
}

Here is the caller graph for this function:

expand_space_time()

void smash::expand_space_time	(	Particles *	particles,
		const ExperimentParameters &	parameters,
		const ExpansionProperties &	metric
	)

Modifies positions and momentum of all particles to account for space-time deformation.

Parameters

[out]	particles	All the particles in the event
[in]	parameters	A struct containing the parameters from which we extract the time in the computational frame.
[in]	metric	A struct containing the parameters need to calculate the metric

Definition at line 106 of file propagation.cc.

                                                          {
  const double dt = parameters.labclock->timestep_duration();
  for (ParticleData &data : *particles) {
    // Momentum and position modification to ensure appropriate expansion
    const double h = calc_hubble(parameters.labclock->current_time(), metric);
    FourVector delta_mom = FourVector(0.0, h * data.momentum().threevec() * dt);
    FourVector expan_dist =
        FourVector(0.0, h * data.position().threevec() * dt);
 
    logg[LPropagation].debug("Particle ", data,
                             " expansion motion: ", expan_dist);
    // New position and momentum
    FourVector position = data.position() + expan_dist;
    FourVector momentum = data.momentum() - delta_mom;
 
    // set the new momentum and position variables
    data.set_4position(position);
    data.set_4momentum(momentum);
    // force the on shell condition to ensure correct energy
    data.set_4momentum(data.pole_mass(), data.momentum().threevec());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_momenta()

void smash::update_momenta	(	std::vector< Particles > &	particles,
		double	dt,
		const Potentials &	pot,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	FB_lat,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	FI3_lat,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	EM_lat,
		DensityLattice *	jB_lat
	)

Updates the momenta of all particles at the current time step according to the equations of motion:

\[ \frac{dp}{dt} = q\,(\mathbf{E} + \mathbf{v} \times \mathbf{B}) \]

Parameters

[out]	particles	The particle list in the event
[in]	dt	timestep
[in]	pot	The potentials in the system
[in]	FB_lat	Lattice for the electric and magnetic components of the Skyrme force
[in]	FI3_lat	Lattice for the electric and magnetic components of the symmetry force
[in]	EM_lat	Lattice for the electric and magnetic field
[in]	jB_lat	Lattice of the net baryon density

Definition at line 131 of file propagation.cc.

                            {
  // Copy particles from ALL ensembles to a single list before propagation
  // and calculate potentials from this list
  ParticleList plist;
  for (Particles &particles : ensembles) {
    const ParticleList tmp = particles.copy_to_vector();
    plist.insert(plist.end(), tmp.begin(), tmp.end());
  }
 
  bool possibly_use_lattice =
      (pot.use_skyrme() ? (FB_lat != nullptr) : true) &&
      (pot.use_vdf() ? (FB_lat != nullptr) : true) &&
      (pot.use_symmetry() ? (FI3_lat != nullptr) : true);
  std::pair<ThreeVector, ThreeVector> FB, FI3, EM_fields;
  double min_time_scale = std::numeric_limits<double>::infinity();
 
  for (Particles &particles : ensembles) {
    for (ParticleData &data : particles) {
      // Only baryons and nuclei will be affected by the potentials
      if (!(data.is_baryon() || data.is_nucleus())) {
        continue;
      }
      const auto scale = pot.force_scale(data.type());
      const ThreeVector r = data.position().threevec();
      /* Lattices can be used for calculation if 1-2 are fulfilled:
       * 1) Required lattices are not nullptr - possibly_use_lattice
       * 2) r is not out of required lattices */
      const bool use_lattice =
          possibly_use_lattice &&
          (pot.use_skyrme() ? FB_lat->value_at(r, FB) : true) &&
          (pot.use_vdf() ? FB_lat->value_at(r, FB) : true) &&
          (pot.use_symmetry() ? FI3_lat->value_at(r, FI3) : true);
      if (!use_lattice && !pot.use_potentials_outside_lattice()) {
        continue;
      }
      if (!pot.use_skyrme() && !pot.use_vdf()) {
        FB = std::make_pair(ThreeVector(0., 0., 0.), ThreeVector(0., 0., 0.));
      }
      if (!pot.use_symmetry()) {
        FI3 = std::make_pair(ThreeVector(0., 0., 0.), ThreeVector(0., 0., 0.));
      }
      if (!use_lattice) {
        const auto tmp = pot.all_forces(r, plist);
        FB = std::make_pair(std::get<0>(tmp), std::get<1>(tmp));
        FI3 = std::make_pair(std::get<2>(tmp), std::get<3>(tmp));
      }
      ThreeVector force = std::invoke([&]() {
        if (pot.use_momentum_dependence()) {
          const ThreeVector energy_grad = pot.single_particle_energy_gradient(
              jB_lat, data.position().threevec(), data.momentum().threevec(),
              data.effective_mass(), plist);
          return -energy_grad * scale.first +
                 scale.second * data.type().isospin3_rel() *
                     (FI3.first +
                      data.momentum().velocity().cross_product(FI3.second));
        } else {
          return scale.first *
                     (FB.first +
                      data.momentum().velocity().cross_product(FB.second)) +
                 scale.second * data.type().isospin3_rel() *
                     (FI3.first +
                      data.momentum().velocity().cross_product(FI3.second));
        }
      });
      // Potentially add Lorentz force
      if (pot.use_coulomb() && EM_lat->value_at(r, EM_fields)) {
        // factor hbar*c to convert fields from 1/fm^2 to GeV/fm
        force += hbarc * data.type().charge() * elementary_charge *
                 (EM_fields.first +
                  data.momentum().velocity().cross_product(EM_fields.second));
      }
      logg[LPropagation].debug("Update momenta: F [GeV/fm] = ", force);
      data.set_4momentum(data.effective_mass(),
                         data.momentum().threevec() + force * dt);
 
      // calculate the time scale of the change in momentum
      const double Force_abs = force.abs();
      if (Force_abs < really_small) {
        continue;
      }
      const double time_scale = data.momentum().x0() / Force_abs;
      if (time_scale < min_time_scale) {
        min_time_scale = time_scale;
      }
    }
  }
  // warn if the time step is too big
  constexpr double safety_factor = 0.1;
  if (dt > safety_factor * min_time_scale) {
    logg[LPropagation].warn()
        << "The time step size is too large for an accurate propagation "
        << "with potentials. Maximum safe value: "
        << safety_factor * min_time_scale << " fm.\n"
        << "In case of Triangular or Discrete smearing you may additionally "
        << "need to increase the number of ensembles or testparticles.";
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_finder_parameters()

ScatterActionsFinderParameters smash::create_finder_parameters	(	Configuration &	config,
		const ExperimentParameters &	parameters
	)

Gather all relevant parameters for a ScatterActionsFinder either getting them from an ExperimentParameters instance or extracting them from a Configuration .

Parameters

[in]	parameters	The parameters of the considered experiment
[in,out]	config	SMASH input configuration

Returns

A ScatterActionsFinderParameters appropriately filled.

load_particles_and_decaymodes()

std::pair< std::string, std::string > smash::load_particles_and_decaymodes	(	const std::filesystem::path &	particles_file,
		const std::filesystem::path &	decaymodes_file
	)

Loads particles and decaymodes from provided files particles_file and decaymodes_file.

In case if particles_file or decaymodes_file are nullptr, the defaults are taken

Parameters

[in]	particles_file	a file containing particles list. See Particles.
[in]	decaymodes_file	a file containing decay modes of the resonances. See Decay modes.

Returns

a pair of strings – the contents of particle and decaymode files.

Definition at line 28 of file setup_particles_decaymodes.cc.

                                              {
  std::string particle_string, decay_string;
  if (!particles_file.empty()) {
    if (!std::filesystem::exists(particles_file)) {
      std::stringstream err;
      err << "The particles file was expected at '" << particles_file
          << "', but the file does not exist.";
      throw std::runtime_error(err.str());
    }
    particle_string = read_all(std::ifstream{particles_file});
    if (has_crlf_line_ending(particle_string)) {
      std::stringstream err;
      err << "The particles file has CR LF line endings. Please use LF"
             " line endings.";
      throw std::runtime_error(err.str());
    }
  } else {
    particle_string = particles_txt::data;
  }
 
  if (!decaymodes_file.empty()) {
    if (!std::filesystem::exists(decaymodes_file)) {
      std::stringstream err;
      err << "The decay modes file was expected at '" << decaymodes_file
          << "', but the file does not exist.";
      throw std::runtime_error(err.str());
    }
    decay_string = read_all(std::ifstream{decaymodes_file});
    if (has_crlf_line_ending(decay_string)) {
      std::stringstream err;
      err << "The decay mode file has CR LF line endings. Please use LF"
             " line endings.";
      throw std::runtime_error(err.str());
    }
  } else {
    decay_string = decaymodes_txt::data;
  }
  return std::make_pair(particle_string, decay_string);
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_default_particles_and_decaymodes()

void smash::initialize_default_particles_and_decaymodes

(

)

Loads default smash particle list and decaymodes.

Definition at line 70 of file setup_particles_decaymodes.cc.

                                                   {
  const auto pd = load_particles_and_decaymodes({}, {});
  ParticleType::create_type_list(pd.first);
  DecayModes::load_decaymodes(pd.second);
  ParticleType::check_consistency();
}

Here is the call graph for this function:

trim()

std::string smash::trim

(

const std::string &

s

)

Strip leading and trailing whitespaces.

Parameters

s	String to be trimmed.

Returns

Trimmed string.

Definition at line 76 of file stringfunctions.cc.

                                   {
  const auto begin = s.find_first_not_of(" \t\n\r");
  if (begin == std::string::npos) {
    return {};
  }
  const auto end = s.find_last_not_of(" \t\n\r");
  return s.substr(begin, end - begin + 1);
}

Here is the caller graph for this function:

remove_substr()

void smash::remove_substr	(	std::string &	s,
		const std::string &	p
	)

Remove all instances of a substring p in a string s.

Parameters

[in,out]	s	String to be searched and modified.
[in]	p	Substring to be removed.

Definition at line 85 of file stringfunctions.cc.

                                                     {
  using str = std::string;
  str::size_type n = p.length();
  for (str::size_type i = s.find(p); i != str::npos; i = s.find(p)) {
    s.erase(i, n);
  }
}

Here is the caller graph for this function:

isoclean()

void smash::isoclean

(

std::string &

s

)

Remove ⁺, ⁻, ⁰ from string.

Parameters

[in,out]

s

String to be cleaned.

Definition at line 93 of file stringfunctions.cc.

                            {
  remove_substr(s, "⁺");
  remove_substr(s, "⁻");
  remove_substr(s, "⁰");
}

Here is the call graph for this function:

Here is the caller graph for this function:

split() [1/2]

std::vector< std::string > smash::split	(	const std::string &	s,
		char	delim
	)

Split string by delimiter.

Parameters

[in]	s	String to be split.
[in]	delim	Splitting delimiter.

Returns

Split string.

Definition at line 121 of file stringfunctions.cc.

                                                           {
  std::vector<std::string> elems;
  split(s, delim, std::back_inserter(elems));
  return elems;
}

Here is the caller graph for this function:

join() [1/3]

std::string smash::join	(	const std::vector< std::string > &	v,
		std::string_view	delim
	)

Join strings using delimiter.

Parameters

[in]	v	Strings to be joint.
[in]	delim	Joining delimiter.

Returns

Joint string.

Definition at line 162 of file stringfunctions.cc.

                                                                    {
  return join_impl(v, delim);
}

Here is the call graph for this function:

Here is the caller graph for this function:

join() [2/3]

std::string smash::join	(	const std::vector< std::string_view > &	v,
		std::string_view	delim
	)

Join string views using delimiter.

Parameters

[in]	v	String views to be joint.
[in]	delim	Joining delimiter.

Returns

Joint string.

Definition at line 166 of file stringfunctions.cc.

                                       {
  return join_impl(v, delim);
}

Here is the call graph for this function:

join() [3/3]

std::string smash::join	(	const std::set< std::string > &	s,
		std::string_view	delim
	)

Join strings using delimiter.

Parameters

[in]	s	Strings to be joint.
[in]	delim	Joining delimiter.

Returns

Joint string.

Definition at line 171 of file stringfunctions.cc.

                                                                 {
  return join_impl(s, delim);
}

Here is the call graph for this function:

quote()

std::string smash::quote

(

const std::string &

s

)

Add quotes around string.

This is a simpler version of std::quoted that also escapes e.g. contained quotes and cannot directly be converted to a string.

Parameters

[in]

s

Strings to be quoted.

Returns

Quoted string.

Definition at line 175 of file stringfunctions.cc.

{ return "\"" + s + "\""; }

Here is the caller graph for this function:

to_string() [1/27]

std::string smash::to_string

(

ThermodynamicQuantity

quantity

)

Convert a ThermodynamicQuantity enum value to its corresponding string.

Parameters

[in]

quantity

The ThermodynamicQuantity enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 26 of file stringify.cc.

                                                    {
  switch (quantity) {
    case ThermodynamicQuantity::EckartDensity:
      return "rho_eckart";
    case ThermodynamicQuantity::Tmn:
      return "tmn";
    case ThermodynamicQuantity::TmnLandau:
      return "tmn_landau";
    case ThermodynamicQuantity::LandauVelocity:
      return "landau_velocity";
    case ThermodynamicQuantity::j_QBS:
      return "j_QBS";
  }
  throw_unhandled_enum("ThermodynamicQuantity", static_cast<int>(quantity));
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_string() [2/27]

std::string smash::to_string

(

CalculationFrame

frame

)

Convert a CalculationFrame enum value to its corresponding string.

Parameters

[in]

frame

The CalculationFrame enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 42 of file stringify.cc.

                                            {
  switch (frame) {
    case CalculationFrame::CenterOfVelocity:
      return "center of velocity";
    case CalculationFrame::CenterOfMass:
      return "center of mass";
    case CalculationFrame::FixedTarget:
      return "fixed target";
  }
  throw_unhandled_enum("CalculationFrame", static_cast<int>(frame));
}

Here is the call graph for this function:

to_string() [3/27]

std::string smash::to_string

(

DileptonBremsPionFormFactor

factor

)

Convert a DileptonBremsPionFormFactor enum value to its corresponding string.

Parameters

[in]

factor

The DileptonBremsPionFormFactor enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 54 of file stringify.cc.

                                                        {
  switch (factor) {
    case DileptonBremsPionFormFactor::FF1:
      return "FF1";
    case DileptonBremsPionFormFactor::FF2:
      return "FF2";
    case DileptonBremsPionFormFactor::Off:
      return "Off";
  }
  throw_unhandled_enum("DileptonBremsPionFormFactor", static_cast<int>(factor));
}

Here is the call graph for this function:

to_string() [4/27]

std::string smash::to_string

(

FermiMotion

motion

)

Convert a FermiMotion enum value to its corresponding string.

Parameters

[in]

motion

The FermiMotion enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 66 of file stringify.cc.

                                        {
  switch (motion) {
    case FermiMotion::Off:
      return "off";
    case FermiMotion::On:
      return "on";
    case FermiMotion::Frozen:
      return "frozen";
  }
  throw_unhandled_enum("FermiMotion", static_cast<int>(motion));
}

Here is the call graph for this function:

to_string() [5/27]

std::string smash::to_string

(

DensityType

type

)

Convert a DensityType enum value to its corresponding string.

Parameters

[in]

type

The DensityType enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 78 of file stringify.cc.

                                      {
  switch (type) {
    case DensityType::Hadron:
      return "hadron";
    case DensityType::Baryon:
      return "baryon";
    case DensityType::BaryonicIsospin:
      return "baryonic isospin";
    case DensityType::Pion:
      return "pion";
    case DensityType::Isospin3_tot:
      return "total isospin";
    case DensityType::None:
      return "none";
    case DensityType::Charge:
      return "charge";
    case DensityType::Strangeness:
      return "strangeness";
  }
  throw_unhandled_enum("DensityType", static_cast<int>(type));
}

Here is the call graph for this function:

to_string() [6/27]

std::string smash::to_string

(

ExpansionMode

mode

)

Convert an ExpansionMode enum value to its corresponding string.

Parameters

[in]

mode

The ExpansionMode enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 100 of file stringify.cc.

                                        {
  switch (mode) {
    case ExpansionMode::NoExpansion:
      return "NoExpansion";
    case ExpansionMode::MasslessFRW:
      return "MasslessFRW";
    case ExpansionMode::MassiveFRW:
      return "MassiveFRW";
    case ExpansionMode::Exponential:
      return "Exponential";
  }
  throw_unhandled_enum("ExpansionMode", static_cast<int>(mode));
}

Here is the call graph for this function:

to_string() [7/27]

std::string smash::to_string

(

DerivativesMode

mode

)

Convert a DerivativesMode enum value to its corresponding string.

Parameters

[in]

mode

The DerivativesMode enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 114 of file stringify.cc.

                                          {
  switch (mode) {
    case DerivativesMode::CovariantGaussian:
      return "Covariant Gaussian";
    case DerivativesMode::FiniteDifference:
      return "Finite difference";
    case DerivativesMode::Off:
      return "Off";
  }
  throw_unhandled_enum("DerivativesMode", static_cast<int>(mode));
}

Here is the call graph for this function:

to_string() [8/27]

std::string smash::to_string

(

FieldDerivativesMode

mode

)

Convert a FieldDerivativesMode enum value to its corresponding string.

Parameters

[in]

mode

The FieldDerivativesMode enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 126 of file stringify.cc.

                                               {
  switch (mode) {
    case FieldDerivativesMode::ChainRule:
      return "Chain Rule";
    case FieldDerivativesMode::Direct:
      return "Direct";
  }
  throw_unhandled_enum("FieldDerivativesMode", static_cast<int>(mode));
}

Here is the call graph for this function:

to_string() [9/27]

std::string smash::to_string

(

SmearingMode

mode

)

Convert a SmearingMode enum value to its corresponding string.

Parameters

[in]

mode

The SmearingMode enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 136 of file stringify.cc.

                                       {
  switch (mode) {
    case SmearingMode::CovariantGaussian:
      return "Covariant Gaussian";
    case SmearingMode::Discrete:
      return "Discrete";
    case SmearingMode::Triangular:
      return "Triangular";
  }
  throw_unhandled_enum("SmearingMode", static_cast<int>(mode));
}

Here is the call graph for this function:

to_string() [10/27]

std::string smash::to_string

(

TimeStepMode

mode

)

Convert a TimeStepMode enum value to its corresponding string.

Parameters

[in]

mode

The TimeStepMode enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 148 of file stringify.cc.

                                       {
  switch (mode) {
    case TimeStepMode::None:
      return "None";
    case TimeStepMode::Fixed:
      return "Fixed";
  }
  throw_unhandled_enum("TimeStepMode", static_cast<int>(mode));
}

Here is the call graph for this function:

to_string() [11/27]

std::string smash::to_string

(

BoxInitialCondition

cond

)

Convert a BoxInitialCondition enum value to its corresponding string.

Parameters

[in]

cond

The BoxInitialCondition enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 158 of file stringify.cc.

                                              {
  switch (cond) {
    case BoxInitialCondition::ThermalMomentaBoltzmann:
      return "thermal momenta";
    case BoxInitialCondition::ThermalMomentaQuantum:
      return "thermal momenta quantum";
    case BoxInitialCondition::PeakedMomenta:
      return "peaked momenta";
  }
  throw_unhandled_enum("BoxInitialCondition", static_cast<int>(cond));
}

Here is the call graph for this function:

to_string() [12/27]

std::string smash::to_string

(

SphereInitialCondition

cond

)

Convert a SphereInitialCondition enum value to its corresponding string.

Parameters

[in]

cond

The SphereInitialCondition enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 170 of file stringify.cc.

                                                 {
  switch (cond) {
    case SphereInitialCondition::ThermalMomentaBoltzmann:
      return "thermal momenta";
    case SphereInitialCondition::ThermalMomentaQuantum:
      return "thermal momenta quantum";
    case SphereInitialCondition::IC_ES:
      return "IC_ES";
    case SphereInitialCondition::IC_1M:
      return "IC_1M";
    case SphereInitialCondition::IC_2M:
      return "IC_2M";
    case SphereInitialCondition::IC_Massive:
      return "IC_Massive";
  }
  throw_unhandled_enum("SphereInitialCondition", static_cast<int>(cond));
}

Here is the call graph for this function:

to_string() [13/27]

std::string smash::to_string

(

NNbarTreatment

t

)

Convert a NNbarTreatment enum value to its corresponding string.

Parameters

[in]

t

The NNbarTreatment enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 188 of file stringify.cc.

                                      {
  switch (t) {
    case NNbarTreatment::NoAnnihilation:
      return "no annihilation";
    case NNbarTreatment::Resonances:
      return "resonances";
    case NNbarTreatment::TwoToFive:
      return "two to five";
    case NNbarTreatment::Strings:
      return "strings";
  }
  throw_unhandled_enum("NNbarTreatment", static_cast<int>(t));
}

Here is the call graph for this function:

to_string() [14/27]

std::string smash::to_string

(

Sampling

s

)

Convert a Sampling enum value to its corresponding string.

Parameters

[in]

s

The Sampling enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 202 of file stringify.cc.

                                {
  switch (s) {
    case Sampling::Quadratic:
      return "quadratic";
    case Sampling::Custom:
      return "custom";
    case Sampling::Uniform:
      return "uniform";
  }
  throw_unhandled_enum("Sampling", static_cast<int>(s));
}

Here is the call graph for this function:

to_string() [15/27]

std::string smash::to_string

(

ThermalizationAlgorithm

algo

)

Convert a ThermalizationAlgorithm enum value to its corresponding string.

Parameters

[in]

algo

The ThermalizationAlgorithm enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 214 of file stringify.cc.

                                                  {
  switch (algo) {
    case ThermalizationAlgorithm::ModeSampling:
      return "mode sampling";
    case ThermalizationAlgorithm::BiasedBF:
      return "biased BF";
    case ThermalizationAlgorithm::UnbiasedBF:
      return "unbiased BF";
  }
  throw_unhandled_enum("ThermalizationAlgorithm", static_cast<int>(algo));
}

Here is the call graph for this function:

to_string() [16/27]

std::string smash::to_string

(

CollisionCriterion

c

)

Convert a CollisionCriterion enum value to its corresponding string.

Parameters

[in]

c

The CollisionCriterion enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 226 of file stringify.cc.

                                          {
  switch (c) {
    case CollisionCriterion::Geometric:
      return "Geometric";
    case CollisionCriterion::Stochastic:
      return "Stochastic";
    case CollisionCriterion::Covariant:
      return "Covariant";
  }
  throw_unhandled_enum("CollisionCriterion", static_cast<int>(c));
}

Here is the call graph for this function:

to_string() [17/27]

std::string smash::to_string

(

CharmRescattering

c

)

Convert a CharmRescattering enum value to its corresponding string.

Parameters

[in]

c

The CharmRescattering enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 238 of file stringify.cc.

                                         {
  switch (c) {
    case CharmRescattering::None:
      return "none";
    case CharmRescattering::Resonances:
      return "resonances";
    case CharmRescattering::T_Matrix:
      return "T-matrix";
  }
  throw_unhandled_enum("CharmRescattering", static_cast<int>(c));
}

Here is the call graph for this function:

to_string() [18/27]

std::string smash::to_string

(

SpinInteractionType

type

)

Convert a SpinInteractionType enum value to its corresponding string.

Parameters

[in]

type

The SpinInteractionType enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 250 of file stringify.cc.

                                              {
  switch (type) {
    case SpinInteractionType::On:
      return "On";
    case SpinInteractionType::Off:
      return "Off";
  }
  throw_unhandled_enum("SpinInteractionType", static_cast<int>(type));
}

Here is the call graph for this function:

to_string() [19/27]

std::string smash::to_string

(

HardStringTransitionMode

mode

)

Convert a HardStringTransitionMode enum value to its corresponding string.

Parameters

[in]

mode

The HardStringTransitionMode enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

to_string() [20/27]

std::string smash::to_string

(

TotalCrossSectionStrategy

s

)

Convert a TotalCrossSectionStrategy enum value to its corresponding string.

Parameters

[in]

s

The TotalCrossSectionStrategy enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 260 of file stringify.cc.

                                                 {
  switch (s) {
    case TotalCrossSectionStrategy::BottomUp:
      return "BottomUp";
    case TotalCrossSectionStrategy::TopDown:
      return "TopDown";
    case TotalCrossSectionStrategy::TopDownMeasured:
      return "TopDownMeasured";
  }
  throw_unhandled_enum("TotalCrossSectionStrategy", static_cast<int>(s));
}

Here is the call graph for this function:

to_string() [21/27]

std::string smash::to_string

(

PseudoResonance

p

)

Convert a PseudoResonance enum value to its corresponding string.

Parameters

[in]

p

The PseudoResonance enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 272 of file stringify.cc.

                                       {
  switch (p) {
    case PseudoResonance::None:
      return "None";
    case PseudoResonance::Largest:
      return "Largest";
    case PseudoResonance::Closest:
      return "Closest";
    case PseudoResonance::LargestFromUnstable:
      return "LargestFromUnstable";
    case PseudoResonance::ClosestFromUnstable:
      return "ClosestFromUnstable";
  }
  throw_unhandled_enum("PseudoResonance", static_cast<int>(p));
}

Here is the call graph for this function:

to_string() [22/27]

std::string smash::to_string

(

FluidizationType

f

)

Convert a FluidizationType enum value to its corresponding string.

Parameters

[in]

f

The FluidizationType enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 288 of file stringify.cc.

                                        {
  switch (f) {
    case FluidizationType::ConstantTau:
      return "Constant_Tau";
    case FluidizationType::Dynamic:
      return "Dynamic";
  }
  throw_unhandled_enum("FluidizationType", static_cast<int>(f));
}

Here is the call graph for this function:

to_string() [23/27]

std::string smash::to_string

(

OutputOnlyFinal

o

)

Convert an OutputOnlyFinal enum value to its corresponding string.

Parameters

[in]

o

The OutputOnlyFinal enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 298 of file stringify.cc.

                                       {
  switch (o) {
    case OutputOnlyFinal::Yes:
      return "Yes";
    case OutputOnlyFinal::No:
      return "No";
    case OutputOnlyFinal::IfNotEmpty:
      return "IfNotEmpty";
  }
  throw_unhandled_enum("OutputOnlyFinal", static_cast<int>(o));
}

Here is the call graph for this function:

to_string() [24/27]

std::string smash::to_string

(

einhard::LogLevel

level

)

Convert a LogLevel enum value to its corresponding string.

Parameters

[in]

level

The LogLevel enum value to convert.

Returns

std::string Corresponding string representation.

Exceptions

std::invalid_argument

If the enum value is unhandled.

Definition at line 310 of file stringify.cc.

                                           {
  switch (level) {
    case einhard::LogLevel::ALL:
      return "ALL";
    case einhard::LogLevel::TRACE:
      return "TRACE";
    case einhard::LogLevel::DEBUG:
      return "DEBUG";
    case einhard::LogLevel::INFO:
      return "INFO";
    case einhard::LogLevel::WARN:
      return "WARN";
    case einhard::LogLevel::ERROR:
      return "ERROR";
    case einhard::LogLevel::FATAL:
      return "FATAL";
    case einhard::LogLevel::OFF:
      return "OFF";
  }
  throw_unhandled_enum("einhard::LogLevel", static_cast<int>(level));
}

Here is the call graph for this function:

to_string() [25/27]

std::vector< std::string > smash::to_string

(

const ReactionsBitSet &

s

)

Convert a ReactionsBitSet to a vector of strings for all set reactions.

Parameters

[in]

s

The ReactionsBitSet to convert.

Returns

std::vector<std::string> Vector of all set reaction names.

Definition at line 332 of file stringify.cc.

                                                         {
  std::vector<std::string> result{};
  if (s.test(IncludedReactions::Elastic))
    result.push_back("Elastic");
  if (s.test(IncludedReactions::NN_to_NR))
    result.push_back("NN_to_NR");
  if (s.test(IncludedReactions::NN_to_DR))
    result.push_back("NN_to_DR");
  if (s.test(IncludedReactions::KN_to_KN))
    result.push_back("KN_to_KN");
  if (s.test(IncludedReactions::KN_to_KDelta))
    result.push_back("KN_to_KDelta");
  if (s.test(IncludedReactions::Strangeness_exchange))
    result.push_back("Strangeness_exchange");
  if (s.test(IncludedReactions::NNbar))
    result.push_back("NNbar");
  if (s.test(IncludedReactions::PiDeuteron_to_NN))
    result.push_back("PiDeuteron_to_NN");
  if (s.test(IncludedReactions::PiDeuteron_to_pidprime))
    result.push_back("PiDeuteron_to_pidprime");
  if (s.test(IncludedReactions::NDeuteron_to_Ndprime))
    result.push_back("NDeuteron_to_Ndprime");
  if (s.test(IncludedReactions::Charm_T_matrix))
    result.push_back("Charm_T-matrix");
  return result;
}

to_string() [26/27]

std::vector< std::string > smash::to_string

(

const MultiParticleReactionsBitSet &

s

)

Convert a MultiParticleReactionsBitSet to a vector of strings for all set reactions.

Parameters

[in]

s

The MultiParticleReactionsBitSet to convert.

Returns

std::vector<std::string> Vector of all set reaction names.

Definition at line 359 of file stringify.cc.

                                                                      {
  std::vector<std::string> result{};
  if (s.test(IncludedMultiParticleReactions::Meson_3to1))
    result.push_back("Meson_3to1");
  if (s.test(IncludedMultiParticleReactions::Deuteron_3to2))
    result.push_back("Deuteron_3to2");
  if (s.test(IncludedMultiParticleReactions::NNbar_5to2))
    result.push_back("NNbar_5to2");
  if (s.test(IncludedMultiParticleReactions::A3_Nuclei_4to2))
    result.push_back("A3_Nuclei_4to2");
  return result;
}

to_string() [27/27]

std::vector< std::string > smash::to_string

(

const FluidizableProcessesBitSet &

s

)

Convert a FluidizableProcessesBitSet to a vector of strings for all set processes.

Parameters

[in]

s

The FluidizableProcessesBitSet to convert.

Returns

std::vector<std::string> Vector of all set process names.

Definition at line 372 of file stringify.cc.

                                                                    {
  std::vector<std::string> result{};
  if (s.test(IncludedFluidizableProcesses::From_Elastic))
    result.push_back("Elastic");
  if (s.test(IncludedFluidizableProcesses::From_Decay))
    result.push_back("Decay");
  if (s.test(IncludedFluidizableProcesses::From_Inelastic))
    result.push_back("Inelastic");
  if (s.test(IncludedFluidizableProcesses::From_SoftString))
    result.push_back("SoftString");
  if (s.test(IncludedFluidizableProcesses::From_HardString))
    result.push_back("HardString");
  return result;
}

spec_func_integrand_1res()

double smash::spec_func_integrand_1res ( double  resonance_mass, double  sqrts, double  stable_mass, const ParticleType &  type  )

inline

Spectral function integrand for GSL integration, with one resonance in the final state (the second particle is stable).

The integrand is \( A(m) p_{cm}^f \), where \( m \) is the resonance mass, \( A(m) \) is the spectral function and \( p_{cm}^f \) is the center-of-mass momentum of the final state.

Parameters

[in]	resonance_mass	Actual mass of the resonance [GeV].
[in]	sqrts	Center-of-mass Energy, i.e. sqrt of Mandelstam s [GeV].
[in]	stable_mass	Mass of the stable particle in the final state [GeV].
[in]	type	Type of the resonance.

Returns

Value of the integrand.

Definition at line 144 of file tabulation.h.

                                                                 {
  if (sqrts <= stable_mass + resonance_mass) {
    return 0.;
  }
 
  /* Integrand is the spectral function weighted by the CM momentum of the
   * final state. */
  return type.full_spectral_function(resonance_mass) *
         pCM(sqrts, stable_mass, resonance_mass);
}

Here is the call graph for this function:

Here is the caller graph for this function:

spec_func_integrand_2res()

double smash::spec_func_integrand_2res ( double  sqrts, double  res_mass_1, double  res_mass_2, const ParticleType &  t1, const ParticleType &  t2  )

inline

Spectral function integrand for GSL integration, with two resonances in the final state.

The integrand is \( A_1(m_1) A_2(m_2) p_{cm}^f \), where \( m_1 \) and \( m_2 \) are the resonance masses, \( A_1 \) and \( A_2 \) are the spectral functions and \( p_{cm}^f \) is the center-of-mass momentum of the final state.

Parameters

[in]	sqrts	Center-of-mass energy, i.e. sqrt of Mandelstam s [GeV].
[in]	res_mass_1	Actual mass of the first resonance [GeV].
[in]	res_mass_2	Actual mass of the second resonance [GeV].
[in]	t1	Type of the first resonance.
[in]	t2	Type of the second resonance.

Returns

Value of the integrand.

Definition at line 173 of file tabulation.h.

                                                               {
  if (sqrts <= res_mass_1 + res_mass_2) {
    return 0.;
  }
 
  /* Integrand is the product of the spectral function weighted by the
   * CM momentum of the final state. */
  return t1.full_spectral_function(res_mass_1) *
         t2.full_spectral_function(res_mass_2) *
         pCM(sqrts, res_mass_1, res_mass_2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

spectral_integral_semistable()

Tabulation smash::spectral_integral_semistable ( Integrator &  integrate, const ParticleType &  resonance, const ParticleType &  stable, double  range  )

inline

Create a table for the spectral integral of a resonance and a stable particle.

Parameters

[in,out]	integrate	Numerical integrator.
[in]	resonance	Type of the resonance particle.
[in]	stable	Type of the stable particle.
[in]	range	Distance between tabulation points [GeV].

Returns

Tabulation of the given integral.

Definition at line 198 of file tabulation.h.

                                                             {
  const double m_min = resonance.min_mass_kinematic();
  const double m_stable = stable.mass();
  return Tabulation(m_min + m_stable, range, 100, [&](double srts) {
    return integrate(m_min, srts - m_stable, [&](double m) {
      return spec_func_integrand_1res(m, srts, m_stable, resonance);
    });
  });
}

Here is the call graph for this function:

Here is the caller graph for this function:

spectral_integral_unstable()

Tabulation smash::spectral_integral_unstable ( Integrator2d &  integrate2d, const ParticleType &  res1, const ParticleType &  res2, double  range  )

inline

Create a table for the spectral integral of two resonances.

Parameters

[in,out]	integrate2d	Numerical integrator.
[in]	res1	Type of the first resonance particle.
[in]	res2	Type of the second resonance particle.
[in]	range	Distance between tabulation points [GeV].

Returns

Tabulation of the given integral.

Definition at line 220 of file tabulation.h.

                                                           {
  const double m1_min = res1.min_mass_kinematic();
  const double m2_min = res2.min_mass_kinematic();
  return Tabulation(m1_min + m2_min, range, 125, [&](double srts) {
    const double m1_max = srts - m2_min;
    const double m2_max = srts - m1_min;
    return integrate2d(
        m1_min, m1_max, m2_min, m2_max, [&](double m1, double m2) {
          return spec_func_integrand_2res(srts, m1, m2, res1, res2);
        });
  });
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator+() [3/3]

ThreeVector smash::operator+ ( ThreeVector  a, const ThreeVector &  b  )

inline

Returns

sum of two three-vectors: \( \mathbf{a} + \mathbf{b} \).

Definition at line 211 of file threevector.h.

                                                                  {
  a += b;
  return a;
}

operator-() [4/4]

ThreeVector smash::operator- ( ThreeVector  a, const ThreeVector &  b  )

inline

Returns

difference between two three-vectors: \(\mathbf{a}-\mathbf{b}\).

Definition at line 224 of file threevector.h.

                                                                  {
  a -= b;
  return a;
}

operator*() [6/8]

ThreeVector smash::operator* ( ThreeVector  a, const double &  b  )

inline

multiply a three-vector by constant factor: \( b\cdot\mathbf{a} \).

Definition at line 237 of file threevector.h.

                                                             {
  a *= b;
  return a;
}

operator*() [7/8]

ThreeVector smash::operator* ( const double &  a, ThreeVector  b  )

inline

multiply a three-vector by constant factor: \( a\cdot\mathbf{b} \).

Definition at line 243 of file threevector.h.

                                                             {
  b *= a;
  return b;
}

operator*() [8/8]

double smash::operator* ( ThreeVector  a, const ThreeVector &  b  )

inline

Returns

inner product of two three-vectors: \(\mathbf{a}\cdot\mathbf{b}\).

Definition at line 251 of file threevector.h.

                                                             {
  return a.x1() * b.x1() + a.x2() * b.x2() + a.x3() * b.x3();
}

Here is the call graph for this function:

operator/() [3/3]

ThreeVector smash::operator/ ( ThreeVector  a, const double &  b  )

inline

divide a three-vector by constant factor: \(\mathbf{a}/b\).

Definition at line 270 of file threevector.h.

                                                             {
  a /= b;
  return a;
}

get_list_of_binary_quantities()

static auto smash::get_list_of_binary_quantities ( const std::string &  content, const std::string &  format, const OutputParameters &  parameters  )

static

Definition at line 422 of file binaryoutput.cc.

                                                                              {
  const bool is_extended = std::invoke([&content, &parameters]() {
    if (content == "Particles")
      return parameters.part_extended;
    else if (content == "Collisions")
      return parameters.coll_extended;
    else if (content == "Dileptons")
      return parameters.dil_extended;
    else if (content == "Photons")
      return parameters.photons_extended;
    else if (content == "Initial_Conditions")
      return parameters.ic_extended;
    else
      return false;
  });
  const auto default_quantities =
      (is_extended) ? OutputDefaultQuantities::oscar2013extended
                    : OutputDefaultQuantities::oscar2013;
  if (format == "Oscar2013_bin") {
    return default_quantities;
  } else if (format == "Binary") {
    if (content == "Particles" || content == "Collisions" ||
        content == "Dileptons" || content == "Photons" ||
        content == "Initial_Conditions") {
      auto list_of_quantities = parameters.quantities.at(content);
      if (list_of_quantities.empty()) {
        return default_quantities;
      } else {
        return list_of_quantities;
      }
    } else {
      /* Note that this function should not be called with "Binary" format for
       * output contents which do not support custom binary quantities. Hence we
       * throw here to prevent such a case.*/
      throw std::invalid_argument(
          "Unknown content to get the list of quantities for binary output.");
    }
  } else {
    throw std::invalid_argument(
        "Unknown format to get the list of quantities for binary output.");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_binary_filename()

static auto smash::get_binary_filename ( const std::string &  content, const std::vector< std::string > &  quantities  )

static

Definition at line 26 of file binaryoutput.cc.

                                                                        {
  std::string filename = content;
  if (content == "Particles" || content == "Collisions") {
    std::transform(filename.begin(), filename.end(), filename.begin(),
                   [](unsigned char c) { return std::tolower(c); });
  } else if (content == "Photons" || content == "Dileptons") {
    // Nothing to be done here
  } else if (content == "Initial_Conditions") {
    filename = "SMASH_IC";
  } else {
    throw std::invalid_argument(
        "Unknown content to get the binary output filename.");
  }
  if (quantities == OutputDefaultQuantities::oscar2013) {
    filename += "_oscar2013";
  } else if (quantities == OutputDefaultQuantities::oscar2013extended) {
    filename += "_oscar2013_extended";
  } else {
    filename += "_custom";
  }
  return filename + ".bin";
}

operator<<() [4/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const BoxModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The BoxModus object to write into out

Definition at line 33 of file boxmodus.cc.

                                                           {
  out << "-- Box Modus:\nSize of the box: (" << m.length_ << " fm)³\n";
  if (m.use_thermal_) {
    out << "Thermal multiplicities "
        << "(T = " << m.temperature_ << " GeV, muB = " << m.mub_
        << " GeV, muS = " << m.mus_ << " GeV, muQ = " << m.muq_ << " GeV)\n";
  } else {
    for (const auto &p : m.init_multipl_) {
      ParticleTypePtr ptype = &ParticleType::find(p.first);
      out << ptype->name() << " initial multiplicity " << p.second << '\n';
    }
  }
  switch (m.initial_condition_) {
    case BoxInitialCondition::PeakedMomenta:
      out << "All initial momenta = 3T = " << 3 * m.temperature_ << " GeV\n";
      break;
    case BoxInitialCondition::ThermalMomentaBoltzmann:
      out << "Boltzmann momentum distribution with T = " << m.temperature_
          << " GeV.\n";
      break;
    case BoxInitialCondition::ThermalMomentaQuantum:
      out << "Fermi/Bose momentum distribution with T = " << m.temperature_
          << " GeV.\n";
      break;
  }
  if (m.jet_pdg_) {
    ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_.value());
    out << "Adding a " << ptype->name() << " as a jet in the middle "
        << "of the box with " << m.jet_mom_ << " GeV initial momentum.\n";
  }
  return out;
}

isospin_clebsch_gordan_2to1()

static double smash::isospin_clebsch_gordan_2to1 ( const ParticleType &  p_a, const ParticleType &  p_b, const int  I_tot, const int  I_z  )

static

Calculate isospin Clebsch-Gordan coefficient for two particles p_a and p_b coupling to a total isospin.

See also

ClebschGordan::coefficient for details (I_tot, I_z).

Parameters

[in]	p_a	Information of particle type for first particle
[in]	p_b	Information of particle type for second particle
[out]	I_tot	Total isospin of the reaction
[out]	I_z	Total isospin 3 component of the reaction

Definition at line 30 of file clebschgordan.cc.

                                                                          {
  return ClebschGordan::coefficient(p_a.isospin(), p_b.isospin(), I_tot,
                                    p_a.isospin3(), p_b.isospin3(), I_z);
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [5/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const ColliderModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The ColliderModus object to write into out

Definition at line 352 of file collidermodus.cc.

                                                                {
  return out << "-- Collider Modus:\n"
             << "sqrt(S) (nucleus-nucleus) = "
             << format(std::sqrt(m.total_s_), "GeV\n")
             << "sqrt(S) (nucleon-nucleon) = " << format(m.sqrt_s_NN_, "GeV\n")
             << "Projectile:\n"
             << *m.projectile_ << "\nTarget:\n"
             << *m.target_;
}

detailed_balance_factor_stable()

static double smash::detailed_balance_factor_stable ( double  s, const ParticleType &  a, const ParticleType &  b, const ParticleType &  c, const ParticleType &  d  )

static

Helper function: Calculate the detailed balance factor R such that.

\[ R = \sigma(AB \to CD) / \sigma(CD \to AB) \]

where \( A, B, C, D \) are stable.

Definition at line 29 of file crosssections.cc.

                                                                    {
  double spin_factor = (c.spin() + 1) * (d.spin() + 1);
  spin_factor /= (a.spin() + 1) * (b.spin() + 1);
  double symmetry_factor = (1 + (a == b));
  symmetry_factor /= (1 + (c == d));
  const double momentum_factor = pCM_sqr_from_s(s, c.mass(), d.mass()) /
                                 pCM_sqr_from_s(s, a.mass(), b.mass());
  return spin_factor * symmetry_factor * momentum_factor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

detailed_balance_factor_RK()

static double smash::detailed_balance_factor_RK ( double  sqrts, double  pcm, const ParticleType &  a, const ParticleType &  b, const ParticleType &  c, const ParticleType &  d  )

static

Helper function: Calculate the detailed balance factor R such that.

\[ R = \sigma(AB \to CD) / \sigma(CD \to AB) \]

where \(A\) is unstable, \(B\) is a kaon and \(C, D\) are stable.

Definition at line 48 of file crosssections.cc.

                                                                {
  assert(!a.is_stable());
  assert(b.pdgcode().is_kaon());
  double spin_factor = (c.spin() + 1) * (d.spin() + 1);
  spin_factor /= (a.spin() + 1) * (b.spin() + 1);
  double symmetry_factor = (1 + (a == b));
  symmetry_factor /= (1 + (c == d));
  const double momentum_factor =
      pCM_sqr(sqrts, c.mass(), d.mass()) /
      (pcm * a.iso_multiplet()->get_integral_RK(sqrts));
  return spin_factor * symmetry_factor * momentum_factor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

detailed_balance_factor_RR()

static double smash::detailed_balance_factor_RR ( double  sqrts, double  pcm, const ParticleType &  a, const ParticleType &  b, const ParticleType &  c, const ParticleType &  d  )

static

Helper function: Calculate the detailed balance factor R such that.

\[ R = \sigma(AB \to CD) / \sigma(CD \to AB) \]

where \(A\) and \(B\) are unstable, and \(C\) and \(D\) are stable.

Definition at line 71 of file crosssections.cc.

                                                                {
  assert(!a.is_stable());
  assert(!b.is_stable());
  double spin_factor = (c.spin() + 1) * (d.spin() + 1);
  spin_factor /= (a.spin() + 1) * (b.spin() + 1);
  double symmetry_factor = (1 + (a == b));
  symmetry_factor /= (1 + (c == d));
  const double momentum_factor =
      pCM_sqr(sqrts, c.mass(), d.mass()) /
      (pcm * a.iso_multiplet()->get_integral_RR(b.iso_multiplet(), sqrts));
  return spin_factor * symmetry_factor * momentum_factor;
}

Here is the call graph for this function:

Here is the caller graph for this function:

append_list()

static void smash::append_list ( CollisionBranchList &  main_list, CollisionBranchList  in_list, double  weight = 1.  )

static

Helper function: Append a list of processes to another (main) list of processes.

Definition at line 92 of file crosssections.cc.

                                                                         {
  main_list.reserve(main_list.size() + in_list.size());
  for (auto& proc : in_list) {
    proc->set_weight(proc->weight() * weight);
    main_list.emplace_back(std::move(proc));
  }
}

Here is the caller graph for this function:

throw_xsec_is_not_implemented()

static void smash::throw_xsec_is_not_implemented ( const ParticleData &  data_a, const ParticleData &  data_b, const std::string  func_name  )

static

Helper function: Throw if cross section between two particles is not implemented.

Parameters

[in]	data_a	incoming particle a
[in]	data_b	incoming particle b
[in]	func_name	name of the function that encountered the throw

Definition at line 109 of file crosssections.cc.

                               {
  std::stringstream ss{};
  const ParticleType& a = data_a.type();
  const ParticleType& b = data_b.type();
  ss << "Cross section for scattering of " << a.name() << " and " << b.name()
     << " is not implemented in function 'CrossSections::" << func_name << "'.";
  throw std::runtime_error(ss.str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

throw_xsec_is_negative()

static void smash::throw_xsec_is_negative ( const double  sqrts, const double  xsec, const ParticleData &  data_a, const ParticleData &  data_b, std::string  func_name  )

static

Helper function: Throw if cross section is negative.

Parameters

[in]	sqrts	center of mass energy of incoming particles
[in]	xsec	cross section
[in]	data_a	incoming particle a
[in]	data_b	incoming particle b
[in]	func_name	name of the function that encountered the throw

Definition at line 130 of file crosssections.cc.

                                                                     {
  const ParticleType& a = data_a.type();
  const ParticleType& b = data_b.type();
  const PdgCode& pdg_a = a.pdgcode();
  const PdgCode& pdg_b = b.pdgcode();
  std::stringstream ss{};
  ss << "Negative cross section encountered in function 'CrossSections::"
     << func_name << "':\na=" << a.name() << " b=" << b.name()
     << " j_a=" << pdg_a.spin() << " j_b=" << pdg_b.spin() << " sigma=" << xsec
     << " s=" << sqrts * sqrts << " sqrt(s)=" << sqrts;
  throw std::runtime_error(ss.str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

effective_AQM_s()

static double smash::effective_AQM_s ( const double  mandelstam_s, const double  m1, const double  m2, const double  m1_ref, const double  m2_ref  )

static

Helper function: Shift the energy of a collision for AQM rescaled cross sections.

Parameters

[in]	mandelstam_s	the rest frame total energy squared
[in]	m1	effective mass of incoming first particle
[in]	m2	effective mass of incoming second particle
[in]	m1_ref	mass of the first AQM reference
[in]	m2_ref	mass of the second AQM reference

Returns

the shifted center of mass energy squared

Definition at line 158 of file crosssections.cc.

                                                   {
  const double eff_sqrt_s = std::sqrt(mandelstam_s) - m1 - m2 + m1_ref + m2_ref;
  return eff_sqrt_s * eff_sqrt_s;
}

Here is the caller graph for this function:

AQM_based_on_piminusp_high_energy()

static double smash::AQM_based_on_piminusp_high_energy ( const double  sqrts, const PdgCode &  pdg_a, const PdgCode &  pdg_b, const double  AQM_scaling_factor_a, const double  AQM_scaling_factor_b  )

static

Helper function: Approximate cross section using AQM based on function piminusp_high_energy.

Parameters

[in]	sqrts	center of mass energy of incoming particles
[in]	pdg_a	PDG code of incoming particle a
[in]	pdg_b	PDG code of incoming particle b
[in]	AQM_scaling_factor_a	AQM scaling factor of incoming particle a
[in]	AQM_scaling_factor_b	AQM scaling factor of incoming particle b

Returns

the approximated cross section

Definition at line 176 of file crosssections.cc.

                                                                          {
  int n_mesons = 0;
  if (pdg_a.is_meson()) {
    n_mesons += 1;
  }
  if (pdg_b.is_meson()) {
    n_mesons += 1;
  }
  return std::pow(2. / 3., n_mesons - 1) * piminusp_high_energy(sqrts * sqrts) *
         AQM_scaling_factor_a * AQM_scaling_factor_b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

warn_if_charm_rescattering_enabled_and_AQM_disabled()

static void smash::warn_if_charm_rescattering_enabled_and_AQM_disabled ( const double  sqrts, const ParticleType &  type_a, const ParticleType &  type_b, const CharmRescattering  charm_rescattering  )

static

Helper function: Print a warning message if Charm_Rescattering_Method is not set to none and AQM is disabled but should be used.

Parameters

[in]	sqrts	center of mass energy of incoming particles
[in]	type_a	type of incoming particle a
[in]	type_b	type of incoming particle b
[in]	charm_rescattering	type of charm rescattering

Definition at line 200 of file crosssections.cc.

                                                {
  std::ostringstream warn_msg{
      "AQM is disabled and 'Charm_Rescattering_Method' is set to ",
      std::ios::ate};
  if (charm_rescattering == CharmRescattering::T_Matrix) {
    warn_msg << "'T-matrix' with sqrt(s) = " << sqrts
             << " GeV out of bounds of the underlying data";
  } else if (charm_rescattering == CharmRescattering::Resonances) {
    warn_msg << "'resonances'";
  }
  warn_msg << ".\nElastic interactions of " << type_a.name() << " and "
           << type_b.name()
           << " are disabled under these circumstances.\nPlease enable AQM "
              "if these interactions should occur.";
  logg[LCrossSections].warn(warn_msg.str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

min_angular_momentum() [1/2]

static int smash::min_angular_momentum ( int  s0, int  s1, int  s2  )

static

Definition at line 138 of file decaymodes.cc.

                                                        {
  int min_L = std::min(std::abs(s0 - s1 - s2), std::abs(s0 - s1 + s2));
  min_L = std::min(min_L, std::abs(s0 + s1 - s2));
  if (min_L % 2 != 0) {
    throw std::runtime_error(
        "min_angular_momentum: sum of spins should be integer");
  }
  return min_L / 2;
}

Here is the caller graph for this function:

min_angular_momentum() [2/2]

static int smash::min_angular_momentum ( int  s0, int  s1, int  s2, int  s3  )

static

Definition at line 148 of file decaymodes.cc.

                                                                {
  int min_L =
      std::min(std::abs(s0 - s1 + s2 + s3), std::abs(s0 + s1 - s2 + s3));
  min_L = std::min(min_L, std::abs(s0 + s1 + s2 - s3));
  min_L = std::min(min_L, std::abs(s0 - s1 - s2 + s3));
  min_L = std::min(min_L, std::abs(s0 - s1 + s2 - s3));
  min_L = std::min(min_L, std::abs(s0 + s1 - s2 - s3));
  min_L = std::min(min_L, std::abs(s0 - s1 - s2 - s3));
  if (min_L % 2 != 0) {
    throw std::runtime_error(
        "min_angular_momentum: sum of spins should be integer");
  }
  return min_L / 2;
}

integrand_rho_Manley_1res()

static double smash::integrand_rho_Manley_1res ( double  sqrts, double  mass, double  stable_mass, ParticleTypePtr  type, int  L  )

static

Definition at line 21 of file decaytype.cc.

                                                                     {
  if (sqrts <= mass + stable_mass) {
    return 0.;
  }
 
  /* center-of-mass momentum of final state particles */
  const double p_f = pCM(sqrts, stable_mass, mass);
 
  return p_f / sqrts * blatt_weisskopf_sqr(p_f, L) *
         type->full_spectral_function(mass);
}

Here is the call graph for this function:

Here is the caller graph for this function:

integrand_rho_Manley_2res()

static double smash::integrand_rho_Manley_2res ( double  sqrts, double  m1, double  m2, ParticleTypePtr  t1, ParticleTypePtr  t2, int  L  )

static

Definition at line 35 of file decaytype.cc.

                                               {
  if (sqrts <= m1 + m2) {
    return 0.;
  }
 
  /* center-of-mass momentum of final state particles */
  const double p_f = pCM(sqrts, m1, m2);
 
  return p_f / sqrts * blatt_weisskopf_sqr(p_f, L) *
         t1->full_spectral_function(m1) * t2->full_spectral_function(m2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

arrange_particles()

static ParticleTypePtrList& smash::arrange_particles ( ParticleTypePtrList &  part_types )

static

Rearrange the particle list such that the first particle is the stable one.

Parameters

[in,out]

part_types

Particle list to be rearranged.

Returns

Reference to rearranged particle list.

Definition at line 109 of file decaytype.cc.

                                                                               {
  if (part_types[1]->is_stable()) {
    std::swap(part_types[0], part_types[1]);
  }
  /* verify that this is really a "semi-stable" decay,
   * i.e. the first particle is stable and the second unstable */
  if (!part_types[0]->is_stable() || part_types[1]->is_stable()) {
    throw std::runtime_error("Error in TwoBodyDecaySemistable constructor: " +
                             part_types[0]->pdgcode().string() + " " +
                             part_types[1]->pdgcode().string());
  }
  return part_types;
}

sort_particles()

static ParticleTypePtrList smash::sort_particles ( ParticleTypePtrList  part_types )

static

sort the particle list

Definition at line 269 of file decaytype.cc.

                                                                          {
  std::sort(part_types.begin(), part_types.end());
  return part_types;
}

current_eckart_impl()

template<typename T >

std::tuple<double, FourVector, ThreeVector, ThreeVector, FourVector, FourVector, FourVector, FourVector> smash::current_eckart_impl	(	const ThreeVector &	r,
		const T &	plist,
		const DensityParameters &	par,
		DensityType	dens_type,
		bool	compute_gradient,
		bool	smearing
	)

Calculates Eckart rest frame density and 4-current of a given density type and optionally the gradient of the density in an arbitary frame (grad j0), the curl of the 3-current, and the time, x, y, and z derivatives of the 4-current.

\[ j^{\mu} = (\sqrt{2\pi} \sigma )^{-3} \sum_{i=1}^N C_i u^{\mu}_i \exp \left( - \frac{\bigl[\mathbf{r} - \mathbf{r}_i + \frac{\gamma_i^2}{1 + \gamma_i} \boldsymbol{\beta}_i (\boldsymbol{\beta}_i, \mathbf{r} - \mathbf{r}_i) \bigr]^2}{2\sigma^2} \right) \]

\[ \rho^{Eckart} = \sqrt{j^{\mu} j_{\mu}} \]

Here \( C_i \) is a corresponding value of "charge". If baryon current option is selected then \( C_i \) is 1 for baryons, -1 for antibaryons and 0 otherwise. For proton/neutron current \( C_i = 1\) for proton/neutron and 0 otherwise.

To avoid the problems with Eckart frame definition, densities for positive and negative charges, \(\rho_+ \) and \( \rho_-\), are computed separately and final density is \(\rho_+ - \rho_-\).

Parameters

[in]	r	Arbitrary space point where 4-current is calculated [fm]; ignored if smearing is false
[in]	plist	List of all particles to be used in \(j^{\mu}\) calculation. If smearing is false or if the distance between particle and calculation point r, \( |r-r_i| > r_{cut} \) then particle input to density will be ignored.

Next four values are taken from ExperimentalParameters structure:

Parameters

[in]	par	Set of parameters packed in one structure. From them the cutting radius r_cut \( r_{cut} / \sigma \), number of test-particles ntest and the gaussian width gs_sigma are needed.
[in]	dens_type	type of four-currect to be calculated: baryon, proton or neutron options are currently available
[in]	compute_gradient	true - compute gradient, false - no
[in]	smearing	whether to use gaussian smearing or not. If false, this parameter will use ALL particles equally to calculate the current, and that as such it will not be normalized wrt volume. This should be true for any internal calculation of any quantity and only makes sense to turn off for output purposes in a box.

Returns

(rest frame density in the local Eckart frame [fm \(^{-3}\)], \( j^\mu \) as a 4-vector, \( \boldsymbol{\nabla}\cdot j^0 \) or a 0 3-vector, \( \boldsymbol{\nabla} \times \mathbf{j} \) or a 0 3-vector, \( \partial_t j^\mu \) or a 0 4-vector, \( \partial_x j^\mu \) or a 0 4-vector, \( \partial_y j^\mu \) or a 0 4-vector, \( \partial_z j^\mu \) or a 0 4-vector).

Definition at line 68 of file density.cc.

                                                          {
  /* The current density of the positively and negatively charged particles.
   * Division into positive and negative charges is necessary to avoid
   * problems with the Eckart frame definition. Example of problem:
   * get Eckart frame for two identical oppositely flying bunches of
   * electrons and positrons. For this case jmu = (0, 0, 0, non-zero),
   * so jmu.abs does not exist and Eckart frame is not defined.
   * If one takes rho = jmu_pos.abs - jmu_neg.abs, it is still Lorentz-
   * invariant and gives the right limit in non-relativistic case, but
   * it gives no such problem. */
  FourVector jmu_pos, jmu_neg;
  /* The array of the derivatives of the current density.
   * The zeroth component is the time derivative,
   * while the next 3 ones are spacial derivatives. */
  std::array<FourVector, 4> djmu_dxnu;
 
  for (const auto &p : plist) {
    if (par.only_participants()) {
      // if this conditions holds, the hadron is a spectator
      if (p.get_history().collisions_per_particle == 0) {
        continue;
      }
      if (par.ignore_unformed()) {
        if (p.xsec_scaling_factor() < 1) {
          continue;
        }
      }
    }
    const double dens_factor = density_factor(p.type(), dens_type);
    if (std::fabs(dens_factor) < really_small) {
      continue;
    }
    const FourVector mom = p.momentum();
    const double m = mom.abs();
    if (m < really_small) {
      continue;
    }
    const double m_inv = 1.0 / m;
    const auto sf_and_grad = unnormalized_smearing_factor(
        p.position().threevec() - r, mom, m_inv, par, compute_gradient);
    const FourVector tmp = mom * (dens_factor / mom.x0());
    if (smearing) {
      if (dens_factor > 0.) {
        jmu_pos += tmp * sf_and_grad.first;
      } else {
        jmu_neg += tmp * sf_and_grad.first;
      }
    } else {
      if (dens_factor > 0.) {
        jmu_pos += tmp;
      } else {
        jmu_neg += tmp;
      }
    }
    if (compute_gradient) {
      for (int k = 1; k <= 3; k++) {
        djmu_dxnu[k] += tmp * sf_and_grad.second[k - 1];
        djmu_dxnu[0] -= tmp * sf_and_grad.second[k - 1] *
                        tmp.threevec()[k - 1] / dens_factor;
      }
    }
  }
 
  // Eckart density (rest frame density)
  const double rho_eck = (jmu_pos.abs() - jmu_neg.abs()) * par.norm_factor_sf();
 
  // $\partial_t j^{\mu}$
  const FourVector djmu_dt = compute_gradient
                                 ? djmu_dxnu[0] * par.norm_factor_sf()
                                 : FourVector(0.0, 0.0, 0.0, 0.0);
  // $\partial_x j^{\mu}$
  const FourVector djmu_dx = compute_gradient
                                 ? djmu_dxnu[1] * par.norm_factor_sf()
                                 : FourVector(0.0, 0.0, 0.0, 0.0);
  // $\partial_y j^{\mu}$
  const FourVector djmu_dy = compute_gradient
                                 ? djmu_dxnu[2] * par.norm_factor_sf()
                                 : FourVector(0.0, 0.0, 0.0, 0.0);
  // $\partial_z j^{\mu}$
  const FourVector djmu_dz = compute_gradient
                                 ? djmu_dxnu[3] * par.norm_factor_sf()
                                 : FourVector(0.0, 0.0, 0.0, 0.0);
 
  // Gradient of j0
  ThreeVector grad_j0 = ThreeVector(0.0, 0.0, 0.0);
  // Curl of the 3-current density
  ThreeVector curl_vecj = ThreeVector(0.0, 0.0, 0.0);
  if (compute_gradient) {
    curl_vecj.set_x1(djmu_dxnu[2].x3() - djmu_dxnu[3].x2());
    curl_vecj.set_x2(djmu_dxnu[3].x1() - djmu_dxnu[1].x3());
    curl_vecj.set_x3(djmu_dxnu[1].x2() - djmu_dxnu[2].x1());
    curl_vecj *= par.norm_factor_sf();
    for (int i = 1; i < 4; i++) {
      grad_j0[i - 1] += djmu_dxnu[i].x0() * par.norm_factor_sf();
    }
  }
  if (smearing) {
    jmu_pos *= par.norm_factor_sf();
    jmu_neg *= par.norm_factor_sf();
  }
  return std::make_tuple(rho_eck, jmu_pos + jmu_neg, grad_j0, curl_vecj,
                         djmu_dt, djmu_dx, djmu_dy, djmu_dz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_find_private()

static IsoParticleType* smash::try_find_private ( const std::string &  name )

static

Helper function for IsoParticleType::try_find and friends.

Definition at line 44 of file isoparticletype.cc.

                                                                {
  auto found =
      std::lower_bound(iso_type_list.begin(), iso_type_list.end(), name,
                       [](const IsoParticleType &l, const std::string &r) {
                         return l.name() < r;
                       });
  if (found == iso_type_list.end() || found->name() != name) {
    return {};  // The default constructor creates an invalid pointer.
  }
  return &*found;
}

Here is the caller graph for this function:

multiplet_name()

static std::string smash::multiplet_name ( std::string  name )

static

Construct the name-string for an isospin multiplet from the given name-string for the particle.

Parameters

[in]

name

name-string of the particle

Returns

the name-string for an isospin multiplet

Definition at line 89 of file isoparticletype.cc.

                                                {
  if (name.find("⁺⁺") != std::string::npos) {
    return name.substr(0, name.length() - sizeof("⁺⁺") + 1);
  } else if (name.find("⁺") != std::string::npos) {
    return name.substr(0, name.length() - sizeof("⁺") + 1);
  } else if (name.find("⁻⁻") != std::string::npos) {
    return name.substr(0, name.length() - sizeof("⁻⁻") + 1);
  } else if (name.find("⁻") != std::string::npos) {
    return name.substr(0, name.length() - sizeof("⁻") + 1);
  } else if (name.find("⁰") != std::string::npos) {
    return name.substr(0, name.length() - sizeof("⁰") + 1);
  } else {
    return name;
  }
}

Here is the caller graph for this function:

generate_tabulation_path()

static std::filesystem::path smash::generate_tabulation_path ( const std::filesystem::path &  dir, const std::string &  prefix, const std::string &  res_name  )

static

Definition at line 220 of file isoparticletype.cc.

                               {
  return dir / (prefix + res_name + ".bin");
}

Here is the caller graph for this function:

cache_integral()

static bool smash::cache_integral ( std::unordered_map< std::string, Tabulation > &  tabulations, const std::filesystem::path &  dir, sha256::Hash  hash, const IsoParticleType &  part, const IsoParticleType &  res, const IsoParticleType *  antires, bool  unstable  )

static

Definition at line 226 of file isoparticletype.cc.

                                                   {
  constexpr double spacing = 2.0;
  constexpr double spacing2d = 3.0;
  const auto path = generate_tabulation_path(dir, part.name_filtered_prime(),
                                             res.name_filtered_prime());
  bool loaded_from_file = false;
  /* This is a static variable to keep track of the length of the previous
   * status message. It is used to overwrite the previous message with spaces if
   * the new message is shorter, ensuring that the console output remains clean
   * and readable also across multiple function calls. */
  static std::size_t previous_length = 0;
  const auto print_status = [](std::string_view msg) {
    std::string output{msg};
    if (output.size() < previous_length) {
      output.append(previous_length - output.size(), ' ');
    }
    previous_length = output.size();
    std::cout << output << '\r' << std::flush;
  };
  Tabulation integral;
  if (!dir.empty() && std::filesystem::exists(path)) {
    std::ifstream file(path.string());
    integral = Tabulation::from_file(file, hash);
  }
  if (integral.is_empty()) {
    const auto particle_names =
        part.name_filtered_prime() + res.name_filtered_prime();
    print_status("Calculating integral for " + particle_names);
    if (!unstable) {
      integral = spectral_integral_semistable(integrate, *res.get_states()[0],
                                              *part.get_states()[0], spacing);
    } else {
      integral = spectral_integral_unstable(integrate2d, *res.get_states()[0],
                                            *part.get_states()[0], spacing2d);
    }
 
    if (!dir.empty()) {
      // To avoid race conditions, make sure that this is the only instance
      // writing the tabulation to file.
      FileLock lock(dir / (particle_names + ".lock"));
      if (lock.acquire()) {
        print_status("Caching tabulation to " + path.filename().string());
        std::ofstream file(path.string());
        integral.write(file, hash);
      } else {
        print_status("Another instance is caching the tabulation to " +
                     path.filename().string() +
                     ", skipping caching for this instance");
      }
    }
  } else {
    // Only print message if the found tabulation was valid.
    print_status("Tabulation found at " + path.filename().string());
    loaded_from_file = true;
  }
  tabulations.emplace(std::make_pair(res.name(), integral));
  if (antires != nullptr) {
    tabulations.emplace(std::make_pair(antires->name(), integral));
  }
  return loaded_from_file;
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_configuration()

static Configuration smash::create_configuration ( const std::string &  config_file, const std::vector< std::string > &  extra_config  )

static

Definition at line 87 of file library.cc.

                                              {
  // Read in config file
  std::filesystem::path config_path(config_file);
  Configuration configuration(config_path.parent_path(),
                              config_path.filename());
 
  // Merge config passed via command line
  for (const auto &config : extra_config) {
    configuration.merge_yaml(config);
  }
  return configuration;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_minimal_loggers_setup_for_config_validation()

static void smash::do_minimal_loggers_setup_for_config_validation ( )

static

Definition at line 102 of file library.cc.

                                                             {
  const std::string conf_tag = LogArea::Configuration::textual();
  const std::string main_tag = LogArea::Main::textual();
  const auto size =
      conf_tag.size() > main_tag.size() ? conf_tag.size() : main_tag.size();
  logg[LogArea::Configuration::id].setAreaName(utf8::fill_both(conf_tag, size));
  logg[LogArea::Main::id].setAreaName(utf8::fill_both(main_tag, size));
}

Here is the call graph for this function:

Here is the caller graph for this function:

fully_validate_configuration()

static void smash::fully_validate_configuration ( const Configuration &  configuration )

static

Definition at line 111 of file library.cc.

                                                                             {
  do_minimal_loggers_setup_for_config_validation();
  if (configuration.validate() == Configuration::Is::Invalid) {
    throw std::runtime_error("Validation of SMASH input failed.");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_logging()

static void smash::setup_logging ( Configuration &  configuration )

static

Definition at line 118 of file library.cc.

                                                        {
  set_default_loglevel(configuration.take(InputKeys::log_default));
  auto logger_config = configuration.extract_sub_configuration(
      InputSections::logging, Configuration::GetEmpty::Yes);
  if (!logger_config.is_empty()) {
    logger_config.enclose_into_section(InputSections::logging);
  }
  create_all_loggers(std::move(logger_config));
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_particles_and_decaymodes_files_setting_keys_in_configuration()

static void smash::read_particles_and_decaymodes_files_setting_keys_in_configuration ( const std::string &  particles_file, const std::string &  decaymodes_file, Configuration &  configuration  )

static

Definition at line 128 of file library.cc.

                                  {
  logg[LMain].trace(SMASH_SOURCE_LOCATION, " load ParticleType and DecayModes");
  std::filesystem::path particles_path(particles_file);
  std::filesystem::path decaymodes_path(decaymodes_file);
  auto particles_and_decays =
      load_particles_and_decaymodes(particles_path, decaymodes_path);
  /* For particles and decaymodes: external file is superior to config.
   * However, warn in case of conflict. */
  if (configuration.has_value(InputKeys::particles) &&
      !particles_path.empty()) {
    logg[LMain].warn(
        "Ambiguity: particles from external file ", particles_path,
        " requested, but there is also particle list in the config."
        " Using particles from ",
        particles_path);
  }
  if (!configuration.has_value(InputKeys::particles) ||
      !particles_path.empty()) {
    configuration.set_value(InputKeys::particles, particles_and_decays.first);
  }
 
  if (configuration.has_value(InputKeys::decaymodes) &&
      !decaymodes_path.empty()) {
    logg[LMain].warn(
        "Ambiguity: decaymodes from external file ", decaymodes_path,
        " requested, but there is also decaymodes list in the config."
        " Using decaymodes from",
        decaymodes_path);
  }
  if (!configuration.has_value(InputKeys::decaymodes) ||
      !decaymodes_path.empty()) {
    configuration.set_value(InputKeys::decaymodes, particles_and_decays.second);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_list_of_particles_invalid()

static bool smash::is_list_of_particles_invalid ( const Particles &  particles, int  event  )

static

Definition at line 529 of file listmodus.cc.

                                                    {
  /* In order to make the desired check, particles are classified in an std::map
   * using their position as a key. However, to do so, the operator< of the
   * FourVector class is not suitable since in a std::map, by default, two keys
   * a and b are considered equivalent if !(a<b) && !(b<a). Therefore we convert
   * the 4-postion to a string and use this as key. Note that this should also
   * work in the case in which the file contains apparently different positions,
   * i.e. with differences in the decimals beyond double precision. At this
   * point the file has been already read and the 4-positions are stored in
   * double position. */
  auto to_string = [](const FourVector &v) {
    return "(" + std::to_string(v[0]) + ", " + std::to_string(v[1]) + ", " +
           std::to_string(v[2]) + ", " + std::to_string(v[3]) + ")";
  };
  std::map<std::string, int> checker{};
  for (const auto &p : particles) {
    checker[to_string(p.position())]++;
  }
  bool error_found = false;
  for (const auto &[key, value] : checker) {
    if (value > 2) {
      logg[LList].error() << "Event " << event << ": Found " << value
                          << " particles at same position " << key;
      error_found = true;
    }
  }
  return error_found;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [6/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const ListModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The ListModus object to write into out

Definition at line 101 of file listmodus.cc.

                                                            {
  out << "-- List Modus\nInput directory for external particle lists:\n"
      << m.particle_list_file_directory_ << "\n";
  return out;
}

find_longest_logger_name() [1/2]

template<int index, int stop = 0>

constexpr std::enable_if<(index == stop), int>::type smash::find_longest_logger_name ( )

constexpr

Recursively find the longest logger name at compile time.

Beginning of the recursion.

Template Parameters

index	Recursion index.
stop	Stopping index.

Returns

Current maximal logger name length.

Definition at line 49 of file logging.cc.

                           {
  using LogAreaTag = typename std::remove_reference<decltype(std::get<index>(
      std::declval<LogArea::AreaTuple &>()))>::type;
  return LogAreaTag::textual_length();
}

find_longest_logger_name() [2/2]

template<int index, int stop = 0, int mid = (index + stop) / 2>

constexpr std::enable_if<(index > stop), int>::type smash::find_longest_logger_name ( )

constexpr

Recursively find the longest logger name at compile time.

All cases except for the beginning of the recursion.

Template Parameters

index	Recursion index.
stop	Stopping index.
mid	Middle index.

Returns

Current maximal logger name length.

Definition at line 68 of file logging.cc.

                           {
  return find_longest_logger_name<index, mid + 1>() >
                 find_longest_logger_name<mid, stop>()
             ? find_longest_logger_name<index, mid + 1>()
             : find_longest_logger_name<mid, stop>();
}

create_all_loggers_impl() [1/2]

template<std::size_t index, int >

std::enable_if<(index == 0)>::type smash::create_all_loggers_impl ( Configuration &  )

inline

Recurse over the log areas in the LogArea::AreaTuple type. Do nothing here to end the recursion (see also below).

Definition at line 81 of file logging.cc.

                     {}

Here is the caller graph for this function:

create_all_loggers_impl() [2/2]

template<std::size_t index, int longest_name = find_longest_logger_name<index - 1>()>

std::enable_if<(index != 0)>::type smash::create_all_loggers_impl ( Configuration &  config )

inline

Recurse over the log areas in the LogArea::AreaTuple type. (The recursion is ended via the overload above.)

For every entry in the list the corresponding Logger object in logg is set up with area name and verbosity.

Template Parameters

index	Recursion index.
longest_name	Length of longest log area name.

Parameters

[in,out]

config

Configuration object.

Definition at line 98 of file logging.cc.

                           {
  using LogAreaTag =
      typename std::remove_reference<decltype(std::get<index - 1>(
          std::declval<LogArea::AreaTuple &>()))>::type;
  static_assert(LogAreaTag::id == index - 1,
                "The order of types in LogArea::AreaTuple does not match the "
                "id values in the LogArea types. Please fix! (see top of "
                "'include/logging.h')");
  auto &logger = logg[LogAreaTag::id];
  const auto tmp = utf8::fill_both(LogAreaTag::textual(), longest_name);
  logger.setAreaName(tmp);
  auto logging_key = InputKeys::get_logging_key(LogAreaTag::textual());
  logger.setVerbosity(config.take(logging_key, global_default_loglevel));
  create_all_loggers_impl<index - 1, longest_name>(config);
}

Here is the call graph for this function:

operator<<() [7/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const Nucleus &	n
	)

Definition at line 579 of file nucleus.cc.

                                                          {
  return out << "  #particles   #testparticles   mass [GeV]   "
                "radius [fm]  diffusiveness [fm]\n"
             << format(n.number_of_particles(), nullptr, 12)
             << format(n.size(), nullptr, 17) << format(n.mass(), nullptr, 13)
             << format(n.get_nuclear_radius(), nullptr, 14)
             << format(n.get_diffusiveness(), nullptr, 20);
}

piplusp_elastic_pdg()

static double smash::piplusp_elastic_pdg ( double  mandelstam_s )

static

Definition at line 166 of file parametrizations.cc.

                                                       {
  if (piplusp_elastic_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIPLUSP_ELASTIC_P_LAB, PIPLUSP_ELASTIC_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
    piplusp_elastic_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piplusp_elastic_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

piminusp_elastic_pdg()

static double smash::piminusp_elastic_pdg ( double  mandelstam_s )

static

Definition at line 261 of file parametrizations.cc.

                                                        {
  if (piminusp_elastic_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(PIMINUSP_ELASTIC_P_LAB, PIMINUSP_ELASTIC_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
    piminusp_elastic_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piminusp_elastic_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kminusp_elastic_pdg()

static double smash::kminusp_elastic_pdg ( double  mandelstam_s )

static

Definition at line 600 of file parametrizations.cc.

                                                       {
  if (kminusp_elastic_interpolation == nullptr) {
    auto [dedup_x, dedup_y] =
        dedup_avg<double>(KMINUSP_ELASTIC_P_LAB, KMINUSP_ELASTIC_SIG);
    dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
    kminusp_elastic_interpolation =
        std::make_unique<InterpolateDataLinear<double>>(
            dedup_x, dedup_y, ExtrapolationType::Constant);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kminusp_elastic_interpolation)(p_lab);
}

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

static void smash::initialize ( std::unordered_map< std::pair< uint64_t, uint64_t >, double, pair_hash > &  ratios )

static

Calculate and store isospin ratios for K N -> K Delta reactions.

See the documentation of KaonNucleonRatios for details.

Parameters

[in]

ratios

An empty map where the ratios for K N -> K Delta reactions are stored.

Definition at line 715 of file parametrizations.cc.

                                                              {
  const auto& type_p = ParticleType::find(pdg::p);
  const auto& type_n = ParticleType::find(pdg::n);
  const auto& type_K_p = ParticleType::find(pdg::K_p);
  const auto& type_K_z = ParticleType::find(pdg::K_z);
  const auto& type_Delta_pp = ParticleType::find(pdg::Delta_pp);
  const auto& type_Delta_p = ParticleType::find(pdg::Delta_p);
  const auto& type_Delta_z = ParticleType::find(pdg::Delta_z);
  const auto& type_Delta_m = ParticleType::find(pdg::Delta_m);
 
  /* Store the isospin ratio of the given reaction relative to all other
   * possible isospin-symmetric reactions. */
  auto add_to_ratios = [&](const ParticleType& a, const ParticleType& b,
                           const ParticleType& c, const ParticleType& d,
                           double weight_numerator, double weight_other) {
    assert(weight_numerator + weight_other != 0);
    const auto key =
        std::make_pair(pack(a.pdgcode().code(), b.pdgcode().code()),
                       pack(c.pdgcode().code(), d.pdgcode().code()));
    const double ratio = weight_numerator / (weight_numerator + weight_other);
    ratios[key] = ratio;
  };
 
  /* All inelastic channels are K N -> K Delta -> K pi N or charge exchange,
   * with identical cross section, weighted by the isospin factor.
   *
   * For charge exchange, the isospin factors are 1,
   * so they are excluded here. */
  {
    const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
        type_p, type_K_p, type_K_z, type_Delta_pp);
    const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
        type_p, type_K_p, type_K_p, type_Delta_p);
 
    add_to_ratios(type_p, type_K_p, type_K_z, type_Delta_pp, weight1, weight2);
    add_to_ratios(type_p, type_K_p, type_K_p, type_Delta_p, weight2, weight1);
  }
  {
    const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
        type_n, type_K_p, type_K_z, type_Delta_p);
    const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
        type_n, type_K_p, type_K_p, type_Delta_z);
 
    add_to_ratios(type_n, type_K_p, type_K_z, type_Delta_p, weight1, weight2);
    add_to_ratios(type_n, type_K_p, type_K_p, type_Delta_z, weight2, weight1);
  }
  /* K+ and K0 have the same mass and spin, their cross sections are assumed to
   * only differ in isospin factors. */
  {
    const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
        type_p, type_K_z, type_K_z, type_Delta_p);
    const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
        type_p, type_K_z, type_K_p, type_Delta_z);
 
    add_to_ratios(type_p, type_K_z, type_K_z, type_Delta_p, weight1, weight2);
    add_to_ratios(type_p, type_K_z, type_K_p, type_Delta_z, weight2, weight1);
  }
  {
    const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
        type_n, type_K_z, type_K_z, type_Delta_z);
    const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
        type_n, type_K_z, type_K_p, type_Delta_m);
 
    add_to_ratios(type_n, type_K_z, type_K_z, type_Delta_z, weight1, weight2);
    add_to_ratios(type_n, type_K_z, type_K_p, type_Delta_m, weight2, weight1);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [8/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const Particles &	particles
	)

Parameters

[in]	out	The ostream into which to output
[in]	particles	The Particles object to write into out

Definition at line 148 of file particles.cc.

                                                                    {
  out << particles.size() << " Particles:\n";
  for (unsigned i = 0; i < particles.data_size_; ++i) {
    const auto &p = particles.data_[i];
    if (p.id() < 0) {
      out << "------  ";
    } else {
      out << std::setw(5) << std::setprecision(3) << p.momentum().abs3()
          << p.type().name();
    }
    if ((i & 15) == 0) {
      out << '\n';
    }
  }
  return out;
}

antiname()

static std::string smash::antiname ( const std::string &  name, PdgCode  code  )

static

Construct an antiparticle name-string from the given name-string for the particle and its PDG code.

Parameters

[in]	name	the name-string of the particle to convert
[in]	code	the pdgcode of the particle to convert

Returns

the name-string of the converted antiparticle

Definition at line 143 of file particletype.cc.

                                                               {
  std::string basename, charge;
 
  if (name.find("⁺⁺") != std::string::npos) {
    basename = name.substr(0, name.length() - sizeof("⁺⁺") + 1);
    charge = "⁻⁻";
  } else if (name.find("⁺") != std::string::npos) {
    basename = name.substr(0, name.length() - sizeof("⁺") + 1);
    charge = "⁻";
  } else if (name.find("⁻⁻") != std::string::npos) {
    basename = name.substr(0, name.length() - sizeof("⁻⁻") + 1);
    charge = "⁺⁺";
  } else if (name.find("⁻") != std::string::npos) {
    basename = name.substr(0, name.length() - sizeof("⁻") + 1);
    charge = "⁺";
  } else if (name.find("⁰") != std::string::npos) {
    basename = name.substr(0, name.length() - sizeof("⁰") + 1);
    charge = "⁰";
  } else {
    basename = name;
    charge = "";
  }
 
  // baryons & strange mesons: insert a bar
  if (code.baryon_number() != 0 || code.strangeness() != 0 ||
      code.charmness() != 0 || code.is_neutrino()) {
    constexpr char bar[] = "\u0305";
    basename.insert(utf8::sequence_length(basename.begin()), bar);
  }
 
  return basename + charge;
}

Here is the call graph for this function:

Here is the caller graph for this function:

chargestr()

static std::string smash::chargestr ( int  charge )

static

Construct a charge string, given the charge as integer.

Parameters

[in]

charge

charge of a particle

Returns

the corresponding string to write out this charge

Exceptions

runtime_error

if the charge is not an integer between -2 and 2

Definition at line 183 of file particletype.cc.

                                       {
  switch (charge) {
    case 2:
      return "⁺⁺";
    case 1:
      return "⁺";
    case 0:
      return "⁰";
    case -1:
      return "⁻";
    case -2:
      return "⁻⁻";
    default:
      throw std::runtime_error("Invalid charge " + std::to_string(charge));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [9/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const ParticleType &	type
	)

Parameters

[out]	out	The ostream into which to output
[in]	type	The ParticleType object to write into out

Definition at line 827 of file particletype.cc.

                                                                  {
  const PdgCode &pdg = type.pdgcode();
  return out << type.name() << std::setfill(' ') << std::right
             << "[ mass:" << field<6> << type.mass()
             << ", width:" << field<6> << type.width_at_pole()
             << ", PDG:" << field<6> << pdg
             << ", charge:" << field<3> << pdg.charge()
             << ", spin:" << field<2> << pdg.spin() << "/2 ]";
}

high_energy_bpp()

static double smash::high_energy_bpp ( double  plab )

static

Computes the B coefficients from the STAR fit, see fig.

(6) in STAR:2020phn [2].

Parameters

[in]

plab

Lab momentum in GeV.

Returns

B coefficients of high-energy elastic proton-proton scatterings.

Definition at line 465 of file scatteraction.cc.

                                           {
  double mandelstam_s = s_from_plab(plab, nucleon_mass, nucleon_mass);
  return 7.6 + 0.66 * std::log(mandelstam_s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cugnon_bpp()

static double smash::Cugnon_bpp ( double  plab )

static

Computes the B coefficients from the Cugnon parametrization of the angular distribution in elastic pp scattering.

See equation (8) in Cugnon:1996kh [21]. Note: The original Cugnon parametrization is only applicable for plab < 6 GeV and keeps rising above that.

Parameters

[in]

plab

Lab momentum in GeV.

Returns

Cugnon B coefficient for elastic proton-proton scatterings.

Definition at line 482 of file scatteraction.cc.

                                      {
  if (plab < 2.) {
    double p8 = pow_int(plab, 8);
    return 5.5 * p8 / (7.7 + p8);
  } else {
    return std::min(high_energy_bpp(plab), 5.334 + 0.67 * (plab - 2.));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Cugnon_bnp()

static double smash::Cugnon_bnp ( double  plab )

static

Computes the B coefficients from the Cugnon parametrization of the angular distribution in elastic np scattering.

See equation (10) in Cugnon:1996kh [21].

Parameters

[in]

plab

Lab momentum in GeV.

Returns

Cugnon B coefficient for elastic proton-neutron scatterings.

Definition at line 501 of file scatteraction.cc.

                                      {
  if (plab < 0.225) {
    return 0.;
  } else if (plab < 0.6) {
    return 16.53 * (plab - 0.225);
  } else if (plab < 1.6) {
    return -1.63 * plab + 7.16;
  } else {
    return Cugnon_bpp(plab);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

boost_spin_vectors_after_elastic_scattering()

static void smash::boost_spin_vectors_after_elastic_scattering ( ParticleData &  outgoing_particle_a, ParticleData &  outgoing_particle_b  )

static

Definition at line 779 of file scatteraction.cc.

                                                                          {
  // Boost spin vectors
  outgoing_particle_a.set_spin_vector(
      outgoing_particle_a.spin_vector().lorentz_boost(
          outgoing_particle_a.velocity()));
  outgoing_particle_b.set_spin_vector(
      outgoing_particle_b.spin_vector().lorentz_boost(
          outgoing_particle_b.velocity()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_string_transition_parameters()

static StringTransitionParameters smash::create_string_transition_parameters ( Configuration &  config )

static

Definition at line 104 of file scatteractionsfinder.cc.

                           {
  return {config.take(InputKeys::collTerm_stringTrans_rangeNpi),
          config.take(InputKeys::collTerm_stringTrans_rangeNN),
          config.take(InputKeys::collTerm_stringTrans_lower),
          config.take(InputKeys::collTerm_stringTrans_range_width),
          config.take(InputKeys::collTerm_stringTrans_pipiOffset),
          config.take(InputKeys::collTerm_stringTrans_KNOffset)};
}

Here is the call graph for this function:

deduplicate()

static void smash::deduplicate ( std::vector< FinalStateCrossSection > &  final_state_xs )

static

Deduplicate the final-state cross sections by summing.

Parameters

[in,out]

final_state_xs

Final-state cross sections.

Definition at line 889 of file scatteractionsfinder.cc.

                                                                           {
  std::sort(final_state_xs.begin(), final_state_xs.end(),
            [](const FinalStateCrossSection& a,
               const FinalStateCrossSection& b) { return a.name_ < b.name_; });
  auto current = final_state_xs.begin();
  while (current != final_state_xs.end()) {
    auto adjacent = std::adjacent_find(
        current, final_state_xs.end(),
        [](const FinalStateCrossSection& a, const FinalStateCrossSection& b) {
          return a.name_ == b.name_;
        });
    current = adjacent;
    if (adjacent != final_state_xs.end()) {
      adjacent->cross_section_ += (adjacent + 1)->cross_section_;
      final_state_xs.erase(adjacent + 1);
    }
  }
}

Here is the caller graph for this function:

operator<<() [10/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const SphereModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The SphereModus object to write into out

Definition at line 89 of file spheremodus.cc.

                                                              {
  out << "-- Sphere Modus:\nRadius of the sphere: " << m.radius_ << " fm\n";
  if (m.use_thermal_) {
    out << "Thermal multiplicities (T = " << m.sphere_temperature_
        << " GeV, muB = " << m.mub_ << " GeV, muS = " << m.mus_
        << " GeV, muQ = " << m.muq_ << " GeV)\n";
  } else {
    for (const auto &p : m.init_multipl_) {
      ParticleTypePtr ptype = &ParticleType::find(p.first);
      out << ptype->name() << " initial multiplicity " << p.second << '\n';
    }
  }
  switch (m.init_distr_) {
    case SphereInitialCondition::ThermalMomentaBoltzmann:
      out << "Boltzmann momentum distribution with T = "
          << m.sphere_temperature_ << " GeV.\n";
      break;
    case SphereInitialCondition::ThermalMomentaQuantum:
      out << "Fermi/Bose momentum distribution with T = "
          << m.sphere_temperature_ << " GeV.\n";
      break;
    case SphereInitialCondition::IC_ES:
      out << "Sphere Initial Condition is IC_ES";
      break;
    case SphereInitialCondition::IC_1M:
      out << "Sphere Initial Condition is IC_1M";
      break;
    case SphereInitialCondition::IC_2M:
      out << "Sphere Initial Condition is IC_2M";
      break;
    case SphereInitialCondition::IC_Massive:
      out << "Sphere Initial Condition is IC_Massive";
      break;
  }
  if (m.jet_pdg_) {
    ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_.value());
    const auto pos = m.jet_pos_;
    if (m.jet_back_) {
      ParticleTypePtr anti =
          ptype->has_antiparticle() ? ptype->get_antiparticle() : ptype;
      out << "Adding a dijet " << ptype->name() << anti->name()
          << " centered at (" << pos.x1() << ", " << pos.x2() << ", "
          << pos.x3() << ") separated by " << m.jet_back_separation_
          << " fm,\neach with " << m.jet_mom_ << " GeV of initial momentum.\n";
    } else {
      out << "Adding a " << ptype->name() << " as a jet at (" << pos.x1()
          << ", " << pos.x2() << ", " << pos.x3() << ") fm with " << m.jet_mom_
          << " GeV of initial momentum.\n";
    }
  }
  return out;
}

split() [2/2]

template<typename Out >

void smash::split	(	const std::string &	s,
		char	delim,
		Out	result
	)

Split string by delimiter.

Parameters

[in]	s	String to be split.
[in]	delim	Splitting delimiter.
[out]	result	Split string as iterator.

Necessary for the next function

Definition at line 112 of file stringfunctions.cc.

                                                       {
  std::stringstream ss;
  ss.str(s);
  std::string item;
  while (std::getline(ss, item, delim)) {
    *(result++) = item;
  }
}

join_impl()

template<typename Container >

static std::string smash::join_impl ( const Container &  container, std::string_view  delim  )

static

Definition at line 128 of file stringfunctions.cc.

                                                   {
  // Enable ADL (Argument-Dependent Lookup); not necessary now but harmless
  using std::begin;
  using std::end;
  using value_type = std::decay_t<decltype(*begin(container))>;
  /* Here this is not really needed as the developer calls this function with
   * the appropriate types, but it is ready to be moved to the header one day */
  static_assert(
      std::is_convertible_v<value_type, std::string_view>,
      "join() requires string-like objects convertible to std::string_view!");
  auto it = begin(container);
  const auto last = end(container);
  if (it == last) {
    return {};
  }
  std::size_t total_size = 0;
  std::size_t count = 0;
  for (const auto &s : container) {
    total_size += std::string_view{s}.size();
    ++count;
  }
  total_size += delim.size() * (count - 1);
  std::string result{};
  result.reserve(total_size);
  result.append(std::string_view{*it});
  ++it;
  for (; it != last; ++it) {
    result.append(delim);
    result.append(std::string_view{*it});
  }
  return result;
}

Here is the caller graph for this function:

throw_unhandled_enum()

static void smash::throw_unhandled_enum ( std::string_view  enum_name, int  value  )

static

Definition at line 19 of file stringify.cc.

                                                         {
  throw std::invalid_argument("Unhandled " + std::string(enum_name) +
                              " enum value " + std::to_string(value) +
                              " passed to conversion function to_string().");
}

Here is the call graph for this function:

Here is the caller graph for this function:

swrite() [1/4]

static void smash::swrite ( std::ofstream &  stream, double  x  )

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

Definition at line 71 of file tabulation.cc.

                                                  {
  stream.write(reinterpret_cast<const char*>(&x), sizeof(x));
}

Here is the caller graph for this function:

sread_double()

static double smash::sread_double ( std::ifstream &  stream )

static

Read binary representation of a double.

Parameters

[in]

stream

Input stream.

Returns

Read value.

Definition at line 81 of file tabulation.cc.

                                                {
  double x;
  stream.read(reinterpret_cast<char*>(&x), sizeof(x));
  return x;
}

Here is the caller graph for this function:

swrite() [2/4]

static void smash::swrite ( std::ofstream &  stream, size_t  x  )

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

Definition at line 93 of file tabulation.cc.

                                                  {
  // We want to support 32-bit and 64-bit platforms, so we store a 64-bit
  // integer on all platforms.
  const auto const_size_x = static_cast<uint64_t>(x);
  stream.write(reinterpret_cast<const char*>(&const_size_x),
               sizeof(const_size_x));
}

sread_size()

static size_t smash::sread_size ( std::ifstream &  stream )

static

Read binary representation of a size_t.

Parameters

[in]

stream

Input stream.

Returns

Read value.

Definition at line 107 of file tabulation.cc.

                                              {
  uint64_t x;
  stream.read(reinterpret_cast<char*>(&x), sizeof(x));
  if (x > std::numeric_limits<size_t>::max()) {
    throw std::runtime_error("trying to read vector larger than supported");
  }
  return x;
}

Here is the caller graph for this function:

swrite() [3/4]

static void smash::swrite ( std::ofstream &  stream, const std::vector< double >  x  )

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

Definition at line 122 of file tabulation.cc.

                                                                   {
  swrite(stream, x.size());
  if (x.size() > 0) {
    stream.write(reinterpret_cast<const char*>(x.data()),
                 sizeof(x[0]) * x.size());
  }
}

Here is the call graph for this function:

sread_vector()

static std::vector<double> smash::sread_vector ( std::ifstream &  stream )

static

Read binary representation of a vector of doubles.

Parameters

[in]

stream

Input stream.

Returns

Read value.

Definition at line 136 of file tabulation.cc.

                                                           {
  const size_t n = sread_size(stream);
  std::vector<double> x;
  x.resize(n);
  stream.read(reinterpret_cast<char*>(x.data()), sizeof(double) * n);
  return x;
}

Here is the call graph for this function:

Here is the caller graph for this function:

swrite() [4/4]

static void smash::swrite ( std::ofstream &  stream, sha256::Hash  x  )

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

Definition at line 150 of file tabulation.cc.

                                                      {
  // The size is always the same, so there is no need to write it.
  stream.write(reinterpret_cast<const char*>(x.data()),
               sizeof(x[0]) * x.size());
}

sread_hash()

static sha256::Hash smash::sread_hash ( std::ifstream &  stream )

static

Read binary representation of a SHA256 hash.

Parameters

[in]

stream

Input stream.

Returns

Read value.

Definition at line 162 of file tabulation.cc.

                                                  {
  sha256::Hash x;
  stream.read(reinterpret_cast<char*>(x.data()), x.size());
  return x;
}

Here is the caller graph for this function:

operator<<() [11/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const TimeStampCounter &	tsc
	)

Definition at line 18 of file tsc.cc.

                                                                     {
  auto c = tsc.cycles();
  int blocks[10];
  int n = 0;
  for (int digits = std::log10(c); digits > 0; digits -= 3) {
    blocks[n++] = c % 1000;
    c /= 1000;
  }
  if (n == 0) {
    return out;
  }
  const auto lastFill = out.fill('0');
  out << blocks[--n];
  while (n > 0) {
    out << '\'' << std::setw(3) << blocks[--n];
  }
  out.fill(lastFill);
  return out << " Cycles";
}

Variable Documentation

LAction

constexpr int smash::LAction = LogArea::Action::id

staticconstexpr

Definition at line 25 of file action.h.

LClock

constexpr int smash::LClock = LogArea::Clock::id

staticconstexpr

Definition at line 26 of file clock.h.

smash_NaN

template<typename T >

constexpr T smash::smash_NaN = std::numeric_limits<T>::quiet_NaN()

constexpr

Centralized alias for a quiet NaN.

Definition at line 24 of file constants.h.

hbarc

constexpr double smash::hbarc = 0.197327053

constexpr

GeV <-> fm conversion factor.

Definition at line 29 of file constants.h.

fm2_mb

constexpr double smash::fm2_mb = 0.1

constexpr

mb <-> fm^2 conversion factor.

Definition at line 32 of file constants.h.

gev2_mb

constexpr double smash::gev2_mb = hbarc * hbarc / fm2_mb

constexpr

GeV^-2 <-> mb conversion factor.

Definition at line 35 of file constants.h.

mev_to_gev

constexpr double smash::mev_to_gev = 1.e-3

constexpr

MeV to GeV conversion factor.

Definition at line 38 of file constants.h.

really_small

constexpr double smash::really_small = 1.0e-6

constexpr

Numerical error tolerance.

Definition at line 41 of file constants.h.

very_small_double

constexpr double smash::very_small_double = 1.0e-15

constexpr

A very small double, used to avoid division by zero.

Definition at line 44 of file constants.h.

twopi

constexpr double smash::twopi = 2. * M_PI

constexpr

\( 2\pi \).

Definition at line 49 of file constants.h.

nuclear_density

constexpr double smash::nuclear_density = 0.168

constexpr

Ground state density of symmetric nuclear matter [fm^-3].

Definition at line 52 of file constants.h.

small_number

constexpr double smash::small_number = 1.0e-4

constexpr

Physical error tolerance.

Definition at line 55 of file constants.h.

electron_mass

constexpr double smash::electron_mass = 0.000511

constexpr

Electron mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 62 of file constants.h.

nucleon_mass

constexpr double smash::nucleon_mass = 0.938

constexpr

Nucleon mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 69 of file constants.h.

pion_mass

constexpr double smash::pion_mass = 0.138

constexpr

Pion mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 76 of file constants.h.

kaon_mass

constexpr double smash::kaon_mass = 0.494

constexpr

Kaon mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 83 of file constants.h.

omega_mass

constexpr double smash::omega_mass = 0.783

constexpr

omega mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 90 of file constants.h.

delta_mass

constexpr double smash::delta_mass = 1.232

constexpr

Delta mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 97 of file constants.h.

deuteron_mass

constexpr double smash::deuteron_mass = 1.8756

constexpr

Deuteron mass in GeV.

Note that this should be the same as in particles.txt.

Definition at line 103 of file constants.h.

fine_structure

constexpr double smash::fine_structure = 7.2973525698e-3

constexpr

Fine-struture constant, approximately 1/137.

Definition at line 106 of file constants.h.

elementary_charge

const double smash::elementary_charge = std::sqrt(fine_structure * 4 * M_PI)

Elementary electric charge in natural units, approximately 0.3.

Definition at line 109 of file constants.h.

maximum_rndm_seed_in_pythia

constexpr int smash::maximum_rndm_seed_in_pythia = 900000000

constexpr

The maximum value of the random seed used in PYTHIA.

Definition at line 114 of file constants.h.

minimum_sqrts_pythia_can_handle

constexpr double smash::minimum_sqrts_pythia_can_handle = 10.0

constexpr

Energy in GeV, below which hard reactions via pythia are impossible.

This constraint is technical and comes from the pythia model itself. At the same time, physics-wise, hard cross-sections at the low energies are so small, that this constrant is well justified.

Definition at line 122 of file constants.h.

ID_PROCESS_PHOTON

constexpr std::uint32_t smash::ID_PROCESS_PHOTON

constexpr

Initial value:

=
    std::numeric_limits<std::uint32_t>::max()

Process ID for any photon process.

It is chosen such that it will not conflict with any other process.

Definition at line 129 of file constants.h.

BREMS_SQRTS

const std::initializer_list<double> smash::BREMS_SQRTS

Initial value:

= {
    0.3,  0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4,  0.41,
    0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5,  0.51, 0.52, 0.53,
    0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6,  0.61, 0.62, 0.63, 0.64, 0.65,
    0.66, 0.67, 0.68, 0.69, 0.7,  0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77,
    0.78, 0.79, 0.8,  0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89,
    0.9,  0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99, 1.0,  1.01,
    1.02, 1.03, 1.04, 1.05, 1.06, 1.07, 1.08, 1.09, 1.1,  1.11, 1.12, 1.13,
    1.14, 1.15, 1.16, 1.17, 1.18, 1.19, 1.2,  1.21, 1.22, 1.23, 1.24, 1.25,
    1.26, 1.27, 1.28, 1.29, 1.3,  1.31, 1.32, 1.33, 1.34, 1.35, 1.36, 1.37,
    1.38, 1.39, 1.4,  1.41, 1.42, 1.43, 1.44, 1.45, 1.46, 1.47, 1.48, 1.49,
    1.5,  1.51, 1.52, 1.53, 1.54, 1.55, 1.56, 1.57, 1.58, 1.59, 1.6,  1.61,
    1.62, 1.63, 1.64, 1.65, 1.66, 1.67, 1.68, 1.69, 1.7,  1.71, 1.72, 1.73,
    1.74, 1.75, 1.76, 1.77, 1.78, 1.79, 1.8,  1.81, 1.82, 1.83, 1.84, 1.85,
    1.86, 1.87, 1.88, 1.89, 1.9,  1.91, 1.92, 1.93, 1.94, 1.95, 1.96, 1.97,
    1.98, 1.99, 2.03, 2.06, 2.09, 2.12, 2.15, 2.18, 2.21, 2.24, 2.27, 2.3,
    2.33, 2.36, 2.39, 2.42, 2.45, 2.48, 2.51, 2.54, 2.57, 2.6,  2.63, 2.66,
    2.69, 2.72, 2.75, 2.78, 2.81, 2.84, 2.87, 2.9,  2.93, 2.96, 2.99, 3.02,
    3.05, 3.08, 3.11, 3.14, 3.17, 3.2,  3.23, 3.26, 3.29, 3.32, 3.35, 3.38,
    3.41, 3.44, 3.47, 3.5,  3.53, 3.56, 3.59, 3.62, 3.65, 3.68, 3.71, 3.74,
    3.77, 3.8,  3.83, 3.86, 3.89, 3.92, 3.95, 3.98, 4.01, 4.04, 4.07, 4.1,
    4.13, 4.16, 4.19, 4.22, 4.25, 4.28, 4.31, 4.34, 4.37, 4.4,  4.43, 4.46,
    4.49, 4.52, 4.55, 4.58, 4.61, 4.64, 4.67, 4.7,  4.73, 4.76, 4.79, 4.82,
    4.85, 4.88, 4.91, 4.94, 4.97, 5.0}

Center-of-mass energy.

Definition at line 24 of file crosssectionsbrems.h.

BREMS_K

const std::initializer_list<double> smash::BREMS_K

Initial value:

= {
    0.001,      0.00107227, 0.00114976, 0.00123285, 0.00132194, 0.00141747,
    0.00151991, 0.00162975, 0.00174753, 0.00187382, 0.00200923, 0.00215443,
    0.00231013, 0.00247708, 0.00265609, 0.00284804, 0.00305386, 0.00327455,
    0.00351119, 0.00376494, 0.00403702, 0.00432876, 0.00464159, 0.00497702,
    0.0053367,  0.00572237, 0.00613591, 0.00657933, 0.0070548,  0.00756463,
    0.00811131, 0.00869749, 0.00932603, 0.01,       0.0107227,  0.0114976,
    0.0123285,  0.0132194,  0.0141747,  0.0151991,  0.0162975,  0.0174753,
    0.0187382,  0.0200923,  0.0215443,  0.0231013,  0.0247708,  0.0265609,
    0.0284804,  0.0305386,  0.0327455,  0.0351119,  0.0376494,  0.0403702,
    0.0432876,  0.0464159,  0.0497702,  0.053367,   0.0572237,  0.0613591,
    0.0657933,  0.070548,   0.0756463,  0.0811131,  0.0869749,  0.0932603,
    0.1,        0.107227,   0.114976,   0.123285,   0.132194,   0.141747,
    0.151991,   0.162975,   0.174753,   0.187382,   0.200923,   0.215443,
    0.231013,   0.247708,   0.265609,   0.284804,   0.305386,   0.327455,
    0.351119,   0.376494,   0.403702,   0.432876,   0.464159,   0.497702,
    0.53367,    0.572237,   0.613591,   0.657933,   0.70548,    0.756463,
    0.811131,   0.869749,   0.932603,   1.0}

photon momentum

Definition at line 50 of file crosssectionsbrems.h.

BREMS_THETA

const std::initializer_list<double> smash::BREMS_THETA

Initial value:

= {
    0.0,      0.039767, 0.079534, 0.119301, 0.159068, 0.198835, 0.238602,
    0.278369, 0.318136, 0.357903, 0.39767,  0.437437, 0.477204, 0.516971,
    0.556738, 0.596505, 0.636272, 0.676039, 0.715806, 0.755573, 0.79534,
    0.835107, 0.874874, 0.914641, 0.954408, 0.994175, 1.03394,  1.07371,
    1.11348,  1.15324,  1.19301,  1.23278,  1.27254,  1.31231,  1.35208,
    1.39184,  1.43161,  1.47138,  1.51115,  1.55091,  1.59068,  1.63045,
    1.67021,  1.70998,  1.74975,  1.78951,  1.82928,  1.86905,  1.90882,
    1.94858,  1.98835,  2.02812,  2.06788,  2.10765,  2.14742,  2.18718,
    2.22695,  2.26672,  2.30649,  2.34625,  2.38602,  2.42579,  2.46555,
    2.50532,  2.54509,  2.58485,  2.62462,  2.66439,  2.70416,  2.74392,
    2.78369,  2.82346,  2.86322,  2.90299,  2.94276,  2.98252,  3.02229,
    3.06206,  3.10183,  3.14159}

theta angle with respect to collision axis of incoming pions

Definition at line 70 of file crosssectionsbrems.h.

pipi_pipi_opp_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pipi_pipi_opp_interpolation = nullptr

static

Definition at line 89 of file crosssectionsbrems.h.

pipi_pipi_opp_dsigma_dk_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi_pipi_opp_dsigma_dk_interpolation = nullptr

static

Definition at line 91 of file crosssectionsbrems.h.

pipi_pipi_opp_dsigma_dtheta_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi_pipi_opp_dsigma_dtheta_interpolation = nullptr

static

Definition at line 93 of file crosssectionsbrems.h.

BREMS_PIPI_PIPI_OPP_SIG

const std::initializer_list<double> smash::BREMS_PIPI_PIPI_OPP_SIG

Total π+- + π-+ -> π+- + π-+ + γ cross section.

Definition at line 97 of file crosssectionsbrems.h.

BREMS_PIPI_PIPI_OPP_DIFF_SIG_K

const std::initializer_list<double> smash::BREMS_PIPI_PIPI_OPP_DIFF_SIG_K

dSigma/dk for π+- + π-+ -> π+- + π-+ + γ

Definition at line 139 of file crosssectionsbrems.h.

BREMS_PIPI_PIPI_OPP_DIFF_SIG_THETA

const std::initializer_list<double> smash::BREMS_PIPI_PIPI_OPP_DIFF_SIG_THETA

dSigma/dtheta for π+- + π-+ -> π+- + π-+ + γ

Definition at line 4642 of file crosssectionsbrems.h.

pipi_pipi_same_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pipi_pipi_same_interpolation = nullptr

static

Definition at line 8969 of file crosssectionsbrems.h.

pipi_pipi_same_dsigma_dk_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi_pipi_same_dsigma_dk_interpolation = nullptr

static

Definition at line 8971 of file crosssectionsbrems.h.

pipi_pipi_same_dsigma_dtheta_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi_pipi_same_dsigma_dtheta_interpolation = nullptr

static

Definition at line 8973 of file crosssectionsbrems.h.

BREMS_PIPI_PIPI_SAME_SIG

const std::initializer_list<double> smash::BREMS_PIPI_PIPI_SAME_SIG

Total π+ + π+ -> π+ + π+ + γ or π- + π- -> π- + π- + γ cross section.

Definition at line 8977 of file crosssectionsbrems.h.

BREMS_PIPI_PIPI_SAME_DIFF_SIG_K

const std::initializer_list<double> smash::BREMS_PIPI_PIPI_SAME_DIFF_SIG_K

dSigma/dk for π+ + π+ -> π+ + π+ + γ or π- + π- -> π- + π- + γ

Definition at line 9025 of file crosssectionsbrems.h.

BREMS_PIPI_PIPI_SAME_DIFF_SIG_THETA

const std::initializer_list<double> smash::BREMS_PIPI_PIPI_SAME_DIFF_SIG_THETA

dSigma/dtheta for π+ + π+ -> π+ + π+ + γ or π- + π- -> π- + π- + γ

Definition at line 14428 of file crosssectionsbrems.h.

pipi0_pipi0_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pipi0_pipi0_interpolation = nullptr

static

Definition at line 18754 of file crosssectionsbrems.h.

pipi0_pipi0_dsigma_dk_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi0_pipi0_dsigma_dk_interpolation = nullptr

static

Definition at line 18756 of file crosssectionsbrems.h.

pipi0_pipi0_dsigma_dtheta_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi0_pipi0_dsigma_dtheta_interpolation = nullptr

static

Definition at line 18758 of file crosssectionsbrems.h.

BREMS_PIPI0_PIPI0_SIG

const std::initializer_list<double> smash::BREMS_PIPI0_PIPI0_SIG

Total π0 + π -> π0 + π + γ cross section.

Definition at line 18762 of file crosssectionsbrems.h.

BREMS_PIPI0_PIPI0_DIFF_SIG_K

const std::initializer_list<double> smash::BREMS_PIPI0_PIPI0_DIFF_SIG_K

dSigma/dk for π0 + π -> π0 + π + γ

Definition at line 18810 of file crosssectionsbrems.h.

BREMS_PIPI0_PIPI0_DIFF_SIG_THETA

const std::initializer_list<double> smash::BREMS_PIPI0_PIPI0_DIFF_SIG_THETA

dSigma/dtheta for π0 + π -> π0 + π + γ

Definition at line 23313 of file crosssectionsbrems.h.

pipi_pi0pi0_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pipi_pi0pi0_interpolation = nullptr

static

Definition at line 27639 of file crosssectionsbrems.h.

pipi_pi0pi0_dsigma_dk_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi_pi0pi0_dsigma_dk_interpolation = nullptr

static

Definition at line 27641 of file crosssectionsbrems.h.

pipi_pi0pi0_dsigma_dtheta_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pipi_pi0pi0_dsigma_dtheta_interpolation = nullptr

static

Definition at line 27643 of file crosssectionsbrems.h.

BREMS_PIPI_PI0PI0_SIG

const std::initializer_list<double> smash::BREMS_PIPI_PI0PI0_SIG

Total π+- + π-+ -> π0 + π0 + γ cross section.

Definition at line 27647 of file crosssectionsbrems.h.

BREMS_PIPI_PI0PI0_DIFF_SIG_K

const std::initializer_list<double> smash::BREMS_PIPI_PI0PI0_DIFF_SIG_K

dSigma/dk for π+- + π-+ -> π0 + π0 + γ

Definition at line 27695 of file crosssectionsbrems.h.

BREMS_PIPI_PI0PI0_DIFF_SIG_THETA

const std::initializer_list<double> smash::BREMS_PIPI_PI0PI0_DIFF_SIG_THETA

dSigma/dtheta for π+- + π-+ -> π0 + π0 + γ

Definition at line 31556 of file crosssectionsbrems.h.

pi0pi0_pipi_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pi0pi0_pipi_interpolation = nullptr

static

Definition at line 35882 of file crosssectionsbrems.h.

pi0pi0_pipi_dsigma_dk_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pi0pi0_pipi_dsigma_dk_interpolation = nullptr

static

Definition at line 35884 of file crosssectionsbrems.h.

pi0pi0_pipi_dsigma_dtheta_interpolation

std::unique_ptr<InterpolateData2DSpline> smash::pi0pi0_pipi_dsigma_dtheta_interpolation = nullptr

static

Definition at line 35886 of file crosssectionsbrems.h.

BREMS_PI0PI0_PIPI_SIG

const std::initializer_list<double> smash::BREMS_PI0PI0_PIPI_SIG

Total π0 + π0 -> π+- + π-+ + γ cross section.

Definition at line 35890 of file crosssectionsbrems.h.

BREMS_PI0PI0_PIPI_DIFF_SIG_K

const std::initializer_list<double> smash::BREMS_PI0PI0_PIPI_DIFF_SIG_K

dSigma/dk for π0 + π0 -> π+- + π-+ + γ

Definition at line 35938 of file crosssectionsbrems.h.

BREMS_PI0PI0_PIPI_DIFF_SIG_THETA

const std::initializer_list<double> smash::BREMS_PI0PI0_PIPI_DIFF_SIG_THETA

dSigma/dtheta for π0 + π0 -> π+- + π-+ + γ

Definition at line 41341 of file crosssectionsbrems.h.

LDensity

constexpr int smash::LDensity = LogArea::Density::id

staticconstexpr

Definition at line 29 of file density.h.

LMain [1/2]

constexpr int smash::LMain = LogArea::Main::id

staticconstexpr

Definition at line 94 of file experiment.h.

LInitialConditions [1/2]

constexpr int smash::LInitialConditions = LogArea::InitialConditions::id

staticconstexpr

Definition at line 95 of file experiment.h.

LLattice

constexpr int smash::LLattice = LogArea::Lattice::id

staticconstexpr

Definition at line 27 of file lattice.h.

LOutput

constexpr int smash::LOutput = LogArea::Output::id

staticconstexpr

Definition at line 26 of file outputinterface.h.

LExperiment

constexpr int smash::LExperiment = LogArea::Experiment::id

staticconstexpr

Definition at line 23 of file outputparameters.h.

kaon_nucleon_ratios

KaonNucleonRatios smash::kaon_nucleon_ratios

Definition at line 809 of file parametrizations.cc.

KMINUSN_TOT_PLAB

const std::initializer_list<double> smash::KMINUSN_TOT_PLAB

Initial value:

= {
    0.627,   0.728333, 0.846,   0.924,   1.01033, 1.09367, 1.259,   1.48,
    1.72,    2.05333,  2.46667, 2.81667, 3.31667, 4.32667, 5.54333, 6.88333,
    8.21667, 9.33333,  10.6667, 11.7667, 13.1,    14.1,    15.,     16.3333,
    18.,     19.3333,  21.6667, 23.3333, 26.6667, 28.3333, 31.6667, 33.3333,
    35.,     36.6667,  38.3333, 41.6667, 43.3333, 46.6667, 48.3333, 50.,
    50.,     51.6667,  53.3333, 60.,     75.,     90.,     106.667, 123.333,
    140.,    156.667,  173.333, 190.,    213.333, 240.,    276.667, 280.,
    310.}

PDG data on K- n total cross section: momentum in lab frame.

Definition at line 20 of file parametrizations_data.h.

KMINUSN_TOT_SIG

const std::initializer_list<double> smash::KMINUSN_TOT_SIG

Initial value:

= {
    26.2,    29.1333, 30.8,    33.9667, 36.1667, 35.5667, 30.8,    26.7,
    24.4667, 23.2,    22.5667, 22.2667, 21.5667, 21.4,    21.4667, 21.2,
    20.9333, 20.4667, 20.6333, 20.5667, 20.4,    20.3033, 20.1033, 20.17,
    19.9,    19.75,   19.55,   19.6667, 19.5267, 19.66,   19.81,   19.8233,
    19.7367, 19.57,   19.5333, 19.4067, 19.6733, 19.8033, 19.7867, 19.6867,
    19.7233, 19.7633, 19.93,   19.92,   20.0267, 19.88,   19.99,   20.08,
    20.0967, 20.1267, 20.26,   20.3567, 20.4567, 20.5833, 20.84,   20.9,
    21.07}

PDG data on K- n total cross section: cross section.

Definition at line 31 of file parametrizations_data.h.

kminusn_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::kminusn_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the KMINUSN_TOT data.

Definition at line 43 of file parametrizations_data.h.

KMINUSP_ELASTIC_P_LAB

const std::initializer_list<double> smash::KMINUSP_ELASTIC_P_LAB

PDG data on K- p elastic cross section: momentum in lab frame.

Definition at line 46 of file parametrizations_data.h.

KMINUSP_ELASTIC_SIG

const std::initializer_list<double> smash::KMINUSP_ELASTIC_SIG

PDG data on K- p elastic cross section: cross section.

Definition at line 94 of file parametrizations_data.h.

kminusp_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::kminusp_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the KMINUSP_ELASTIC data.

Definition at line 133 of file parametrizations_data.h.

KMINUSP_TOT_PLAB

const std::initializer_list<double> smash::KMINUSP_TOT_PLAB

PDG smoothed data on K- p total cross section: momentum in lab frame.

Definition at line 136 of file parametrizations_data.h.

KMINUSP_TOT_SIG

const std::initializer_list<double> smash::KMINUSP_TOT_SIG

PDG smoothed data on K- p total cross section: cross section.

Definition at line 191 of file parametrizations_data.h.

kminusp_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::kminusp_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the KMINUSP_TOT data.

Definition at line 237 of file parametrizations_data.h.

KMINUSP_RES_SQRTS

const std::initializer_list<double> smash::KMINUSP_RES_SQRTS

Initial value:

= {
    1.4355, 1.4530, 1.4730, 1.4929, 1.5129, 1.5329, 1.5529, 1.5729,
    1.5929, 1.6128, 1.6328, 1.6528, 1.6728, 1.6928, 1.7127, 1.7327,
    1.7527, 1.7727, 1.7927, 1.8127, 1.8326, 1.8526, 1.8726, 1.8926,
    1.9126, 1.9325, 1.9525, 1.9725, 1.9925, 2.0125, 2.0325, 2.0524,
    2.0724, 2.0924, 2.1124, 2.1324, 2.1523, 2.1723, 2.1923, 2.2123,
    2.2323, 2.2523, 2.2722, 2.2922, 2.3122, 2.3322, 2.3522, 2.3721,
    2.3921, 2.4121, 2.4321, 2.4521, 2.4721, 2.4920, 2.5120, 2.5320}

Center-of-mass energy list for K̅⁻ N⁺

Definition at line 240 of file parametrizations_data.h.

KMINUSP_RES_SIG

const std::initializer_list<double> smash::KMINUSP_RES_SIG

Initial value:

= {
    0.46856081097,  0.68994120313, 1.00475205957,  1.66469547655,
    5.63530052434,  4.17372028288, 4.50737036469,  8.00913400697,
    0.29205365102,  2.72859364291, 3.30822314603,  4.44740017628,
    4.95697831919,  5.05350905117, 4.87562017799,  7.48383422000,
    8.29845755438,  9.71940157530, 11.10200040600, 12.00610574630,
    10.06137989140, 7.47886042856, 6.11390219499,  5.19531126779,
    4.38090191191,  3.95316327084, 3.53446044755,  3.46497827089,
    3.63741875589,  3.77762079044, 0.87409952036,  4.19070149234,
    4.38097308237,  4.27752586136, 4.12637945445,  3.70027602474,
    3.31806303484,  2.88526838044, 2.58141493751,  2.36391939397,
    2.18133708906,  1.39193162095, 2.03247269918,  2.00726146262,
    2.13817978212,  2.16907178433, 2.08118209913,  1.83166338166,
    1.56038155638,  1.27216056674, 1.03167072054,  0.85006416230,
    0.39627220898,  0.57172926654, 0.51129452389,  0.44626386026}

Elastic K̅⁻ N⁺ cross section contributions from decays.

These need to be subtracted from the interpolation of the PDG data on elastic cross sections. This data was generated using the SMASH analysis suite and should be updated when strange resonances are changed or added.

Definition at line 256 of file parametrizations_data.h.

kminusp_elastic_res_interpolation

std::unique_ptr<InterpolateDataSpline> smash::kminusp_elastic_res_interpolation = nullptr

static

An interpolation that gets lazily filled using the KMINUSP_RES data.

Definition at line 274 of file parametrizations_data.h.

KPLUSN_TOT_PLAB

const std::initializer_list<double> smash::KPLUSN_TOT_PLAB

Initial value:

= {
    0.770,   0.888,   0.939,   0.970,   0.989,   1.040,   1.091,   1.141,
     1.191,   1.242,   1.292,   1.300,   1.342,   1.392,   1.440,
    1.442,   1.492,   1.550,   1.593,   1.600,   1.643,   1.690,   1.693,
    1.700,   1.743,   1.750,   1.793,   1.800,   1.850,   1.893,   1.900,
    1.950,   1.970,   1.993,   2.000,   2.050,   2.093,   2.100,   2.150,
    2.193,   2.200,   2.260,   2.300,   2.350,   2.393,   2.400,   2.450,
    2.500,   2.550,   2.550,   2.600,   2.650,   2.700,   2.750,   2.800,
    2.830,   2.850,   2.900,   2.950,   3.000,   3.050,   3.100,   3.150,
    3.200,   3.250,   3.300,   6.000,   8.000,   10.000,  12.000,  14.000,
    15.000,  16.000,  18.000,  20.000,  20.000,  25.000,  30.000,  35.000,
    35.000,  40.000,  45.000,  50.000,  50.000,  50.000,  55.000,  70.000,
    100.000, 100.000, 120.000, 150.000, 150.000, 170.000, 200.000, 200.000,
    240.000, 280.000, 310.000}

PDG data on K+ n total cross section: momentum in lab frame.

One data point is ignored because it is an outlier and messes up the smoothing.

Definition at line 282 of file parametrizations_data.h.

KPLUSN_TOT_SIG

const std::initializer_list<double> smash::KPLUSN_TOT_SIG

Initial value:

= {
    15.50, 16.85, 17.60, 17.80, 18.53, 18.91, 20.61, 21.25,  20.87,
    20.26, 19.68, 18.50, 19.32, 19.22, 18.10, 19.07, 18.95, 18.91,
    18.79, 18.89, 18.67, 18.50, 18.69, 18.83, 18.88, 18.86, 18.73,
    18.53, 18.66, 18.50, 18.69, 18.70, 18.60, 18.55, 18.79, 18.54,
    18.67, 18.49, 18.43, 18.40, 18.40, 17.70, 18.27, 18.26, 18.63,
    18.09, 18.25, 18.11, 17.10, 18.17, 18.09, 18.02, 18.11, 18.06,
    18.01, 17.50, 17.95, 17.85, 17.81, 17.81, 17.83, 17.85, 17.61,
    17.61, 17.66, 17.55, 17.50, 17.60, 17.50, 17.60, 17.50, 17.87,
    17.40, 17.60, 17.94, 17.70, 17.78, 17.69, 18.29, 18.12, 18.15,
    18.30, 18.66, 18.56, 18.02, 18.43, 18.60, 19.04, 18.99, 19.23,
    19.63, 19.55, 19.74, 19.72, 19.82, 20.37, 20.61, 20.80}

PDG data on K+ n total cross section: cross section.

One data point is ignored because it is an outlier and messes up the smoothing.

Definition at line 303 of file parametrizations_data.h.

kplusn_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::kplusn_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the KPLUSN_TOT data.

Definition at line 318 of file parametrizations_data.h.

KPLUSP_TOT_PLAB

const std::initializer_list<double> smash::KPLUSP_TOT_PLAB

Initial value:

= {
    0.178,   0.265,   0.321,   0.351,   0.366,   0.405,   0.440,   0.451,
    0.475,   0.475,   0.506,   0.522,   0.536,   0.566,   0.569,   0.588,
    0.589,   0.592,   0.593,   0.596,   0.618,   0.620,   0.627,   0.643,
    0.644,   0.657,   0.668,   0.686,   0.698,   0.713,   0.717,   0.727,
    0.757,   0.768,   0.770,   0.786,   0.817,   0.823,   0.846,   0.864,
    0.864,   0.881,   0.891,   0.900,   0.904,   0.916,   0.938,   0.942,
    0.951,   0.969,   0.969,   0.970,   0.970,   0.985,   0.992,   1.020,
    1.029,   1.043,   1.055,   1.060,   1.084,   1.090,   1.094,   1.125,
    1.130,   1.140,   1.144,   1.160,   1.170,   1.189,   1.194,   1.207,
    1.210,   1.238,   1.245,   1.250,   1.293,   1.295,   1.300,   1.320,
    1.345,   1.347,   1.380,   1.395,   1.408,   1.440,   1.445,   1.455,
    1.468,   1.480,   1.495,   1.550,   1.563,   1.596,   1.600,   1.646,
    1.690,   1.696,   1.700,   1.746,   1.750,   1.796,   1.800,   1.850,
    1.896,   1.900,   1.945,   1.950,   1.960,   1.970,   1.996,   2.000,
    2.050,   2.096,   2.100,   2.150,   2.196,   2.200,   2.260,   2.300,
    2.350,   2.396,   2.400,   2.450,   2.473,   2.500,   2.530,   2.550,
    2.550,   2.600,   2.650,   2.700,   2.750,   2.760,   2.800,   2.830,
    2.850,   2.900,   2.950,   3.000,   3.050,   3.100,   3.150,   3.200,
    3.200,   3.250,   3.250,   3.300,   3.700,   4.000,   4.200,   4.750,
    5.000,   5.500,   6.000,   7.000,   7.000,   8.000,   8.200,   8.500,
    10.000,  10.000,  10.000,  10.000,  10.900,  11.500,  12.000,  12.500,
    13.400,  14.000,  15.000,  15.000,  16.000,  16.000,  16.900,  18.000,
    19.000,  20.000,  20.000,  25.000,  30.000,  32.000,  35.000,  35.000,
    40.000,  42.500,  45.000,  50.000,  50.000,  50.000,  52.200,  55.000,
    70.000,  100.000, 100.000, 100.000, 100.000, 120.000, 147.000, 150.000,
    150.000, 170.000, 175.000, 200.000, 200.000, 240.000, 280.000, 310.000}

PDG data on K+ p total cross section: momentum in lab frame.

Definition at line 321 of file parametrizations_data.h.

KPLUSP_TOT_SIG

const std::initializer_list<double> smash::KPLUSP_TOT_SIG

Initial value:

= {
    11.40, 13.00, 14.00, 12.20, 13.20, 13.69, 12.81, 16.30, 12.70, 13.58, 13.02,
    15.20, 12.09, 13.20, 12.70, 12.60, 16.30, 14.36, 13.05, 13.04, 12.65, 12.91,
    12.18, 12.50, 12.88, 12.43, 13.10, 11.25, 12.60, 11.14, 11.10, 12.45, 12.65,
    11.65, 13.00, 12.80, 13.20, 12.97, 13.45, 14.07, 13.21, 13.90, 14.39, 13.10,
    14.23, 14.20, 14.59, 15.57, 14.95, 15.28, 15.63, 15.40, 15.25, 16.20, 15.97,
    16.10, 15.69, 17.39, 16.95, 16.40, 17.04, 17.60, 17.12, 17.55, 18.08, 18.02,
    18.09, 17.95, 18.10, 18.06, 18.47, 19.85, 18.58, 18.11, 18.54, 20.71, 18.44,
    18.61, 17.90, 19.33, 18.44, 18.27, 18.64, 18.27, 17.97, 18.10, 18.04, 18.20,
    17.94, 18.04, 17.93, 17.70, 17.66, 17.75, 17.71, 17.86, 17.50, 17.85, 17.73,
    17.80, 17.83, 17.80, 17.98, 17.77, 17.81, 17.79, 17.41, 17.75, 19.40, 16.90,
    17.60, 17.63, 17.72, 17.51, 17.56, 17.57, 17.54, 17.60, 17.10, 17.44, 17.52,
    17.55, 17.56, 17.48, 17.25, 17.49, 17.47, 17.10, 17.44, 17.50, 17.47, 17.41,
    17.41, 17.41, 17.40, 16.70, 17.30, 17.34, 17.30, 17.19, 17.14, 17.08, 17.15,
    17.13, 17.13, 17.13, 17.50, 17.14, 21.00, 17.60, 17.10, 21.30, 17.20, 17.90,
    17.00, 17.20, 18.40, 17.30, 17.20, 18.70, 17.20, 17.30, 18.80, 17.30, 18.10,
    19.00, 17.30, 18.30, 17.50, 17.40, 18.50, 17.31, 17.10, 17.00, 18.80, 17.10,
    17.30, 17.50, 17.42, 17.68, 17.72, 18.40, 17.82, 17.80, 18.05, 17.91, 17.88,
    18.06, 18.03, 18.37, 18.28, 18.17, 18.52, 18.40, 18.88, 18.70, 18.85, 19.14,
    19.52, 19.36, 19.33, 19.64, 18.20, 19.91, 19.84, 20.22, 20.45, 20.67}

PDG data on K+ p total cross section: cross section.

Definition at line 350 of file parametrizations_data.h.

kplusp_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::kplusp_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the KPLUSP_TOT data.

Definition at line 373 of file parametrizations_data.h.

PIMINUSP_ELASTIC_P_LAB

const std::initializer_list<double> smash::PIMINUSP_ELASTIC_P_LAB

Initial value:

= {
    0.09875, 0.14956, 0.21648, 0.21885, 0.22828, 0.24684, 0.25599, 0.26733,
    0.27071, 0.2752,  0.29303, 0.29303, 0.33138, 0.33571, 0.33788, 0.35052,
    0.378,   0.38261, 0.404,   0.40626, 0.408,   0.42188, 0.427,   0.44888,
    0.452,   0.471,   0.49008, 0.49008, 0.49008, 0.509,   0.523,   0.52845,
    0.53155, 0.547,   0.54911, 0.54911, 0.556,   0.565,   0.57281, 0.582,
    0.586,   0.609,   0.6139,  0.61698, 0.625,   0.64054, 0.657,   0.65793,
    0.658,   0.6753,  0.683,   0.687,   0.69061, 0.699,   0.70692, 0.71399,
    0.72628, 0.731,   0.73257, 0.74257, 0.75,    0.76189, 0.775,   0.77714,
    0.77714, 0.77827, 0.798,   0.82586, 0.83803, 0.848,   0.84954, 0.854,
    0.87466, 0.90386, 0.91903, 0.924,   0.95947, 1.03016, 1.106,   1.12339,
    1.164,   1.165,   1.174,   1.214,   1.21659, 1.23,    1.25,    1.26,
    1.279,   1.323,   1.339,   1.347,   1.355,   1.365,   1.375,   1.385,
    1.395,   1.405,   1.415,   1.425,   1.435,   1.445,   1.455,   1.465,
    1.475,   1.485,   1.495,   1.497,   1.499,   1.503,   1.5031,  1.509,
    1.567,   1.59,    1.6,     1.603,   1.71,    1.85,    2.1,     2.14,
    2.26,    2.29,    2.7,     2.75,    2.77,    2.7999,  3.,      3.15}

PDG data on pi- p elastic cross section: momentum in lab frame.

Definition at line 376 of file parametrizations_data.h.

PIMINUSP_ELASTIC_SIG

const std::initializer_list<double> smash::PIMINUSP_ELASTIC_SIG

Initial value:

= {
    1.847,  2.9,    9.6,    11.3,   12.8,   17.,    20.1,   21.4,   22.5,
    21.2,   22.5,   18.2,   19.5,   16.,    17.4,   15.1,   12.29,  12.4,
    10.1,   13.8,   10.41,  11.4,   9.,     10.3,   8.9,    9.2,    10.42,
    10.9,   10.8,   9.15,   9.8,    11.4,   11.4,   9.99,   13.,    13.,
    10.24,  10.8,   12.19,  16.2,   11.34,  12.86,  13.71,  13.9,   12.19,
    14.8,   13.92,  16.2,   15.32,  16.98,  18.9,   17.07,  18.86,  19.07,
    19.95,  20.5,   19.87,  18.9,   16.6,   19.4,   19.91,  18.94,  17.56,
    17.19,  17.82,  16.1,   14.91,  15.75,  14.9,   13.2,   14.1,   14.47,
    14.4,   14.8,   14.1,   18.8,   18.,    18.6,   17.95,  17.7,   13.66,
    15.01,  15.73,  12.45,  14.1,   14.6,   13.31,  13.8,   12.8,   13.09,
    12.627, 12.987, 12.763, 12.367, 12.852, 12.67,  12.126, 12.972, 12.478,
    12.594, 12.532, 11.801, 11.568, 11.413, 11.119, 11.643, 11.368, 11.523,
    11.163, 11.69,  10.,    10.39,  10.21,  9.65,   9.,     9.82,   10.4,
    11.1,   9.69,   9.3,    8.91,   8.5,    7.7,    7.2,    7.2,    7.8,
    7.57,   6.1}

PDG data on pi- p elastic cross section: cross section.

Definition at line 395 of file parametrizations_data.h.

piminusp_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piminusp_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIMINUSP_ELASTIC data.

Definition at line 414 of file parametrizations_data.h.

PIMINUSP_LAMBDAK0_P_LAB

const std::initializer_list<double> smash::PIMINUSP_LAMBDAK0_P_LAB

Initial value:

= {
    0.904, 0.91,  0.919, 0.922, 0.926, 0.93,  0.931, 0.942, 0.945, 0.958, 0.964,
    0.968, 0.98,  0.98,  0.983, 0.993, 0.997, 1.001, 1.002, 1.007, 1.012, 1.017,
    1.02,  1.02,  1.021, 1.022, 1.023, 1.027, 1.031, 1.035, 1.04,  1.04,  1.04,
    1.043, 1.048, 1.054, 1.059, 1.065, 1.078, 1.081, 1.091, 1.091, 1.094, 1.095,
    1.097, 1.116, 1.129, 1.13,  1.135, 1.144, 1.159, 1.194, 1.223, 1.235, 1.277,
    1.287, 1.326, 1.331, 1.332, 1.395, 1.433, 1.455, 1.5,   1.508, 1.515, 1.575,
    1.59,  1.6,   1.615, 1.645, 1.69,  1.69,  1.705, 1.775, 1.85,  1.875, 1.94,
    1.95,  1.98,  2.,    2.05,  2.05,  2.055, 2.115, 2.14,  2.15,  2.235, 2.25,
    2.35,  2.375, 2.494, 2.605, 2.7,   2.75,  2.75,  2.86,  3.01,  3.125, 3.21,
    3.885, 3.9,   3.95,  4.16,  4.5,   6.,    8.,    10.}

PDG data on pi- p to Lambda K0 cross section: momentum in lab frame.

Definition at line 417 of file parametrizations_data.h.

PIMINUSP_LAMBDAK0_SIG

const std::initializer_list<double> smash::PIMINUSP_LAMBDAK0_SIG

Initial value:

= {
    0.056, 0.122,  0.18,  0.14,  0.227, 0.212,  0.13,  0.3,   0.336, 0.43,
    0.427, 0.52,   0.467, 0.45,  0.576, 0.59,   0.652, 0.56,  0.588, 0.634,
    0.686, 0.665,  0.67,  0.69,  0.809, 0.675,  0.94,  0.737, 0.734, 0.73,
    0.926, 0.59,   0.92,  0.57,  0.568, 0.651,  0.899, 0.64,  0.794, 0.58,
    0.82,  0.58,   0.7,   0.68,  0.729, 0.575,  0.592, 0.462, 0.541, 0.64,
    0.48,  0.58,   0.46,  0.485, 0.447, 0.25,   0.367, 0.32,  0.29,  0.25,
    0.32,  0.29,   0.334, 0.214, 0.22,  0.21,   0.214, 0.238, 0.208, 0.16,
    0.199, 0.174,  0.14,  0.13,  0.181, 0.16,   0.185, 0.182, 0.184, 0.15,
    0.182, 0.179,  0.11,  0.16,  0.162, 0.192,  0.15,  0.172, 0.174, 0.12,
    0.16,  0.106,  0.12,  0.09,  0.09,  0.109,  0.084, 0.094, 0.087, 0.067,
    0.058, 0.0644, 0.049, 0.054, 0.038, 0.0221, 0.0157}

PDG data on pi- p to Lambda K0 cross section: cross section.

Definition at line 430 of file parametrizations_data.h.

piminusp_lambdak0_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piminusp_lambdak0_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIMINUSP_LAMBDAK0 data.

Definition at line 445 of file parametrizations_data.h.

PIMINUSP_SIGMAMINUSKPLUS_P_LAB

const std::initializer_list<double> smash::PIMINUSP_SIGMAMINUSKPLUS_P_LAB

Initial value:

= {
    1.091, 1.128, 1.17, 1.22,  1.235, 1.284, 1.326, 1.5,  1.59,
    1.615, 1.69,  1.69, 1.85,  1.94,  1.95,  1.98,  2.05, 2.14,
    2.15,  2.25,  2.35, 2.494, 2.61,  2.7,   2.75,  2.86, 3.,
    3.01,  3.13,  3.21, 3.89,  3.95,  4.,    4.16}

PDG data on pi- p to Sigma- K+ cross section: momentum in lab frame.

Definition at line 448 of file parametrizations_data.h.

PIMINUSP_SIGMAMINUSKPLUS_SIG

const std::initializer_list<double> smash::PIMINUSP_SIGMAMINUSKPLUS_SIG

Initial value:

= {
    0.25,  0.218,  0.231,  0.27,   0.235,  0.209, 0.245, 0.242, 0.262,
    0.18,  0.153,  0.19,   0.099,  0.098,  0.099, 0.09,  0.087, 0.069,
    0.065, 0.057,  0.053,  0.051,  0.03,   0.031, 0.032, 0.022, 0.015,
    0.022, 0.0155, 0.0145, 0.0085, 0.0096, 0.005, 0.0045}

PDG data on pi- p to Sigma- K+ cross section: cross section.

Definition at line 455 of file parametrizations_data.h.

piminusp_sigmaminuskplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piminusp_sigmaminuskplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIMINUSP_SIGMAMINUSKPLUS data.

Definition at line 466 of file parametrizations_data.h.

PIMINUSP_SIGMA0K0_RES_SQRTS

const std::initializer_list<double> smash::PIMINUSP_SIGMA0K0_RES_SQRTS

Initial value:

= {
    1.5,   1.516, 1.532, 1.548, 1.564, 1.58,  1.596, 1.612, 1.628, 1.644, 1.66,
    1.676, 1.692, 1.708, 1.724, 1.74,  1.756, 1.772, 1.788, 1.804, 1.82,  1.836,
    1.852, 1.868, 1.884, 1.9,   1.916, 1.932, 1.948, 1.964, 1.98,  1.996, 2.012,
    2.028, 2.044, 2.06,  2.076, 2.092, 2.108, 2.124, 2.14,  2.156, 2.172, 2.188,
    2.204, 2.22,  2.236, 2.252, 2.268, 2.284, 2.3,   2.316, 2.332, 2.348, 2.364,
    2.38,  2.396, 2.412, 2.428, 2.444, 2.46,  2.476, 2.492, 2.508, 2.524, 2.54,
    2.556, 2.572, 2.588, 2.604, 2.62,  2.636, 2.652, 2.668, 2.684, 2.7,   2.716,
    2.732, 2.748, 2.764, 2.78,  2.796, 2.812, 2.828, 2.844, 2.86,  2.876, 2.892,
    2.908, 2.924, 2.94,  2.956, 2.972, 2.988, 3.004, 3.02,  3.036, 3.052, 3.068,
    3.084, 3.1,   3.116, 3.132, 3.148, 3.164, 3.18}

pi- p to Sigma0 K0 cross section: square root s

Definition at line 469 of file parametrizations_data.h.

PIMINUSP_SIGMA0K0_RES_SIG

const std::initializer_list<double> smash::PIMINUSP_SIGMA0K0_RES_SIG

Initial value:

= {
    0.,         0.,         0.,         0.,         0.,         0.,
    0.,         0.,         0.,         0.,         0.,         0.,
    0.0386981,  0.09589789, 0.11956695, 0.11685363, 0.12053117, 0.13208736,
    0.14949223, 0.16688579, 0.18830654, 0.20611132, 0.22231072, 0.23099061,
    0.23734563, 0.23334048, 0.22794051, 0.21559531, 0.20134617, 0.18763246,
    0.1723282,  0.15814744, 0.14757816, 0.13750278, 0.12698656, 0.11719809,
    0.11024985, 0.1044732,  0.09623321, 0.09092108, 0.08670191, 0.08147493,
    0.0772165,  0.07346243, 0.0719974,  0.06805902, 0.06496733, 0.06264939,
    0.05904799, 0.05762721, 0.05588871, 0.05393479, 0.0517673,  0.05165839,
    0.05087591, 0.04885535, 0.04730724, 0.04651682, 0.04604065, 0.04529776,
    0.04406593, 0.04367817, 0.04230014, 0.04144308, 0.04171145, 0.04073006,
    0.03996921, 0.03902337, 0.03939531, 0.03895125, 0.03904553, 0.03816119,
    0.03772662, 0.03710955, 0.0361001,  0.03632378, 0.03549849, 0.03549987,
    0.03527251, 0.034535,   0.03314715, 0.0335742,  0.03326698, 0.0330181,
    0.0324203,  0.03227253, 0.0315376,  0.03065083, 0.03041305, 0.03023753,
    0.03008669, 0.02900321, 0.02827017, 0.02805024, 0.02785525, 0.02753706,
    0.02692862, 0.02603758, 0.02591122, 0.02537291, 0.02467199, 0.02466657,
    0.02370074, 0.02353027, 0.02362089, 0.0230085}

pi- p to Sigma0 K0 cross section: cross section

The experimental data is missing, so the cross section is obtained by running the simulation, and purely contributed by the resonances

Definition at line 487 of file parametrizations_data.h.

piminusp_sigma0k0_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piminusp_sigma0k0_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIMINUSP_SIGMA0K0_RES data.

Definition at line 512 of file parametrizations_data.h.

PIMINUSP_RES_SQRTS

const std::initializer_list<double> smash::PIMINUSP_RES_SQRTS

Center-of-mass energy.

Definition at line 515 of file parametrizations_data.h.

PIMINUSP_RES_SIG

const std::initializer_list<double> smash::PIMINUSP_RES_SIG

Elastic π⁻N⁺ cross section contributions from decays.

These need to be subtracted from the interpolation of the PDG data on elastic cross sections. This data was generated using the SMASH analysis suite and should be updated when strange resonances are changed or added.

Definition at line 593 of file parametrizations_data.h.

piminusp_elastic_res_interpolation

std::unique_ptr<InterpolateDataSpline> smash::piminusp_elastic_res_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIMINUSP_RES data.

Definition at line 666 of file parametrizations_data.h.

PIPLUSP_ELASTIC_P_LAB

const std::initializer_list<double> smash::PIPLUSP_ELASTIC_P_LAB

Initial value:

= {
    0.09875, 0.13984, 0.14956, 0.33138, 0.378,   0.408,   0.4093,  0.427,
    0.42736, 0.453,   0.471,   0.49008, 0.509,   0.5214,  0.53155, 0.547,
    0.57281, 0.574,   0.586,   0.5891,  0.59,    0.591,   0.6139,  0.625,
    0.625,   0.635,   0.645,   0.645,   0.657,   0.65793, 0.6753,  0.687,
    0.698,   0.7,     0.70692, 0.725,   0.72628, 0.72628, 0.752,   0.752,
    0.77714, 0.807,   0.809,   0.82,    0.82586, 0.85,    0.895,   0.895,
    0.9,     0.91,    0.93926, 0.945,   0.945,   0.995,   0.995,   1.0029,
    1.02,    1.04,    1.04,    1.0402,  1.05,    1.12091, 1.12091, 1.195,
    1.207,   1.2217,  1.232,   1.375,   1.3925,  1.44384, 1.46,    1.493,
    1.5,     1.53,    1.585,   1.585,   1.6,     1.68881, 1.69,    1.77,
    1.8,     1.869,   1.9,     1.99,    2.,      2.0199,  2.07,    2.077,
    2.11,    2.19,    2.3,     2.35,    2.5,     2.77,    2.9,     3.,
    3.05,    3.56,    3.63,    3.65,    3.67,    3.9,     4.,      5.,
    5.,      6.,      6.8001,  8.,      8.04,    8.8,     10.8,    11.7,
    12.8,    14.8,    16.,     16.2,    16.7,    29.,     32.1,    43.,
    50.,     60.,     70.,     100.,    140.,    147.,    175.,    200.,
    250.}

PDG data on pi+ p elastic cross section: momentum in lab frame.

Definition at line 669 of file parametrizations_data.h.

PIPLUSP_ELASTIC_SIG

const std::initializer_list<double> smash::PIPLUSP_ELASTIC_SIG

Initial value:

= {
    6.15,  15.8,  20.4,  140.9, 91.6,  71.6,  67.5,  57.3,  60.19, 46.6,  40.8,
    38.74, 30.6,  29.6,  30.59, 24.74, 24.31, 28.16, 19.83, 20.4,  20.64, 20.63,
    19.55, 15.75, 18.5,  17.2,  14.85, 16.16, 14.71, 15.32, 14.38, 12.2,  12.93,
    12.96, 12.17, 11.6,  11.06, 11.5,  10.62, 10.55, 8.82,  9.36,  8.97,  9.1,
    8.02,  8.38,  8.37,  8.14,  11.1,  9.3,   11.,   10.32, 9.87,  11.7,  11.15,
    12.05, 11.1,  12.37, 11.83, 10.3,  12.8,  14.54, 15.3,  14.3,  13.59, 12.6,
    12.3,  17.87, 16.5,  19.31, 18.73, 16.68, 13.8,  15.86, 16.7,  16.7,  15.05,
    13.04, 13.57, 12.46, 12.3,  11.81, 10.9,  9.84,  10.6,  9.1,   9.52,  9.46,
    9.44,  9.15,  8.45,  10.2,  6.9,   7.7,   8.3,   7.84,  7.02,  6.93,  7.07,
    6.88,  7.15,  6.5,   6.4,   5.85,  5.79,  5.33,  5.47,  4.9,   4.9,   5.02,
    4.75,  4.2,   4.54,  4.46,  4.21,  4.21,  3.98,  3.19,  3.37,  3.16,  3.29,
    3.1,   3.35,  3.3,   3.39,  3.24,  3.37,  3.17,  3.3}

PDG data on pi+ p elastic cross section: cross section.

Definition at line 689 of file parametrizations_data.h.

piplusp_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piplusp_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIPLUSP_ELASTIC_SIG data.

Definition at line 705 of file parametrizations_data.h.

PIPLUSP_SIGMAPLUSKPLUS_P_LAB

const std::initializer_list<double> smash::PIPLUSP_SIGMAPLUSKPLUS_P_LAB

Initial value:

= {
    1.041, 1.105, 1.111, 1.15,  1.157, 1.17,  1.195, 1.206, 1.218, 1.222, 1.265,
    1.28,  1.282, 1.328, 1.34,  1.377, 1.39,  1.41,  1.419, 1.43,  1.456, 1.49,
    1.508, 1.518, 1.549, 1.55,  1.58,  1.582, 1.614, 1.63,  1.68,  1.687, 1.7,
    1.712, 1.76,  1.77,  1.775, 1.808, 1.84,  1.879, 1.906, 1.95,  1.971, 1.997,
    2.067, 2.08,  2.099, 2.152, 2.197, 2.241, 2.291, 2.344, 2.379, 2.437, 2.473,
    2.77,  3.23,  3.71,  4.,    5.,    5.5,   7.,    10.3,  12.,   16.}

PDG data on pi+ p to Sigma+ K+ cross section: momentum in lab frame.

Definition at line 708 of file parametrizations_data.h.

PIPLUSP_SIGMAPLUSKPLUS_SIG

const std::initializer_list<double> smash::PIPLUSP_SIGMAPLUSKPLUS_SIG

Initial value:

= {
    0.034,  0.146,  0.144, 0.214,  0.248, 0.205, 0.24,  0.214, 0.242, 0.25,
    0.278,  0.34,   0.369, 0.412,  0.4,   0.467, 0.44,  0.49,  0.523, 0.51,
    0.662,  0.529,  0.692, 0.545,  0.604, 0.53,  0.53,  0.465, 0.494, 0.47,
    0.505,  0.434,  0.47,  0.436,  0.38,  0.415, 0.418, 0.393, 0.405, 0.332,
    0.37,   0.31,   0.338, 0.298,  0.3,   0.29,  0.28,  0.273, 0.26,  0.25,
    0.23,   0.242,  0.22,  0.217,  0.234, 0.165, 0.168, 0.104, 0.059, 0.059,
    0.0297, 0.0371, 0.02,  0.0202, 0.0143}

PDG data on pi+ p to Sigma+ K+ section: cross section.

Definition at line 717 of file parametrizations_data.h.

piplusp_sigmapluskplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piplusp_sigmapluskplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIPLUSP_SIGMAPLUSKPLUS_SIG data.

Definition at line 731 of file parametrizations_data.h.

PIPLUSP_RES_SQRTS

const std::initializer_list<double> smash::PIPLUSP_RES_SQRTS

Center-of-mass energy.

Definition at line 734 of file parametrizations_data.h.

PIPLUSP_RES_SIG

const std::initializer_list<double> smash::PIPLUSP_RES_SIG

Elastic π⁺N⁺ cross section contributions from decays.

These need to be subtracted from the interpolation of the PDG data on elastic cross sections. This data was generated using the SMASH analysis suite and should be updated when strange resonances are changed or added.

Definition at line 793 of file parametrizations_data.h.

piplusp_elastic_res_interpolation

std::unique_ptr<InterpolateDataSpline> smash::piplusp_elastic_res_interpolation = nullptr

static

A null interpolation that gets filled using the PIPLUSP_RES data.

Definition at line 855 of file parametrizations_data.h.

PIPLUSP_TOT_SQRTS

const std::initializer_list<double> smash::PIPLUSP_TOT_SQRTS

Center-of-mass energy.

Definition at line 858 of file parametrizations_data.h.

PIPLUSP_TOT_SIG

const std::initializer_list<double> smash::PIPLUSP_TOT_SIG

Total p π⁺ cross section parametrized from bottom-up SMASH-3.0, using the hadronic list from PDG2018.

Definition at line 922 of file parametrizations_data.h.

piplusp_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piplusp_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIPLUSP_TOT data.

Definition at line 993 of file parametrizations_data.h.

PIMINUSP_TOT_SQRTS

const std::initializer_list<double> smash::PIMINUSP_TOT_SQRTS

Center-of-mass energy.

Definition at line 996 of file parametrizations_data.h.

PIMINUSP_TOT_SIG

const std::initializer_list<double> smash::PIMINUSP_TOT_SIG

Total p π⁻ cross section parametrized from bottom-up SMASH-3.0, using the hadronic list from PDG2018.

Definition at line 1088 of file parametrizations_data.h.

piminusp_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::piminusp_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIMINUSP_TOT data.

Definition at line 1178 of file parametrizations_data.h.

PIPLUSPIMINUS_TOT_SQRTS

const std::initializer_list<double> smash::PIPLUSPIMINUS_TOT_SQRTS

Center-of-mass energy.

Definition at line 1181 of file parametrizations_data.h.

PIPLUSPIMINUS_TOT_SIG

const std::initializer_list<double> smash::PIPLUSPIMINUS_TOT_SIG

Total π⁺ π⁻ cross section parametrized from bottom-up SMASH-3.0, using the hadronic list from PDG2018.

Definition at line 1245 of file parametrizations_data.h.

pipluspiminus_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pipluspiminus_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIPLUSPIMINUS_TOT data.

Definition at line 1316 of file parametrizations_data.h.

PIZEROPIZERO_TOT_SQRTS

const std::initializer_list<double> smash::PIZEROPIZERO_TOT_SQRTS

Center-of-mass energy.

Definition at line 1319 of file parametrizations_data.h.

PIZEROPIZERO_TOT_SIG

const std::initializer_list<double> smash::PIZEROPIZERO_TOT_SIG

Total π⁰ π⁰ cross section parametrized from bottom-up SMASH-3.0 using the hadronic list from PDG2018.

Definition at line 1383 of file parametrizations_data.h.

pizeropizero_total_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::pizeropizero_total_interpolation = nullptr

static

An interpolation that gets lazily filled using the PIZEROPIZERO_TOT data.

Definition at line 1445 of file parametrizations_data.h.

DPI_SQRTS

const std::initializer_list<double> smash::DPI_SQRTS

Center-of-mass energy.

Definition at line 1448 of file parametrizations_data.h.

DPLUSPIPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSPIPLUS_ELASTIC_SIG

Elastic D⁺π⁺ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1512 of file parametrizations_data.h.

Dpluspiplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dpluspiplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSPIPLUS_ELASTIC data.

Definition at line 1574 of file parametrizations_data.h.

DPLUSPIMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSPIMINUS_ELASTIC_SIG

Elastic D⁺π⁻ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1580 of file parametrizations_data.h.

Dpluspiminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dpluspiminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSPIMINUS_ELASTIC data.

Definition at line 1654 of file parametrizations_data.h.

DPLUSPIMINUS_DZEROPIZERO_SIG

const std::initializer_list<double> smash::DPLUSPIMINUS_DZEROPIZERO_SIG

D⁺π⁻ -> D⁰π⁰ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1660 of file parametrizations_data.h.

Dpluspiminus_Dzeropizero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dpluspiminus_Dzeropizero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSPIMINUS_DZEROPIZERO data.

Definition at line 1735 of file parametrizations_data.h.

DPLUSPIZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSPIZERO_ELASTIC_SIG

Elastic D⁺π⁰ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1741 of file parametrizations_data.h.

Dpluspizero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dpluspizero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSPIZERO_ELASTIC data.

Definition at line 1813 of file parametrizations_data.h.

DPLUSPIZERO_DZEROPIPLUS_SIG

const std::initializer_list<double> smash::DPLUSPIZERO_DZEROPIPLUS_SIG

D⁺π⁰ -> D⁰π⁺ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1819 of file parametrizations_data.h.

Dpluspizero_Dzeropiplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dpluspizero_Dzeropiplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSPIZERO_DZEROPIPLUS data.

Definition at line 1894 of file parametrizations_data.h.

DZEROPIPLUS_DPLUSPIZERO_SIG

const std::initializer_list<double> smash::DZEROPIPLUS_DPLUSPIZERO_SIG

D⁰π⁺ -> D⁺π⁰ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1900 of file parametrizations_data.h.

Dzeropiplus_Dpluspizero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeropiplus_Dpluspizero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROPIPLUS_DPLUSPIZERO data.

Definition at line 1975 of file parametrizations_data.h.

DZEROPIPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROPIPLUS_ELASTIC_SIG

Elastic D⁰π⁺ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 1981 of file parametrizations_data.h.

Dzeropiplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeropiplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROPIPLUS_ELASTIC data.

Definition at line 2053 of file parametrizations_data.h.

DZEROPIMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROPIMINUS_ELASTIC_SIG

Elastic D⁰π⁻ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 2059 of file parametrizations_data.h.

Dzeropiminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeropiminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROPIMINUS_ELASTIC data.

Definition at line 2123 of file parametrizations_data.h.

DZEROPIZERO_DPLUSPIMINUS_SIG

const std::initializer_list<double> smash::DZEROPIZERO_DPLUSPIMINUS_SIG

D⁰π⁰ -> D⁺π⁻ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 2129 of file parametrizations_data.h.

Dzeropizero_Dpluspiminus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeropizero_Dpluspiminus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROPIZERO_DPLUSPIMINUS data.

Definition at line 2204 of file parametrizations_data.h.

DZEROPIZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROPIZERO_ELASTIC_SIG

Elastic D⁰π⁰ cross section Abreu:2011ic [1].

Data provided by Juan Torres-Rincon.

Definition at line 2210 of file parametrizations_data.h.

Dzeropizero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeropizero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROPIZERO_ELASTIC data.

Definition at line 2282 of file parametrizations_data.h.

DETA_SQRTS

const std::initializer_list<double> smash::DETA_SQRTS

Initial value:

= {
    2.4150010, 2.4158018, 2.4166026, 2.4174034, 2.4182042, 2.4190050, 2.4198058,
    2.4206066, 2.4214074, 2.4222082, 2.4230090, 2.4238098, 2.4246106, 2.4254114,
    2.4262122, 2.4270130, 2.4278138, 2.4286146, 2.4294154, 2.4302162, 2.4310170,
    2.4318178, 2.4326186, 2.4334194, 2.4342202, 2.4350210, 2.4358218, 2.4366226,
    2.4374234, 2.4382242, 2.4390250, 2.4398258, 2.4406266, 2.4414274, 2.4422282,
    2.4430290, 2.4438298, 2.4446306, 2.4454314, 2.4462322, 2.4470330, 2.4478338,
    2.4486346, 2.4494354, 2.4502362, 2.4510370, 2.4518378, 2.4526386, 2.4534394,
    2.4566426, 2.4574434, 2.4582442, 2.4590450, 2.4598458, 2.4606466, 2.4614474,
    2.4622482, 2.4630490, 2.4638498, 2.4646506, 2.4654515, 2.4662523, 2.4670531,
    2.4678539, 2.4686547, 2.4694555, 2.4702563, 2.4710571, 2.4718579, 2.4726587,
    2.4734595, 2.4742603, 2.4750611, 2.4758619, 2.4766627, 2.4774635, 2.4782643,
    2.4790651, 2.4798659, 2.4806667, 2.4814675, 2.4822683, 2.4830691, 2.4846707,
    2.4862723, 2.4878739, 2.4894755, 2.4910771, 2.4926787, 2.4942803, 2.4958819,
    2.4974835, 2.4990851, 2.5014875, 2.5030891, 2.5054915, 2.5078939, 2.5102963,
    2.5126987, 2.5151011, 2.5175035, 2.5199059, 2.5223083, 2.5255115, 2.5279139,
    2.5311171, 2.5343203, 2.5375235, 2.5407267, 2.5447307, 2.5479339, 2.5519379,
    2.5559419, 2.5599459, 2.5679540, 2.5767628, 2.5863724, 2.5967828, 2.6071932,
    2.6184044, 2.6296156, 2.6416276, 2.6544404, 2.6680541, 2.6824685, 2.6976837,
    2.7128989, 2.7289149, 2.7457317, 2.7593453, 2.7729590, 2.7873734, 2.8025886,
    2.8186046, 2.8346206, 2.8682543, 2.8874735, 2.9074935, 2.9499359, 2.9931792,
    3.0900761, 3.1141001, 3.1349209, 3.1589449, 3.1693554, 3.1797658, 3.1893754,
    3.1981842, 3.2069930, 3.2150010}

Center-of-mass energy.

Definition at line 2285 of file parametrizations_data.h.

DPLUSETA_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSETA_ELASTIC_SIG

Initial value:

= {
    0.0000000,  0.0000000,  0.0000000,  0.0000000,  6.4742523,  6.6000965,
    6.7437668,  6.9041576,  7.0808488,  7.2738254,  7.4833374,  7.7098247,
    7.9538737,  8.2161907,  8.4975866,  8.7989657,  9.1213203,  9.4657257,
    9.8333381,  10.2253922, 10.6432002, 11.0881500, 11.5617036, 12.0653946,
    12.6008254, 13.1696625, 13.7736310, 14.4145068, 15.0941072, 15.8142780,
    16.5768787, 17.3837627, 18.2367547, 19.1376227, 20.0880450, 21.0895709,
    22.1435754, 23.2512073, 24.4133289, 25.6304492, 26.9026494, 28.2295007,
    29.6099757, 31.0423557, 32.5241326, 34.0519113, 35.6213136, 37.2268885,
    38.8620326, 45.5229479, 47.1633878, 48.7677186, 50.3209461, 51.8072026,
    53.2099503, 54.5123739, 55.6988076, 56.7659851, 50.5094043, 45.7786026,
    42.9964930, 40.9588504, 39.3384512, 37.9902816, 36.8355190, 35.8259601,
    34.9297416, 34.1245981, 33.3943071, 32.7266568, 32.1122097, 31.5435136,
    31.0145760, 30.5205041, 30.0572492, 29.6214223, 29.2101578, 28.8210107,
    28.4518780, 28.1009378, 27.7666015, 27.4474753, 27.1423302, 26.5697452,
    26.0414671, 25.5515549, 25.0951580, 24.6682665, 24.2675293, 23.8901190,
    23.5336292, 23.1959961, 22.8754374, 22.4232788, 22.1390455, 21.7357041,
    21.3571277, 21.0005824, 20.6637496, 20.3446476, 20.0415706, 19.7530405,
    19.4777691, 19.1294337, 18.8809384, 18.5650106, 18.2650908, 17.9796679,
    17.7074311, 17.3839491, 17.1374104, 16.8431366, 16.5629483, 16.2955746,
    15.7949768, 15.2898440, 14.7846325, 14.2827933, 13.8209816, 13.3617228,
    12.9363365, 12.5129428, 12.0932555, 11.6786077, 11.2700133, 10.8682214,
    10.4928517, 10.1227166, 9.7583162,  9.4794811,  9.2136338,  8.9450001,
    8.6744607,  8.4027669,  8.1432199,  7.6327352,  7.3592812,  7.0865296,
    6.5422473,  6.0232201,  4.9024212,  4.6083391,  4.3363411,  3.9908315,
    3.8261851,  3.6497015,  3.4741994,  3.3007977,  3.1135253,  2.9296415}

Elastic D⁺η cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2313 of file parametrizations_data.h.

Dpluseta_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dpluseta_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSETA_ELASTIC data.

Definition at line 2342 of file parametrizations_data.h.

DZEROETA_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROETA_ELASTIC_SIG

Initial value:

= {
    6.4243488,  6.2508093,  6.2889037,  6.3686692,  6.4742523,  6.6000965,
    6.7437668,  6.9041576,  7.0808488,  7.2738254,  7.4833374,  7.7098247,
    7.9538737,  8.2161907,  8.4975866,  8.7989657,  9.1213203,  9.4657257,
    9.8333381,  10.2253922, 10.6432002, 11.0881500, 11.5617036, 12.0653946,
    12.6008254, 13.1696625, 13.7736310, 14.4145068, 15.0941072, 15.8142780,
    16.5768787, 17.3837627, 18.2367547, 19.1376227, 20.0880450, 21.0895709,
    22.1435754, 23.2512073, 24.4133289, 25.6304492, 26.9026494, 28.2295007,
    29.6099757, 31.0423557, 32.5241326, 34.0519113, 35.6213136, 37.2268885,
    38.8620326, 45.5229479, 47.1633878, 48.7677186, 50.3209461, 51.8072026,
    53.2099503, 54.5123739, 55.6988076, 56.7659851, 50.5094043, 45.7786026,
    42.9964930, 40.9588504, 39.3384512, 37.9902816, 36.8355190, 35.8259601,
    34.9297416, 34.1245981, 33.3943071, 32.7266568, 32.1122097, 31.5435136,
    31.0145760, 30.5205041, 30.0572492, 29.6214223, 29.2101578, 28.8210107,
    28.4518780, 28.1009378, 27.7666015, 27.4474753, 27.1423302, 26.5697452,
    26.0414671, 25.5515549, 25.0951580, 24.6682665, 24.2675293, 23.8901190,
    23.5336292, 23.1959961, 22.8754374, 22.4232788, 22.1390455, 21.7357041,
    21.3571277, 21.0005824, 20.6637496, 20.3446476, 20.0415706, 19.7530405,
    19.4777691, 19.1294337, 18.8809384, 18.5650106, 18.2650908, 17.9796679,
    17.7074311, 17.3839491, 17.1374104, 16.8431366, 16.5629483, 16.2955746,
    15.7949768, 15.2898440, 14.7846325, 14.2827933, 13.8209816, 13.3617228,
    12.9363365, 12.5129428, 12.0932555, 11.6786077, 11.2700133, 10.8682214,
    10.4928517, 10.1227166, 9.7583162,  9.4794811,  9.2136338,  8.9450001,
    8.6744607,  8.4027669,  8.1432199,  7.6327352,  7.3592812,  7.0865296,
    6.5422473,  6.0232201,  4.9024212,  4.6083391,  4.3363411,  3.9908315,
    3.8261851,  3.6497015,  3.4741994,  3.3007977,  3.1135253,  2.9296415}

Elastic D⁰η cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2348 of file parametrizations_data.h.

Dzeroeta_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeroeta_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROETA_ELASTIC data.

Definition at line 2377 of file parametrizations_data.h.

DKAON_SQRTS

const std::initializer_list<double> smash::DKAON_SQRTS

Center-of-mass energy.

Definition at line 2380 of file parametrizations_data.h.

DPLUSKPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSKPLUS_ELASTIC_SIG

Elastic D⁺K⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2438 of file parametrizations_data.h.

DplusKplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusKplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSKPLUS_ELASTIC data.

Definition at line 2503 of file parametrizations_data.h.

DPLUSKMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSKMINUS_ELASTIC_SIG

Elastic D⁺K⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2509 of file parametrizations_data.h.

DplusKminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusKminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSKMINUS_ELASTIC data.

Definition at line 2574 of file parametrizations_data.h.

DPLUSKMINUS_DZEROKBARZERO_SIG

const std::initializer_list<double> smash::DPLUSKMINUS_DZEROKBARZERO_SIG

D⁺K⁻ -> D⁰K̄⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2580 of file parametrizations_data.h.

DplusKminus_DzeroKbarzero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusKminus_DzeroKbarzero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSKMINUS_DZEROKBARZERO data.

Definition at line 2648 of file parametrizations_data.h.

DPLUSKZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSKZERO_ELASTIC_SIG

Elastic D⁺K⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2654 of file parametrizations_data.h.

DplusKzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusKzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSKZERO_ELASTIC data.

Definition at line 2719 of file parametrizations_data.h.

DPLUSKZERO_DZEROKPLUS_SIG

const std::initializer_list<double> smash::DPLUSKZERO_DZEROKPLUS_SIG

D⁺K⁰ -> D⁰K⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2725 of file parametrizations_data.h.

DplusKzero_DzeroKplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusKzero_DzeroKplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSKZERO_DZEROKPLUS data.

Definition at line 2793 of file parametrizations_data.h.

DPLUSKBARZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSKBARZERO_ELASTIC_SIG

Elastic D⁺K̄⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2799 of file parametrizations_data.h.

DplusKbarzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusKbarzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSKBARZERO_ELASTIC data.

Definition at line 2858 of file parametrizations_data.h.

DZEROKPLUS_DPLUSKZERO_SIG

const std::initializer_list<double> smash::DZEROKPLUS_DPLUSKZERO_SIG

D⁰K⁺ -> D⁺K⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2864 of file parametrizations_data.h.

DzeroKplus_DplusKzero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroKplus_DplusKzero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROKPLUS_DPLUSKZERO data.

Definition at line 2923 of file parametrizations_data.h.

DZEROKPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROKPLUS_ELASTIC_SIG

Elastic D⁰K⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 2929 of file parametrizations_data.h.

DzeroKplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroKplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROKPLUS_ELASTIC data.

Definition at line 2994 of file parametrizations_data.h.

DZEROKMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROKMINUS_ELASTIC_SIG

Elastic D⁰K⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 3000 of file parametrizations_data.h.

DzeroKminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroKminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROKMINUS_ELASTIC data.

Definition at line 3056 of file parametrizations_data.h.

DZEROKZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROKZERO_ELASTIC_SIG

Elastic D⁰K⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 3062 of file parametrizations_data.h.

DzeroKzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroKzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROKZERO_ELASTIC data.

Definition at line 3127 of file parametrizations_data.h.

DZEROKBARZERO_DPLUSKMINUS_SIG

const std::initializer_list<double> smash::DZEROKBARZERO_DPLUSKMINUS_SIG

D⁰K̄⁰ -> D⁺K⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 3133 of file parametrizations_data.h.

DzeroKbarzero_DplusKminus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroKbarzero_DplusKminus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROKBARZERO_DPLUSKMINUS data.

Definition at line 3201 of file parametrizations_data.h.

DZEROKBARZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROKBARZERO_ELASTIC_SIG

Elastic D⁰K̄⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 3207 of file parametrizations_data.h.

DzeroKbarzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroKbarzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROKBARZERO_ELASTIC data.

Definition at line 3275 of file parametrizations_data.h.

DSTARPI_SQRTS

const std::initializer_list<double> smash::DSTARPI_SQRTS

Center-of-mass energy.

Definition at line 3278 of file parametrizations_data.h.

DSTARPLUSPIPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSPIPLUS_ELASTIC_SIG

Elastic D*(2010)⁺π⁺ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3336 of file parametrizations_data.h.

Dstarpluspiplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarpluspiplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSPIPLUS_ELASTIC data.

Definition at line 3395 of file parametrizations_data.h.

DSTARPLUSPIMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSPIMINUS_ELASTIC_SIG

Elastic D*(2010)⁺π⁻ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3401 of file parametrizations_data.h.

Dstarpluspiminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarpluspiminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSPIMINUS_ELASTIC data.

Definition at line 3469 of file parametrizations_data.h.

DSTARPLUSPIMINUS_DSTARZEROPIZERO_SIG

const std::initializer_list<double> smash::DSTARPLUSPIMINUS_DSTARZEROPIZERO_SIG

D*(2010)⁺π⁻ -> D*(2007)⁰π⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3475 of file parametrizations_data.h.

Dstarpluspiminus_Dstarzeropizero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarpluspiminus_Dstarzeropizero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSPIMINUS_DSTARZEROPIZERO data.

Definition at line 3543 of file parametrizations_data.h.

DSTARPLUSPIZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSPIZERO_ELASTIC_SIG

Elastic D*(2010)⁺π⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3549 of file parametrizations_data.h.

Dstarpluspizero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarpluspizero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSPIZERO_ELASTIC data.

Definition at line 3608 of file parametrizations_data.h.

DSTARPLUSPIZERO_DSTARZEROPIPLUS_SIG

const std::initializer_list<double> smash::DSTARPLUSPIZERO_DSTARZEROPIPLUS_SIG

D*(2010)⁺π⁰ -> D*(2007)⁰π⁺ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3614 of file parametrizations_data.h.

Dstarpluspizero_Dstarzeropiplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarpluspizero_Dstarzeropiplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSPIZERO_DSTARZEROPIPLUS data.

Definition at line 3682 of file parametrizations_data.h.

DSTARZEROPIPLUS_DSTARPLUSPIZERO_SIG

const std::initializer_list<double> smash::DSTARZEROPIPLUS_DSTARPLUSPIZERO_SIG

D*(2007)⁰π⁺ -> D*(2010)⁺π⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3688 of file parametrizations_data.h.

Dstarzeropiplus_Dstarpluspizero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarzeropiplus_Dstarpluspizero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROPIPLUS_DSTARPLUSPIZERO data.

Definition at line 3756 of file parametrizations_data.h.

DSTARZEROPIPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROPIPLUS_ELASTIC_SIG

Elastic D*(2007)⁰π⁺ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3762 of file parametrizations_data.h.

Dstarzeropiplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarzeropiplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROPIPLUS_ELASTIC data.

Definition at line 3830 of file parametrizations_data.h.

DSTARZEROPIMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROPIMINUS_ELASTIC_SIG

Elastic D*(2007)⁰π⁻ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3836 of file parametrizations_data.h.

Dstarzeropiminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarzeropiminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROPIMINUS_ELASTIC data.

Definition at line 3895 of file parametrizations_data.h.

DSTARZEROPIZERO_DSTARPLUSPIMINUS_SIG

const std::initializer_list<double> smash::DSTARZEROPIZERO_DSTARPLUSPIMINUS_SIG

D*(2007)⁰π⁰ -> D*(2010)⁺π⁻ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3901 of file parametrizations_data.h.

Dstarzeropizero_Dstarpluspiminus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarzeropizero_Dstarpluspiminus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROPIZERO_DSTARPLUSPIMINUS data.

Definition at line 3969 of file parametrizations_data.h.

DSTARZEROPIZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROPIZERO_ELASTIC_SIG

Elastic D*(2007)⁰π⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 3975 of file parametrizations_data.h.

Dstarzeropizero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarzeropizero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROPIZERO_ELASTIC data.

Definition at line 4034 of file parametrizations_data.h.

DSTARETA_SQRTS

const std::initializer_list<double> smash::DSTARETA_SQRTS

Initial value:

= {
    2.5571810, 2.5579818, 2.5587826, 2.5595834, 2.5603842, 2.5611850, 2.5619858,
    2.5627866, 2.5635874, 2.5643882, 2.5651890, 2.5659898, 2.5667906, 2.5675914,
    2.5683922, 2.5691930, 2.5699938, 2.5707946, 2.5715954, 2.5723962, 2.5731970,
    2.5747986, 2.5780018, 2.5796034, 2.5804042, 2.5812050, 2.5820058, 2.5828066,
    2.5836074, 2.5844082, 2.5852090, 2.5860098, 2.5868106, 2.5876114, 2.5884122,
    2.5892130, 2.5900138, 2.5908146, 2.5916154, 2.5924162, 2.5932170, 2.5940178,
    2.5956194, 2.6004242, 2.6052290, 2.6060298, 2.6068306, 2.6076315, 2.6084323,
    2.6092331, 2.6100339, 2.6108347, 2.6116355, 2.6124363, 2.6132371, 2.6140379,
    2.6148387, 2.6156395, 2.6164403, 2.6172411, 2.6180419, 2.6188427, 2.6196435,
    2.6204443, 2.6220459, 2.6228467, 2.6244483, 2.6252491, 2.6268507, 2.6276515,
    2.6292531, 2.6308547, 2.6324563, 2.6340579, 2.6356595, 2.6372611, 2.6388627,
    2.6420659, 2.6436675, 2.6460699, 2.6500739, 2.6524763, 2.6548787, 2.6572811,
    2.6604843, 2.6660899, 2.6724963, 2.6789027, 2.6861099, 2.6941179, 2.7021259,
    2.7109348, 2.7205444, 2.7309548, 2.7421660, 2.7541780, 2.7669908, 2.7806044,
    2.7950188, 2.8110349, 2.8358597, 2.8622861, 2.8919157, 2.9247486, 2.9543782,
    2.9880118, 3.1201440, 3.1473712, 3.1713952, 3.1914152, 3.2106345, 3.2298537,
    3.2666905, 3.2763001, 3.2843081, 3.2939177, 3.3027265, 3.3115354, 3.3371610,
    3.3459698, 3.3571810}

Center-of-mass energy.

Definition at line 4037 of file parametrizations_data.h.

DSTARPLUSETA_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSETA_ELASTIC_SIG

Initial value:

= {
    0.0000000,   0.0000000,   26.3688311,  28.1035338,  29.9890301,
    32.0269018,  34.2232570,  36.5862809,  39.1253089,  41.8503462,
    44.7717335,  47.8998446,  51.2447656,  54.8159242,  58.6216511,
    62.6686560,  66.9614095,  71.5014224,  76.2864263,  81.3094630,
    86.5579080,  97.6461980,  121.1253149, 132.5820100, 137.9718789,
    143.0214642, 147.6453408, 151.7629608, 155.3024939, 158.2044084,
    160.4244472, 161.9357005, 162.7295763, 162.8155931, 162.2200635,
    160.9838512, 159.1594740, 156.8078593, 153.9950502, 150.7891145,
    147.2574412, 143.4645319, 135.3290389, 109.5962236, 84.7401955,
    80.3391895,  75.2141638,  63.7432560,  58.8782249,  55.6688406,
    53.1460164,  51.0359482,  49.2116244,  47.6008756,  46.1576787,
    44.8503961,  43.6560985,  42.5575038,  41.5411857,  40.5964604,
    39.7146581,  38.8886286,  38.1123938,  37.3808968,  36.0354289,
    35.4144971,  34.2620180,  33.7257735,  32.7234304,  32.2540051,
    31.3715392,  30.5562905,  29.8001457,  29.0963176,  28.4390730,
    27.8235276,  27.2454878,  26.1878960,  25.7024323,  25.0214508,
    23.9957543,  23.4367933,  22.9145431,  22.4251700,  21.8181696,
    20.8631785,  19.9091514,  19.0724675,  18.2434575,  17.4340832,
    16.7191314,  16.0204788,  15.3430975,  14.6898231,  14.0618917,
    13.4593968,  12.8816556,  12.3274892,  11.7954277,  11.2581747,
    10.5145704,  9.8152528,   9.1165820,   8.4216547,   7.8481395,
    7.2419491,   5.0085868,   4.4991447,   4.0015220,   3.5372793,
    3.0372060,   2.4780772,   1.3262217,   1.0644637,   0.8845032,
    0.7300068,   0.6539350,   0.6338144,   0.6579901,   0.6081938,
    0.4931145}

Elastic D*(2010)⁺η cross section. Data provided by Juan Torres-Rincon.

Definition at line 4058 of file parametrizations_data.h.

Dstarpluseta_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarpluseta_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSETA_ELASTIC data.

Definition at line 4089 of file parametrizations_data.h.

DSTARZEROETA_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROETA_ELASTIC_SIG

Initial value:

= {
    23.6182447,  24.7976453,  26.3688311,  28.1035338,  29.9890301,
    32.0269018,  34.2232570,  36.5862809,  39.1253089,  41.8503462,
    44.7717335,  47.8998446,  51.2447656,  54.8159242,  58.6216511,
    62.6686560,  66.9614095,  71.5014224,  76.2864263,  81.3094630,
    86.5579080,  97.6461980,  121.1253149, 132.5820100, 137.9718789,
    143.0214642, 147.6453408, 151.7629608, 155.3024939, 158.2044084,
    160.4244472, 161.9357005, 162.7295763, 162.8155931, 162.2200635,
    160.9838512, 159.1594740, 156.8078593, 153.9950502, 150.7891145,
    147.2574412, 143.4645319, 135.3290389, 109.5962236, 84.7401955,
    80.3391895,  75.2141638,  63.7432560,  58.8782249,  55.6688406,
    53.1460164,  51.0359482,  49.2116244,  47.6008756,  46.1576787,
    44.8503961,  43.6560985,  42.5575038,  41.5411857,  40.5964604,
    39.7146581,  38.8886286,  38.1123938,  37.3808968,  36.0354289,
    35.4144971,  34.2620180,  33.7257735,  32.7234304,  32.2540051,
    31.3715392,  30.5562905,  29.8001457,  29.0963176,  28.4390730,
    27.8235276,  27.2454878,  26.1878960,  25.7024323,  25.0214508,
    23.9957543,  23.4367933,  22.9145431,  22.4251700,  21.8181696,
    20.8631785,  19.9091514,  19.0724675,  18.2434575,  17.4340832,
    16.7191314,  16.0204788,  15.3430975,  14.6898231,  14.0618917,
    13.4593968,  12.8816556,  12.3274892,  11.7954277,  11.2581747,
    10.5145704,  9.8152528,   9.1165820,   8.4216547,   7.8481395,
    7.2419491,   5.0085868,   4.4991447,   4.0015220,   3.5372793,
    3.0372060,   2.4780772,   1.3262217,   1.0644637,   0.8845032,
    0.7300068,   0.6539350,   0.6338144,   0.6579901,   0.6081938,
    0.4931145}

Elastic D*(2007)⁰η cross section. Data provided by Juan Torres-Rincon.

Definition at line 4092 of file parametrizations_data.h.

Dstarzeroeta_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dstarzeroeta_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROETA_ELASTIC data.

Definition at line 4123 of file parametrizations_data.h.

DSTARKAON_SQRTS

const std::initializer_list<double> smash::DSTARKAON_SQRTS

Center-of-mass energy.

Definition at line 4126 of file parametrizations_data.h.

DSTARPLUSKPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSKPLUS_ELASTIC_SIG

Elastic D*(2010)⁺K⁺ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4192 of file parametrizations_data.h.

DstarplusKplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarplusKplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSKPLUS_ELASTIC data.

Definition at line 4269 of file parametrizations_data.h.

DSTARPLUSKMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSKMINUS_ELASTIC_SIG

Elastic D*(2010)⁺K⁻ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4275 of file parametrizations_data.h.

DstarplusKminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarplusKminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSKMINUS_ELASTIC data.

Definition at line 4352 of file parametrizations_data.h.

DSTARPLUSKMINUS_DSTARZEROKBARZERO_SIG

const std::initializer_list<double> smash::DSTARPLUSKMINUS_DSTARZEROKBARZERO_SIG

D*(2010)⁺K⁻ -> D*(2007)⁰K̄⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4358 of file parametrizations_data.h.

DstarplusKminus_DstarzeroKbarzero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarplusKminus_DstarzeroKbarzero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSKMINUS_DSTARZEROKBARZERO data.

Definition at line 4435 of file parametrizations_data.h.

DSTARPLUSKZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSKZERO_ELASTIC_SIG

Elastic D*(2010)⁺K⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4441 of file parametrizations_data.h.

DstarplusKzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarplusKzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSKZERO_ELASTIC data.

Definition at line 4518 of file parametrizations_data.h.

DSTARPLUSKZERO_DSTARZEROKPLUS_SIG

const std::initializer_list<double> smash::DSTARPLUSKZERO_DSTARZEROKPLUS_SIG

D*(2010)⁺K⁰ -> D*(2007)⁰K⁺ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4524 of file parametrizations_data.h.

DstarplusKzero_DstarzeroKplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarplusKzero_DstarzeroKplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSKZERO_DSTARZEROKPLUS data.

Definition at line 4601 of file parametrizations_data.h.

DSTARPLUSKBARZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARPLUSKBARZERO_ELASTIC_SIG

Elastic D*(2010)⁺K̄⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4607 of file parametrizations_data.h.

DstarplusKbarzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarplusKbarzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARPLUSKBARZERO_ELASTIC data.

Definition at line 4674 of file parametrizations_data.h.

DSTARZEROKPLUS_DSTARPLUSKZERO_SIG

const std::initializer_list<double> smash::DSTARZEROKPLUS_DSTARPLUSKZERO_SIG

D*(2007)⁰K⁺ -> D*(2010)⁺K⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4680 of file parametrizations_data.h.

DstarzeroKplus_DstarplusKzero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarzeroKplus_DstarplusKzero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROKPLUS_DSTARPLUSKZERO data.

Definition at line 4747 of file parametrizations_data.h.

DSTARZEROKPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROKPLUS_ELASTIC_SIG

Elastic D*(2007)⁰K⁺ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4753 of file parametrizations_data.h.

DstarzeroKplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarzeroKplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROKPLUS_ELASTIC data.

Definition at line 4830 of file parametrizations_data.h.

DSTARZEROKMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROKMINUS_ELASTIC_SIG

Elastic D*(2007)⁰K⁻ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4836 of file parametrizations_data.h.

DstarzeroKminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarzeroKminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROKMINUS_ELASTIC data.

Definition at line 4903 of file parametrizations_data.h.

DSTARZEROKZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROKZERO_ELASTIC_SIG

Elastic D*(2007)⁰K⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4909 of file parametrizations_data.h.

DstarzeroKzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarzeroKzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROKZERO_ELASTIC data.

Definition at line 4986 of file parametrizations_data.h.

DSTARZEROKBARZERO_DSTARPLUSKMINUS_SIG

const std::initializer_list<double> smash::DSTARZEROKBARZERO_DSTARPLUSKMINUS_SIG

D*(2007)⁰K̄⁰ -> D*(2010)⁺K⁻ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 4992 of file parametrizations_data.h.

DstarzeroKbarzero_DstarplusKminus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarzeroKbarzero_DstarplusKminus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROKBARZERO_DSTARPLUSKMINUS data.

Definition at line 5069 of file parametrizations_data.h.

DSTARZEROKBARZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DSTARZEROKBARZERO_ELASTIC_SIG

Elastic D*(2007)⁰K̄⁰ cross section.

Data provided by Juan Torres-Rincon, closest reference Song:2015sfa [62].

Definition at line 5075 of file parametrizations_data.h.

DstarzeroKbarzero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DstarzeroKbarzero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DSTARZEROKBARZERO_ELASTIC data.

Definition at line 5152 of file parametrizations_data.h.

DN_SQRTS

const std::initializer_list<double> smash::DN_SQRTS

Center-of-mass energy.

Definition at line 5155 of file parametrizations_data.h.

DPLUSN_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSN_ELASTIC_SIG

Elastic D⁺n cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5235 of file parametrizations_data.h.

Dplusn_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dplusn_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSN_ELASTIC data.

Definition at line 5325 of file parametrizations_data.h.

DPLUSN_DZEROP_SIG

const std::initializer_list<double> smash::DPLUSN_DZEROP_SIG

D⁺n -> D⁰p cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5331 of file parametrizations_data.h.

Dplusn_Dzerop_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dplusn_Dzerop_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSN_DZEROP data.

Definition at line 5421 of file parametrizations_data.h.

DPLUSP_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSP_ELASTIC_SIG

Elastic D⁺p cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5427 of file parametrizations_data.h.

Dplusp_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dplusp_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSP_ELASTIC data.

Definition at line 5517 of file parametrizations_data.h.

DZERON_ELASTIC_SIG

const std::initializer_list<double> smash::DZERON_ELASTIC_SIG

Elastic D⁰n cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5523 of file parametrizations_data.h.

Dzeron_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzeron_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERON_ELASTIC data.

Definition at line 5613 of file parametrizations_data.h.

DZEROP_DPLUSN_SIG

const std::initializer_list<double> smash::DZEROP_DPLUSN_SIG

D⁰p -> D⁺n cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5619 of file parametrizations_data.h.

Dzerop_Dplusn_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzerop_Dplusn_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROP_DPLUSN data.

Definition at line 5709 of file parametrizations_data.h.

DZEROP_ELASTIC_SIG

const std::initializer_list<double> smash::DZEROP_ELASTIC_SIG

Elastic D⁰p cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5715 of file parametrizations_data.h.

Dzerop_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dzerop_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZEROP_ELASTIC data.

Definition at line 5805 of file parametrizations_data.h.

DBARN_SQRTS

const std::initializer_list<double> smash::DBARN_SQRTS

Center-of-mass energy.

Definition at line 5808 of file parametrizations_data.h.

DMINUSN_ELASTIC_SIG

const std::initializer_list<double> smash::DMINUSN_ELASTIC_SIG

Elastic D⁻n cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5858 of file parametrizations_data.h.

Dminusn_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dminusn_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSN_ELASTIC data.

Definition at line 5913 of file parametrizations_data.h.

DMINUSP_ELASTIC_SIG

const std::initializer_list<double> smash::DMINUSP_ELASTIC_SIG

Elastic D⁻p cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5919 of file parametrizations_data.h.

Dminusp_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dminusp_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSP_ELASTIC data.

Definition at line 5985 of file parametrizations_data.h.

DMINUSP_DBARZERON_SIG

const std::initializer_list<double> smash::DMINUSP_DBARZERON_SIG

D⁻p -> D̄⁰n cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 5991 of file parametrizations_data.h.

Dminusp_Dbarzeron_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dminusp_Dbarzeron_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSP_DBARZERON data.

Definition at line 6057 of file parametrizations_data.h.

DBARZERON_DMINUSP_SIG

const std::initializer_list<double> smash::DBARZERON_DMINUSP_SIG

D̄⁰n -> D⁻p cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6063 of file parametrizations_data.h.

Dbarzeron_Dminusp_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dbarzeron_Dminusp_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERON_DMINUSP data.

Definition at line 6129 of file parametrizations_data.h.

DBARZERON_ELASTIC_SIG

const std::initializer_list<double> smash::DBARZERON_ELASTIC_SIG

Elastic D̄⁰n cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6135 of file parametrizations_data.h.

Dbarzeron_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dbarzeron_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERON_ELASTIC data.

Definition at line 6201 of file parametrizations_data.h.

DBARZEROP_ELASTIC_SIG

const std::initializer_list<double> smash::DBARZEROP_ELASTIC_SIG

Elastic D̄⁰p cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6207 of file parametrizations_data.h.

Dbarzerop_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::Dbarzerop_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZEROP_ELASTIC data.

Definition at line 6262 of file parametrizations_data.h.

DDELTA_SQRTS

const std::initializer_list<double> smash::DDELTA_SQRTS

Center-of-mass energy.

Definition at line 6265 of file parametrizations_data.h.

DPLUSDELTAPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSDELTAPLUS_ELASTIC_SIG

Elastic D⁺Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6349 of file parametrizations_data.h.

DplusDeltaplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltaplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAPLUS_ELASTIC data.

Definition at line 6447 of file parametrizations_data.h.

DPLUSDELTAPLUS_DZERODELTAPLUSPLUS_SIG

const std::initializer_list<double> smash::DPLUSDELTAPLUS_DZERODELTAPLUSPLUS_SIG

D⁺Δ⁺ -> D⁰Δ⁺⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6453 of file parametrizations_data.h.

DplusDeltaplus_DzeroDeltaplusplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltaplus_DzeroDeltaplusplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAPLUS_DZERODELTAPLUSPLUS data.

Definition at line 6538 of file parametrizations_data.h.

DPLUSDELTAPLUSPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSDELTAPLUSPLUS_ELASTIC_SIG

Elastic D⁺Δ⁺⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6544 of file parametrizations_data.h.

DplusDeltaplusplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltaplusplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAPLUSPLUS_ELASTIC data.

Definition at line 6660 of file parametrizations_data.h.

DPLUSDELTAMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSDELTAMINUS_ELASTIC_SIG

Elastic D⁺Δ⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6666 of file parametrizations_data.h.

DplusDeltaminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltaminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAMINUS_ELASTIC data.

Definition at line 6764 of file parametrizations_data.h.

DPLUSDELTAMINUS_DZERODELTAZERO_SIG

const std::initializer_list<double> smash::DPLUSDELTAMINUS_DZERODELTAZERO_SIG

D⁺Δ⁻ -> D⁰Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6770 of file parametrizations_data.h.

DplusDeltaminus_DzeroDeltazero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltaminus_DzeroDeltazero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAMINUS_DZERODELTAZERO data.

Definition at line 6855 of file parametrizations_data.h.

DPLUSDELTAZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DPLUSDELTAZERO_ELASTIC_SIG

Elastic D⁺Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6861 of file parametrizations_data.h.

DplusDeltazero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltazero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAZERO_ELASTIC data.

Definition at line 6959 of file parametrizations_data.h.

DPLUSDELTAZERO_DZERODELTAPLUS_SIG

const std::initializer_list<double> smash::DPLUSDELTAZERO_DZERODELTAPLUS_SIG

D⁺Δ⁰ -> D⁰Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 6965 of file parametrizations_data.h.

DplusDeltazero_DzeroDeltaplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DplusDeltazero_DzeroDeltaplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DPLUSDELTAZERO_DZERODELTAPLUS data.

Definition at line 7050 of file parametrizations_data.h.

DZERODELTAPLUS_DPLUSDELTAZERO_SIG

const std::initializer_list<double> smash::DZERODELTAPLUS_DPLUSDELTAZERO_SIG

D⁰Δ⁺ -> D⁺Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7056 of file parametrizations_data.h.

DzeroDeltaplus_DplusDeltazero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltaplus_DplusDeltazero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAPLUS_DPLUSDELTAZERO data.

Definition at line 7141 of file parametrizations_data.h.

DZERODELTAPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZERODELTAPLUS_ELASTIC_SIG

Elastic D⁰Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7147 of file parametrizations_data.h.

DzeroDeltaplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltaplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAPLUS_ELASTIC data.

Definition at line 7245 of file parametrizations_data.h.

DZERODELTAPLUSPLUS_DPLUSDELTAPLUS_SIG

const std::initializer_list<double> smash::DZERODELTAPLUSPLUS_DPLUSDELTAPLUS_SIG

D⁰Δ⁺⁺ -> D⁺Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7251 of file parametrizations_data.h.

DzeroDeltaplusplus_DplusDeltaplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltaplusplus_DplusDeltaplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAPLUSPLUS_DPLUSDELTAPLUS data.

Definition at line 7336 of file parametrizations_data.h.

DZERODELTAPLUSPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZERODELTAPLUSPLUS_ELASTIC_SIG

Elastic D⁰Δ⁺⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7342 of file parametrizations_data.h.

DzeroDeltaplusplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltaplusplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAPLUSPLUS_ELASTIC data.

Definition at line 7440 of file parametrizations_data.h.

DZERODELTAMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DZERODELTAMINUS_ELASTIC_SIG

Elastic D⁰Δ⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7446 of file parametrizations_data.h.

DzeroDeltaminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltaminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAMINUS_ELASTIC data.

Definition at line 7562 of file parametrizations_data.h.

DZERODELTAZERO_DPLUSDELTAMINUS_SIG

const std::initializer_list<double> smash::DZERODELTAZERO_DPLUSDELTAMINUS_SIG

D⁰Δ⁰ -> D⁺Δ⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7568 of file parametrizations_data.h.

DzeroDeltazero_DplusDeltaminus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltazero_DplusDeltaminus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAZERO_DPLUSDELTAMINUS data.

Definition at line 7653 of file parametrizations_data.h.

DZERODELTAZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DZERODELTAZERO_ELASTIC_SIG

Elastic D⁰Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7659 of file parametrizations_data.h.

DzeroDeltazero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DzeroDeltazero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DZERODELTAZERO_ELASTIC data.

Definition at line 7757 of file parametrizations_data.h.

DBARDELTA_SQRTS

const std::initializer_list<double> smash::DBARDELTA_SQRTS

Center-of-mass energy.

Definition at line 7760 of file parametrizations_data.h.

DMINUSDELTAPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DMINUSDELTAPLUS_ELASTIC_SIG

Elastic D⁻Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7803 of file parametrizations_data.h.

DminusDeltaplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltaplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAPLUS_ELASTIC data.

Definition at line 7861 of file parametrizations_data.h.

DMINUSDELTAPLUS_DBARZERODELTAZERO_SIG

const std::initializer_list<double> smash::DMINUSDELTAPLUS_DBARZERODELTAZERO_SIG

D⁻Δ⁺ -> D̄⁰Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7867 of file parametrizations_data.h.

DminusDeltaplus_DbarzeroDeltazero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltaplus_DbarzeroDeltazero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAPLUS_DBARZERODELTAZERO data.

Definition at line 7917 of file parametrizations_data.h.

DMINUSDELTAPLUSPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DMINUSDELTAPLUSPLUS_ELASTIC_SIG

Elastic D⁻Δ⁺⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7923 of file parametrizations_data.h.

DminusDeltaplusplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltaplusplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAPLUSPLUS_ELASTIC data.

Definition at line 7981 of file parametrizations_data.h.

DMINUSDELTAPLUSPLUS_DBARZERODELTAPLUS_SIG

const std::initializer_list<double> smash::DMINUSDELTAPLUSPLUS_DBARZERODELTAPLUS_SIG

D⁻Δ⁺⁺ -> D̄⁰Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 7987 of file parametrizations_data.h.

DminusDeltaplusplus_DbarzeroDeltaplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltaplusplus_DbarzeroDeltaplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAPLUSPLUS_DBARZERODELTAPLUS data.

Definition at line 8037 of file parametrizations_data.h.

DMINUSDELTAMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DMINUSDELTAMINUS_ELASTIC_SIG

Elastic D⁻Δ⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8043 of file parametrizations_data.h.

DminusDeltaminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltaminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAMINUS_ELASTIC data.

Definition at line 8101 of file parametrizations_data.h.

DMINUSDELTAZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DMINUSDELTAZERO_ELASTIC_SIG

Elastic D⁻Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8107 of file parametrizations_data.h.

DminusDeltazero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltazero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAZERO_ELASTIC data.

Definition at line 8165 of file parametrizations_data.h.

DMINUSDELTAZERO_DBARZERODELTAMINUS_SIG

const std::initializer_list<double> smash::DMINUSDELTAZERO_DBARZERODELTAMINUS_SIG

D⁻Δ⁰ -> D̄⁰Δ⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8171 of file parametrizations_data.h.

DminusDeltazero_DbarzeroDeltaminus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DminusDeltazero_DbarzeroDeltaminus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DMINUSDELTAZERO_DBARZERODELTAMINUS data.

Definition at line 8221 of file parametrizations_data.h.

DBARZERODELTAPLUS_DMINUSDELTAPLUSPLUS_SIG

const std::initializer_list<double> smash::DBARZERODELTAPLUS_DMINUSDELTAPLUSPLUS_SIG

D̄⁰Δ⁺ -> D⁻Δ⁺⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8227 of file parametrizations_data.h.

DbarzeroDeltaplus_DminusDeltaplusplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltaplus_DminusDeltaplusplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAPLUS_DMINUSDELTAPLUSPLUS data.

Definition at line 8277 of file parametrizations_data.h.

DBARZERODELTAPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DBARZERODELTAPLUS_ELASTIC_SIG

Elastic D̄⁰Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8283 of file parametrizations_data.h.

DbarzeroDeltaplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltaplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAPLUS_ELASTIC data.

Definition at line 8341 of file parametrizations_data.h.

DBARZERODELTAPLUSPLUS_ELASTIC_SIG

const std::initializer_list<double> smash::DBARZERODELTAPLUSPLUS_ELASTIC_SIG

Elastic D̄⁰Δ⁺⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8347 of file parametrizations_data.h.

DbarzeroDeltaplusplus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltaplusplus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAPLUSPLUS_ELASTIC data.

Definition at line 8405 of file parametrizations_data.h.

DBARZERODELTAMINUS_DMINUSDELTAZERO_SIG

const std::initializer_list<double> smash::DBARZERODELTAMINUS_DMINUSDELTAZERO_SIG

D̄⁰Δ⁻ -> D⁻Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8411 of file parametrizations_data.h.

DbarzeroDeltaminus_DminusDeltazero_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltaminus_DminusDeltazero_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAMINUS_DMINUSDELTAZERO data.

Definition at line 8455 of file parametrizations_data.h.

DBARZERODELTAMINUS_ELASTIC_SIG

const std::initializer_list<double> smash::DBARZERODELTAMINUS_ELASTIC_SIG

Elastic D̄⁰Δ⁻ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8461 of file parametrizations_data.h.

DbarzeroDeltaminus_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltaminus_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAMINUS_ELASTIC data.

Definition at line 8519 of file parametrizations_data.h.

DBARZERODELTAZERO_DMINUSDELTAPLUS_SIG

const std::initializer_list<double> smash::DBARZERODELTAZERO_DMINUSDELTAPLUS_SIG

D̄⁰Δ⁰ -> D⁻Δ⁺ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8525 of file parametrizations_data.h.

DbarzeroDeltazero_DminusDeltaplus_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltazero_DminusDeltaplus_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAZERO_DMINUSDELTAPLUS data.

Definition at line 8569 of file parametrizations_data.h.

DBARZERODELTAZERO_ELASTIC_SIG

const std::initializer_list<double> smash::DBARZERODELTAZERO_ELASTIC_SIG

Elastic D̄⁰Δ⁰ cross section Tolos:2013kva [69].

Data provided by Juan Torres-Rincon.

Definition at line 8575 of file parametrizations_data.h.

DbarzeroDeltazero_elastic_interpolation

std::unique_ptr<InterpolateDataLinear<double> > smash::DbarzeroDeltazero_elastic_interpolation = nullptr

static

An interpolation that gets lazily filled using the DBARZERODELTAZERO_ELASTIC data.

Definition at line 8633 of file parametrizations_data.h.

UB_lat_pointer

RectangularLattice< FourVector > * smash::UB_lat_pointer = nullptr

Pointer to the skyrme potential on the lattice.

Definition at line 15 of file potential_globals.cc.

UI3_lat_pointer

RectangularLattice< FourVector > * smash::UI3_lat_pointer = nullptr

Pointer to the symmmetry potential on the lattice.

Definition at line 16 of file potential_globals.cc.

pot_pointer

Potentials * smash::pot_pointer = nullptr

Pointer to a Potential class.

Definition at line 17 of file potential_globals.cc.

LPotentials

constexpr int smash::LPotentials = LogArea::Potentials::id

staticconstexpr

Definition at line 28 of file potentials.h.

LRootSolver

constexpr int smash::LRootSolver = LogArea::RootSolver::id

staticconstexpr

Definition at line 25 of file rootsolver.h.

LPythia

constexpr int smash::LPythia = LogArea::Pythia::id

staticconstexpr

Definition at line 27 of file stringprocess.h.

is_stl_container_v

template<typename T >

constexpr bool smash::is_stl_container_v = is_stl_container<T>::value

inlineconstexpr

Helper alias which is common to be defined next to a type trait.

Definition at line 94 of file traits.h.

is_tuple_like_v

template<typename T >

constexpr bool smash::is_tuple_like_v = is_tuple_like<T>::value

inlineconstexpr

Helper alias which is common to be defined next to a type trait.

Definition at line 122 of file traits.h.

is_map_like_v

template<typename T >

constexpr bool smash::is_map_like_v = is_map_like<std::decay_t<T>>::value

inlineconstexpr

Helper alias which is common to be defined next to a type trait.

Definition at line 149 of file traits.h.

is_streamable_v

template<typename S , typename T >

constexpr bool smash::is_streamable_v = is_streamable<S, T>::value

inlineconstexpr

Helper alias which is common to be defined next to a type trait.

Definition at line 178 of file traits.h.

is_writable_to_stream_v

template<typename S , typename T >

constexpr bool smash::is_writable_to_stream_v

inlineconstexpr

Initial value:

=
    is_writable_to_stream<S, T>::value

Helper alias which is common to be defined next to a type trait.

Definition at line 300 of file traits.h.

has_to_string_v

template<typename T >

constexpr bool smash::has_to_string_v = has_to_string<T>::value

inlineconstexpr

Helper alias which is always defined next to a type trait.

Definition at line 355 of file traits.h.

LPauliBlocking [1/2]

constexpr int smash::LPauliBlocking = LogArea::PauliBlocking::id

staticconstexpr

Definition at line 30 of file action.cc.

LBox

constexpr int smash::LBox = LogArea::Box::id

staticconstexpr

Definition at line 30 of file boxmodus.cc.

LScatterAction [1/5]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 42 of file bremsstrahlungactiondilepton.cc.

LScatterAction [2/5]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 17 of file bremsstrahlungactionphoton.cc.

LResonances [1/3]

constexpr int smash::LResonances = LogArea::Resonances::id

staticconstexpr

Definition at line 20 of file clebschgordan_lookup.cc.

LCollider [1/2]

constexpr int smash::LCollider = LogArea::Collider::id

staticconstexpr

Definition at line 33 of file collidermodus.cc.

LInitialConditions [2/2]

constexpr int smash::LInitialConditions = LogArea::InitialConditions::id

staticconstexpr

Definition at line 34 of file collidermodus.cc.

LConfiguration

constexpr int smash::LConfiguration = LogArea::Configuration::id

staticconstexpr

Definition at line 28 of file configuration.cc.

LCrossSections

constexpr int smash::LCrossSections = LogArea::CrossSections::id

staticconstexpr

Definition at line 20 of file crosssections.cc.

LScatterAction [3/5]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 21 of file crosssections.cc.

LCollider [2/2]

constexpr int smash::LCollider = LogArea::Collider::id

staticconstexpr

Definition at line 22 of file customnucleus.cc.

LDecayModes [1/2]

constexpr int smash::LDecayModes = LogArea::DecayModes::id

staticconstexpr

Definition at line 19 of file decayaction.cc.

LDecayModes [2/2]

constexpr int smash::LDecayModes = LogArea::DecayModes::id

staticconstexpr

Definition at line 22 of file decaymodes.cc.

all_decay_types

std::vector<DecayTypePtr>* smash::all_decay_types = nullptr

Global pointer to the decay types list.

Definition at line 27 of file decaymodes.cc.

num_tab_pts

constexpr size_t smash::num_tab_pts = 200

constexpr

Number of tabulation points.

Definition at line 142 of file decaytype.cc.

integrate [1/2]

Integrator smash::integrate

static

Definition at line 143 of file decaytype.cc.

integrate2d [1/2]

Integrator2d smash::integrate2d(1E7) ( 1E7  )

static

LDistributions

constexpr int smash::LDistributions = LogArea::Distributions::id

staticconstexpr

Definition at line 22 of file distributions.cc.

LFluidization [1/2]

constexpr int smash::LFluidization = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 18 of file dynamicfluidfinder.cc.

LTmn

constexpr int smash::LTmn = LogArea::Tmn::id

staticconstexpr

Definition at line 23 of file energymomentumtensor.cc.

LFluidization [2/2]

constexpr int smash::LFluidization = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 16 of file fluidizationaction.cc.

LFpe

constexpr int smash::LFpe = LogArea::Fpe::id

staticconstexpr

Definition at line 21 of file fpenvironment.cc.

LGrandcanThermalizer [1/2]

constexpr int smash::LGrandcanThermalizer = LogArea::GrandcanThermalizer::id

staticconstexpr

Definition at line 20 of file grandcan_thermalizer.cc.

LGrid

constexpr int smash::LGrid = LogArea::Grid::id

staticconstexpr

Definition at line 82 of file grid.cc.

ZERO

const std::initializer_list<GridBase::SizeType> smash::ZERO {0}

static

Definition at line 298 of file grid.cc.

ZERO_ONE

const std::initializer_list<GridBase::SizeType> smash::ZERO_ONE {0, 1}

static

Definition at line 299 of file grid.cc.

MINUS_ONE_ZERO

const std::initializer_list<GridBase::SizeType> smash::MINUS_ONE_ZERO {-1, 0}

static

Definition at line 300 of file grid.cc.

MINUS_ONE_ZERO_ONE

const std::initializer_list<GridBase::SizeType> smash::MINUS_ONE_ZERO_ONE

static

Initial value:

{-1, 0,
                                                                          1}

Definition at line 301 of file grid.cc.

LResonances [2/3]

constexpr int smash::LResonances = LogArea::Resonances::id

staticconstexpr

Definition at line 26 of file hadgas_eos.cc.

LHyperSurfaceCrossing

constexpr int smash::LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 16 of file hypersurfacecrossingfinder.cc.

LInputParser

constexpr int smash::LInputParser = LogArea::InputParser::id

staticconstexpr

Definition at line 19 of file inputfunctions.cc.

LParticleType [1/2]

constexpr int smash::LParticleType = LogArea::ParticleType::id

staticconstexpr

Definition at line 17 of file isoparticletype.cc.

iso_type_list

IsoParticleTypeList smash::iso_type_list

static

Definition at line 19 of file isoparticletype.cc.

iso_baryon_resonances

std::vector<const IsoParticleType *> smash::iso_baryon_resonances

static

Definition at line 20 of file isoparticletype.cc.

integrate [2/2]

Integrator smash::integrate

static

Definition at line 182 of file isoparticletype.cc.

integrate2d [2/2]

Integrator2d smash::integrate2d

static

Definition at line 183 of file isoparticletype.cc.

NR_tabulations

std::unordered_map<std::string, Tabulation> smash::NR_tabulations

static

Tabulation of all N R integrals.

Keys are the multiplet names (which are unique).

Definition at line 190 of file isoparticletype.cc.

piR_tabulations

std::unordered_map<std::string, Tabulation> smash::piR_tabulations

static

Tabulation of all pi R integrals.

Keys are the multiplet names (which are unique).

Definition at line 197 of file isoparticletype.cc.

RK_tabulations

std::unordered_map<std::string, Tabulation> smash::RK_tabulations

static

Tabulation of all K R integrals.

Keys are the multiplet names (which are unique).

Definition at line 204 of file isoparticletype.cc.

DeltaR_tabulations

std::unordered_map<std::string, Tabulation> smash::DeltaR_tabulations

static

Tabulation of all Delta R integrals.

Keys are the pairs of multiplet names (which are unique).

Definition at line 211 of file isoparticletype.cc.

rhoR_tabulations

std::unordered_map<std::string, Tabulation> smash::rhoR_tabulations

static

Tabulation of all rho rho integrals.

Keys are the pairs of multiplet names (which are unique).

Definition at line 218 of file isoparticletype.cc.

LMain [2/2]

constexpr int smash::LMain = LogArea::Main::id

staticconstexpr

Definition at line 24 of file library.cc.

LList

constexpr int smash::LList = LogArea::List::id

staticconstexpr

Definition at line 38 of file listmodus.cc.

global_default_loglevel

einhard::LogLevel smash::global_default_loglevel = einhard::ALL

static

The default logging level is ALL.

Definition at line 21 of file logging.cc.

LNucleus

constexpr int smash::LNucleus = LogArea::Nucleus::id

staticconstexpr

Definition at line 26 of file nucleus.cc.

LParticleType [2/2]

constexpr int smash::LParticleType = LogArea::ParticleType::id

staticconstexpr

Definition at line 31 of file particletype.cc.

LResonances [3/3]

constexpr int smash::LResonances = LogArea::Resonances::id

staticconstexpr

Definition at line 32 of file particletype.cc.

LPauliBlocking [2/2]

constexpr int smash::LPauliBlocking = LogArea::PauliBlocking::id

staticconstexpr

Definition at line 17 of file pauliblocking.cc.

LPropagation

constexpr int smash::LPropagation = LogArea::Propagation::id

staticconstexpr

Definition at line 19 of file propagation.cc.

LGrandcanThermalizer [2/2]

constexpr int smash::LGrandcanThermalizer = LogArea::GrandcanThermalizer::id

staticconstexpr

Definition at line 18 of file random.cc.

LScatterAction [4/5]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 27 of file scatteraction.cc.

LScatterActionMulti

constexpr int smash::LScatterActionMulti = LogArea::ScatterActionMulti::id

staticconstexpr

Definition at line 23 of file scatteractionmulti.cc.

LScatterAction [5/5]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 24 of file scatteractionphoton.cc.

LFindScatter

constexpr int smash::LFindScatter = LogArea::FindScatter::id

staticconstexpr

Definition at line 29 of file scatteractionsfinder.cc.

LSphere

constexpr int smash::LSphere = LogArea::Sphere::id

staticconstexpr

Definition at line 35 of file spheremodus.cc.