smash Namespace Reference

Namespaces
	anonymous_namespace{configuration.cc}
	anonymous_namespace{decaymodes.cc}
	anonymous_namespace{oscaroutput.cc}
	anonymous_namespace{particletype.cc}
	anonymous_namespace{smash.cc}
	decaytree
	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	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	BremsstrahlungAction
	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 cross section class assembels everything that is needed to calculate the cross section and returns 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...
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	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	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	HypersurfacecrossingAction
	Hypersurfacecrossingaction is a special action which indicates that a particle has crossed a hypersurface of given proper time. More...
class	HyperSurfaceCrossActionsFinder
	Finder for hypersurface crossing actions. More...
class	ICOutput
	SMASH output in ASCII format containing initial conditions for hydrodynamic codes. More...
class	Key
	Object to store a YAML input file key together with metadata associated to it. 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	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	EventInfo
	Structure to contain custom data for output. 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	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...
struct	ScatterActionsFinderParameters
	Helper structure 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...
class	VtkOutput
	SMASH output in a paraview format, 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...
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	Version = std::string
	Descriptive alias for storing SMASH versions associated to keys metadata. More...
using	KeyLabels = std::vector< std::string >
	Descriptive alias for storing key labels, i.e. More...
using	Permutation = std::vector< size_t >
	Represent a permutation. More...

Enumerations
enum class	ComputationMethod { Analytic }
	Calculation method for the cross sections. More...
enum class	DensityType {   None = 0 , Hadron = 1 , Baryon = 2 , BaryonicIsospin = 3 ,   Pion = 4 , Isospin3_tot = 5 , Charge = 6 , Strangeness = 7 }
	Allows to choose which kind of density to calculate. 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	LatticeUpdate { AtOutput = 0 , EveryTimestep = 1 , EveryFixedInterval = 2 }
	Enumerator option for lattice updates. More...
enum	OscarOutputFormat { OscarFormat2013 , OscarFormat2013Extended , OscarFormat1999 }
	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 , HyperSurfaceCrossing = 8 , Bremsstrahlung = 9 ,   MultiParticleThreeMesonsToOne = 10 , MultiParticleThreeToTwo = 11 , MultiParticleFourToTwo = 14 , MultiParticleFiveToTwo = 12 ,   StringSoftSingleDiffractiveAX = 41 , StringSoftSingleDiffractiveXB = 42 , StringSoftDoubleDiffractive = 43 , StringSoftAnnihilation = 44 ,   StringSoftNonDiffractive = 45 , StringHard = 46 , FailedString = 47 , Freeforall = 90 }
	ProcessTypes are used to identify the type of the process. More...
enum class	Extrapolation { Zero = 0 , Const = 1 , Linear = 2 }
	The kind of extrapolation used by the tabulation. 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...
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 (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. 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 [7] 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 [7] 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 [7]. 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 [7]. 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 [44]) 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 [7]. 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)
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 >
T	interpolate_trilinear (T ax, T ay, T az, T f1, T f2, T f3, T f4, T f5, T f6, T f7, T f8)
	Perform a trilinear 1st order interpolation. 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	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={})
	Initialize the particles and decays from the given configuration, plus 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...
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...
template<typename D , typename S >
constexpr D	numeric_cast (const S value)
	Function template to perform a safe numeric conversion between types. More...
template<>
constexpr uint32_t	numeric_cast (const size_t value)
	Function template specialization to perform a safe numeric conversion from size_t to uint32_t . More...
template<typename N >
bool	almost_equal (const N x, const N y)
	Checks two numbers for relative approximate equality. More...
template<typename N >
bool	almost_equal_physics (const N x, const N y)
	Same as smash::almost_equal, but for physical checks like energy-momentum conservation small_number is enough precision-wise. More...
template<typename T = std::initializer_list<double>>
bool	is_any_nan (const T &collection)
	This function iterates through the elements of a collection and checks if any of them is NaN using the std::isnan function. 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)
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 [51]. 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_high_energy (double mandelstam_s, double m1, double m2)
	pi+p elactic cross section parametrization. More...
double	piplusp_elastic_AQM (double mandelstam_s, double m1, double m2)
	An overload of piplusp_elastic_high_energy in which the very low part is replaced by a flat 5 mb cross section; used for meson-meson interactions. 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 [60], 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 [60], eq. More...
double	pp_total (double mandelstam_s)
	pp total cross section parametrization Sources: low-p: Cugnon:1996kh [18] highest-p: Buss:2011mx [13] More...
double	np_elastic (double mandelstam_s)
	np elastic cross section parametrization Source: Weil:2013mya [60], eq. More...
double	np_total (double mandelstam_s)
	np total cross section parametrization Sources: low-p: Cugnon:1996kh [18] highest-p: Buss:2011mx [13] More...
double	ppbar_elastic (double mandelstam_s)
	ppbar elastic cross section parametrization Source: Bass:1998ca [5] More...
double	ppbar_total (double mandelstam_s)
	ppbar total cross section parametrization Source: Bass:1998ca [5] 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 [39]. 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 [13], 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 [13], B.3.9. More...
double	kminusn_elastic_background (double mandelstam_s)
	K- n elastic background cross section parametrization Source: Buss:2011mx [13], B.3.9. More...
double	k0p_elastic_background (double mandelstam_s)
	K0 p elastic background cross section parametrization Source: Buss:2011mx [13], B.3.9. More...
double	k0n_elastic_background (double mandelstam_s)
	K0 n elastic background cross section parametrization Source: Buss:2011mx [13], B.3.9. More...
double	kbar0p_elastic_background (double mandelstam_s)
	Kbar0 p elastic background cross section parametrization Source: Buss:2011mx [13], B.3.9. More...
double	kbar0n_elastic_background (double mandelstam_s)
	Kbar0 n elastic background cross section parametrization Source: Buss:2011mx [13], B.3.9. More...
double	kplusp_inelastic_background (double mandelstam_s)
	K+ p inelastic background cross section parametrization Source: Buss:2011mx [13], B.3.8. More...
double	kplusn_inelastic_background (double mandelstam_s)
	K+ n inelastic background cross section parametrization Source: Buss:2011mx [13], 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 [24]). More...
double	kminusp_piplussigmaminus (double sqrts)
	K- p <-> pi+ Sigma- cross section parametrization Taken from UrQMD (Graef:2014mra [24]). 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_pi0sigmaminus (double sqrts)
	K- n <-> pi0 Sigma- 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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 [24]). 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::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...
template<class T >
constexpr T	square (const T base)
	Efficient template for calculating the square. More...
bool	is_string_soft_process (ProcessType p)
	Check if a given process type is a soft 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	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, const std::string &delim)
	Join strings using delimiter. More...
std::string	quote (const std::string &s)
	Add quotes around string. 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...
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 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)
void	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 &)
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	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...
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
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	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
	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...
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 >	KMINUSN_TOT_SIG
	PDG data on K- n total cross section: cross section. 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...
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_TOT_SIG
	PDG smoothed data on K- p total cross section: cross section. 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...
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
static constexpr int	LPauliBlocking = LogArea::PauliBlocking::id
static constexpr int	LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id
static constexpr int	LBox = LogArea::Box::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	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	LTmn = LogArea::Tmn::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	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	LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::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	LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::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
static constexpr int	LOutput = LogArea::Output::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.

DensityLattice

typedef RectangularLattice<DensityOnLattice> smash::DensityLattice

Conveniency typedef for lattice of density.

Definition at line 527 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.

Version

using smash::Version = typedef std::string

Descriptive alias for storing SMASH versions associated to keys metadata.

At the moment simply a std::string .

Definition at line 32 of file input_keys.h.

KeyLabels

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

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> .

Definition at line 39 of file input_keys.h.

Permutation

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

Represent a permutation.

Definition at line 136 of file interpolation.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 };

DensityType

enum smash::DensityType

strong

Allows to choose which kind of density to calculate.

The baryon density is necessary for the Skyrme potential. For the symmetry potential one needs to know the isospin density.

Enumerator
None
Hadron
Baryon
BaryonicIsospin
Pion
Isospin3_tot
Charge
Strangeness

Definition at line 36 of file density.h.

                       {
  None = 0,
  Hadron = 1,
  Baryon = 2,
  BaryonicIsospin = 3,
  Pion = 4,
  Isospin3_tot = 5,
  Charge = 6,
  Strangeness = 7,
};

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 153 of file grandcan_thermalizer.h.

                       {
  Baryon = 0,
  Antibaryon = 1,
  PositiveSMeson = 2,
  NegativeSMeson = 3,
  PositiveQZeroSMeson = 4,
  NegativeQZeroSMeson = 5,
  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 {
  Normal = 0,
  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 {
  Optimal,
 
  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 {
  None,
 
  ParticleNumber
};

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 36 of file lattice.h.

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

BelongsTo

enum smash::BelongsTo : uint8_t

strong

Enumerator
Nothing
Projectile
Target

Definition at line 20 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 25 of file particletype.h.

                  {
  Pos,
  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 33 of file particletype.h.

                           {
  All,
  Hadronic,
  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_oscar_particles_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.
HyperSurfaceCrossing	See here for a short description.
Bremsstrahlung	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.
StringHard	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.

                       {
  None = 0,
  Elastic = 1,
  TwoToOne = 2,
  TwoToTwo = 3,
  TwoToThree = 4,
  TwoToFour = 15,
  TwoToFive = 13,
  Decay = 5,
  Wall = 6,
  Thermalization = 7,
  HyperSurfaceCrossing = 8,
  Bremsstrahlung = 9,
  MultiParticleThreeMesonsToOne = 10,
  MultiParticleThreeToTwo = 11,
  MultiParticleFourToTwo = 14,
  MultiParticleFiveToTwo = 12,
  StringSoftSingleDiffractiveAX = 41,
  StringSoftSingleDiffractiveXB = 42,
  StringSoftDoubleDiffractive = 43,
  StringSoftAnnihilation = 44,
  StringSoftNonDiffractive = 45,
  StringHard = 46,
  FailedString = 47,
  Freeforall = 90
};

Extrapolation

enum smash::Extrapolation

strong

The kind of extrapolation used by the tabulation.

Enumerator
Zero
Const
Linear

Definition at line 26 of file tabulation.h.

                         {
  Zero = 0,
  Const = 1,
  Linear = 2,
};

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 355 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 532 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;
}

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));
}

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));
}

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));
}

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;
}

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;
}

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;
}

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;
}

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 242 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.");
  }
}

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 280 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.;
  }
}

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 77 of file density.h.

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

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 99 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);
}

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);
}

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 171 of file density.cc.

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

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 179 of file density.cc.

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

update_lattice() [1/2]

template<typename T >

void smash::update_lattice	(	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.

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 542 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();
  // get the normalization factor for the covariant Gaussian smearing
  const double norm_factor_gaus = par.norm_factor_sf();
  // 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;
  // 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]);
 
  for (const Particles &particles : ensembles) {
    for (const ParticleData &part : particles) {
      if (par.only_participants()) {
        // if this conditions holds, the hadron is a spectator
        if (part.get_history().collisions_per_particle == 0) {
          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) {
        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) {
        // 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) {
        // 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);
            });
      }
    }  // end of for (const ParticleData &part : particles)
  }    // end of for (const Particles &particles : ensembles)
}

update_lattice() [2/2]

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 186 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(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()

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));
}

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.);
}

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));
}

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);
}

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 [7]

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;
}

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 [7]

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;
}

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);
}

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;
}

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 [7].

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);
}

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 [7].

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);
}

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 [44]) 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;
}

sample_momenta_IC_ES()

double smash::sample_momenta_IC_ES

(

const double

temperature

)

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

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;
}

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 713 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 [42]). 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 [42]). If the cross sections are globally scaled, the maximum cross section is also scaled.

Definition at line 132 of file experiment.cc.

                                                                         {
  logg[LExperiment].trace() << SMASH_SOURCE_LOCATION;
 
  const int ntest = config.take({"General", "Testparticles"}, 1);
  if (ntest <= 0) {
    throw std::invalid_argument("Testparticle number should be positive!");
  }
 
  // sets whether to consider only participants in thermodynamic outputs or not
  const bool only_participants =
      config.take({"Output", "Thermodynamics", "Only_Participants"}, false);
 
  if (only_participants && config.has_value({"Potentials"})) {
    throw std::invalid_argument(
        "Only_Participants option cannot be "
        "set to True when using Potentials.");
  }
 
  const std::string modus_chooser = config.take({"General", "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({"Modi", "Box", "Length"})) {
    box_length = config.read({"Modi", "Box", "Length"});
  }
 
  if (config.has_value({"Modi", "ListBox", "Length"})) {
    box_length = config.read({"Modi", "ListBox", "Length"});
  }
 
  /* If this Delta_Time option is absent (this can be for timestepless mode)
   * just assign 1.0 fm, reasonable value will be set at event initialization
   */
  const double dt = config.take({"General", "Delta_Time"}, 1.);
  if (dt <= 0.) {
    throw std::invalid_argument("Delta_Time cannot be zero or negative.");
  }
 
  const double t_end = config.read({"General", "End_Time"});
  if (t_end <= 0.) {
    throw std::invalid_argument("End_Time cannot be zero or negative.");
  }
 
  // 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({"Output", "Output_Times"})) {
    if (config.has_value({"Output", "Output_Interval"})) {
      throw std::invalid_argument(
          "Please specify either Output_Interval or Output_Times");
    }
    std::vector<double> output_times = config.take({"Output", "Output_Times"});
    // 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({"Output", "Output_Interval"}, 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_value({"Output", "Photons"}) &&
      (!config.has_value({"Collision_Term", "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.
  bool missing_output_2to2 = false;
  bool missing_output_brems = false;
  if (!(config.has_value({"Output", "Photons"}))) {
    if (config.has_value({"Collision_Term", "Photons", "2to2_Scatterings"})) {
      missing_output_2to2 =
          config.read({"Collision_Term", "Photons", "2to2_Scatterings"});
    }
    if (config.has_value({"Collision_Term", "Photons", "Bremsstrahlung"})) {
      missing_output_brems =
          config.read({"Collision_Term", "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_value({"Output", "Dileptons"}) &&
      (!config.has_value({"Collision_Term", "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.
  bool missing_output_decays = false;
  if (!(config.has_value({"Output", "Dileptons"}))) {
    if (config.has_value({"Collision_Term", "Dileptons", "Decays"})) {
      missing_output_decays =
          config.read({"Collision_Term", "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({"Collision_Term", "Elastic_NN_Cutoff_Sqrts"}, 1.98);
  const auto proton = ParticleType::try_find(pdg::p);
  const auto pion = ParticleType::try_find(pdg::pi_z);
  if (proton && pion &&
      low_snn_cut > proton->mass() + proton->mass() + pion->mass()) {
    logg[LExperiment].warn("The cut-off should be below the threshold energy",
                           " of the process: NN to NNpi");
  }
  const bool potential_affect_threshold =
      config.take({"Lattice", "Potentials_Affect_Thresholds"}, false);
  const double scale_xs =
      config.take({"Collision_Term", "Cross_Section_Scaling"}, 1.0);
 
  const auto criterion = config.take({"Collision_Term", "Collision_Criterion"},
                                     CollisionCriterion::Covariant);
 
  if (config.has_value({"Collision_Term", "Fixed_Min_Cell_Length"}) &&
      criterion != CollisionCriterion::Stochastic) {
    throw std::invalid_argument(
        "Only use a fixed minimal cell length with the stochastic collision "
        "criterion.");
  }
  if (config.has_value({"Collision_Term", "Maximum_Cross_Section"}) &&
      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.");
  }
 
  const double maximum_cross_section_default =
      ParticleType::exists("d'") ? 2000.0 : 200.0;
 
  double maximum_cross_section =
      config.take({"Collision_Term", "Maximum_Cross_Section"},
                  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({"General", "Ensembles"}, 1),
      ntest,
      config.take({"General", "Derivatives_Mode"},
                  DerivativesMode::CovariantGaussian),
      config.has_value({"Potentials", "VDF"})
          ? RestFrameDensityDerivativesMode::On
          : RestFrameDensityDerivativesMode::Off,
      config.take({"General", "Field_Derivatives_Mode"},
                  FieldDerivativesMode::ChainRule),
      config.take({"General", "Smearing_Mode"},
                  SmearingMode::CovariantGaussian),
      config.take({"General", "Gaussian_Sigma"}, 1.),
      config.take({"General", "Gauss_Cutoff_In_Sigma"}, 4.),
      config.take({"General", "Discrete_Weight"}, 1. / 3.0),
      config.take({"General", "Triangular_Range"}, 2.0),
      criterion,
      config.take({"Collision_Term", "Two_to_One"}, true),
      config.take({"Collision_Term", "Included_2to2"}, ReactionsBitSet().set()),
      config.take({"Collision_Term", "Multi_Particle_Reactions"},
                  MultiParticleReactionsBitSet().reset()),
      config.take({"Collision_Term", "Strings"}, modus_chooser != "Box"),
      config.take({"Collision_Term", "Resonance_Lifetime_Modifier"}, 1.),
      config.take({"Collision_Term", "NNbar_Treatment"},
                  NNbarTreatment::Strings),
      low_snn_cut,
      potential_affect_threshold,
      box_length,
      maximum_cross_section,
      config.take({"Collision_Term", "Fixed_Min_Cell_Length"}, 2.5),
      scale_xs,
      only_participants,
      config.take({"Collision_Term", "Include_Weak_And_EM_Decays_At_The_End"},
                  false),
      config.take({"Collision_Term", "Decay_Initial_Particles"},
                  InputKeys::collTerm_decayInitial.default_value()),
      std::nullopt};
}

hline()

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

String representing a horizontal line.

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 349 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();
}

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 397 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;
}

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 617 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;
}

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 639 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);
    }
  }
}

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 2510 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!");
  }
}

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()

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;
}

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 [21], 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 35 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;
}

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 [13] or eq. (13) in Post:2003hu [43].

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 77 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;
}

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 [33]. For the η the Lambda parameter is fitted to NA60 data, see NA60:2009una [4].

Parameters

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

Definition at line 99 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
  }
}

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 [11].

Parameters

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

Definition at line 122 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
  }
}

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 146 of file formfactors.h.

{ return 3.12; }

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; }

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
}

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();
}

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 + "\")";
}

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;
}

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));
  }
} /*}}}*/

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.

Definition at line 80 of file inputfunctions.h.

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

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 91 of file inputfunctions.h.

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

interpolate_trilinear()

template<typename T >

T smash::interpolate_trilinear	(	T	ax,
		T	ay,
		T	az,
		T	f1,
		T	f2,
		T	f3,
		T	f4,
		T	f5,
		T	f6,
		T	f7,
		T	f8
	)

Perform a trilinear 1st order interpolation.

Assume, we seek the value of a function f at position (x, y, z). We know the position (x, y, z) lies within a 3D cube, for which the values of the function f are known at each corner (f1, ..., f8). We can now interpolate those values trilinearly to obtain an estimate of f at position (x, y, z).

Parameters

[in]	ax	fraction of the step in x-direction
[in]	ay	fraction of the step in y-direction
[in]	az	fraction of the step in z-direction
[in]	f1	Value at the lower left front corner of the cube
[in]	f2	Value at the lower right front corner of the cube
[in]	f3	Value at the upper left front corner of the cube
[in]	f4	Value at the upper right front corner of the cube
[in]	f5	Value at the lower left back corner of the cube
[in]	f6	Value at the lower right back corner of the cube
[in]	f7	Value at the upper left back corner of the cube
[in]	f8	Value at the upper right back corner of the cube

Returns

Interpolated value

Definition at line 126 of file interpolation.h.

                                    {
  T res = az * (ax * (ay * f8 + (1.0 - ay) * f6) +
                (1.0 - ax) * (ay * f7 + (1.0 - ay) * f5)) +
          (1 - az) * (ax * (ay * f4 + (1.0 - ay) * f2) +
                      (1.0 - ax) * (ay * f3 + (1.0 - ay) * f1));
  return res;
}

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 147 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;
}

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 164 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;
}

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.

Throws an exception if duplicates are encountered.

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.

Definition at line 183 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());
  }
}

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 230 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();
  }
}

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));
}

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);
}

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;
}

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.);
}

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);
}

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);
}

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};
}

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());
  }
}

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());
  }
}

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);
}

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);
}

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);
}

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 211 of file kinematics.h.

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

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 224 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 239 of file kinematics.h.

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

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 252 of file kinematics.h.

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

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 265 of file kinematics.h.

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

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 278 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);
}

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 33 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;
}

initialize_particles_decays_and_tabulations()

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

Initialize the particles and decays from the given configuration, plus tabulate 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 45 of file library.cc.

                                      {
  logg[LMain].trace(SMASH_SOURCE_LOCATION,
                    " create ParticleType and DecayModes");
  const std::string particles_string = configuration.take({"particles"});
  const std::string decaymodes_string = configuration.take({"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);
 
  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);
}

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;
}

numeric_cast() [1/2]

template<typename D , typename S >

constexpr D smash::numeric_cast ( const S  value )

constexpr

Function template to perform a safe numeric conversion between types.

Template Parameters

D	Destination type
S	Source type

Parameters

[in]

value

Input value to be converted

Returns

The input value converted to the new type D .

Exceptions

std::overflow_error

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

NOTE: This template is only declared and not implemented! Only specializations are implemented so that only given conversions do not result in compilation errors.

numeric_cast() [2/2]

template<>

constexpr uint32_t smash::numeric_cast ( const size_t  value )

constexpr

Function template specialization to perform a safe numeric conversion from size_t to uint32_t .

Parameters

[in]

value

Input value to be converted

Returns

The input value converted to the uint32_t type.

Exceptions

std::overflow_error

If the value to be converted is larger than the maximum of uint32_t type.

Definition at line 42 of file numeric_cast.h.

                                                    {
  // Conversion from unsigned to unsigned
  //  => the only possible problem is a positive overflow.
  if (value > std::numeric_limits<uint32_t>::max()) {
    throw std::overflow_error(
        "Input value overflows the target uint32_t type!");
  }
  return static_cast<uint32_t>(value);
}

almost_equal()

template<typename N >

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

Checks two numbers for relative approximate equality.

Template Parameters

N	Number type.

Parameters

x	Left-hand side.
y	Right-hand side.

Returns

true if the difference between x and y is less than or equal to \(\delta = \)smash::really_small or that times the average of \(|x|\) and \(|y|\):

\[|x - y| \stackrel{?}{\le} \delta \mbox{ or } |x - y| \stackrel{?}{\le} \frac{|x| + |y|}{2} \cdot \delta\]

See also

smash::really_small

Definition at line 44 of file numerics.h.

                                        {
  return (std::abs(x - y) <= N(really_small) ||
          std::abs(x - y) <=
              N(0.5 * really_small) * (std::abs(x) + std::abs(y)));
}

almost_equal_physics()

template<typename N >

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

Same as smash::almost_equal, but for physical checks like energy-momentum conservation small_number is enough precision-wise.

Template Parameters

N	Number type.

Parameters

x	Left-hand side.
y	Right-hand side.

Returns

true if the difference between x and y is less than or equal to \(\delta = \)smash::small_number or that times the average of \(|x|\) and \(|y|\):

See also

smash::small_number

smash::almost_equal

Definition at line 64 of file numerics.h.

                                                {
  return (std::abs(x - y) <= N(small_number) ||
          std::abs(x - y) <=
              N(0.5 * small_number) * (std::abs(x) + std::abs(y)));
}

is_any_nan()

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

bool smash::is_any_nan

(

const T &

collection

)

This function iterates through the elements of a collection and checks if any of them is NaN using the std::isnan function.

NaN is a special floating-point value that represents undefined or unrepresentable values.

Template Parameters

T	The type of the collection. It can be any iterable container of numeric values.

Parameters

collection

The collection to be checked for NaN values.

Returns

true if any element in the collection is NaN, false otherwise

Definition at line 82 of file numerics.h.

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

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;
}

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;
}

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);
}

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);
}

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);
}

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);
}

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);
}

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);
}

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;
}

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 [51].

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;
  }
}

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);
}

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);
}

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);
}

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);
  }
  const double last = *(PIPLUSPIMINUS_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*pipluspiminus_total_interpolation)(sqrts);
  else
    return pipi_string_hard(sqrts * sqrts);
}

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 128 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);
  }
  const double last = *(PIZEROPIZERO_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*pizeropizero_total_interpolation)(sqrts);
  else
    return pipi_string_hard(sqrts * sqrts);
}

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 143 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);
  }
  const double last = *(PIPLUSP_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*piplusp_total_interpolation)(sqrts);
  else
    return piplusp_high_energy(sqrts * sqrts);
}

piplusp_elastic_high_energy()

double smash::piplusp_elastic_high_energy	(	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)

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 175 of file parametrizations.cc.

                                                                              {
  const double p_lab = (m1 > m2) ? plab_from_s(mandelstam_s, m2, m1)
                                 : plab_from_s(mandelstam_s, m1, m2);
  const auto logp = std::log(p_lab);
  return 11.4 * std::pow(p_lab, -0.4) + 0.079 * logp * logp;
}

piplusp_elastic_AQM()

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

An overload of piplusp_elastic_high_energy in which the very low part is replaced by a flat 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 182 of file parametrizations.cc.

                                                                      {
  const double p_lab = (m1 > m2) ? plab_from_s(mandelstam_s, m2, m1)
                                 : plab_from_s(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 {
    return piplusp_elastic_high_energy(mandelstam_s, m1, m2);
  }
}

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 192 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);
  }
  sigma -= (*piplusp_elastic_res_interpolation)(mandelstam_s);
  if (sigma < 0) {
    sigma = really_small;
  }
  return sigma;
}

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 226 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);
  }
  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,
   * InterpolationDataLinear will return the value at the upper bound and this
   * is what we want here. */
  return (*piplusp_sigmapluskplus_interpolation)(p_lab);
}

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 241 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);
  }
  const double last = *(PIMINUSP_TOT_SQRTS.end() - 1);
  if (sqrts < last)
    return (*piminusp_total_interpolation)(sqrts);
  else
    return piminusp_high_energy(sqrts * sqrts);
}

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 273 of file parametrizations.cc.

                                             {
  double sigma;
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  const auto logp = std::log(p_lab);
  if (mandelstam_s < 1.69) {
    sigma = really_small;
  } else if (mandelstam_s > 4.84) {
    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);
  }
  sigma -= (*piminusp_elastic_res_interpolation)(mandelstam_s);
  if (sigma < 0) {
    sigma = really_small;
  }
  return sigma;
}

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 317 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piminusp_lambdak0_interpolation)(p_lab);
}

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 334 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piminusp_sigmaminuskplus_interpolation)(p_lab);
}

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 351 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);
  }
  const double sqrts = std::sqrt(mandelstam_s);
  return (*piminusp_sigma0k0_interpolation)(sqrts);
}

pp_elastic()

double smash::pp_elastic

(

double

mandelstam_s

)

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

(44)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 363 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;
  }
}

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 [60], 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 382 of file parametrizations.cc.

                                                                         {
  const double p_lab = (m1 > m2) ? plab_from_s(mandelstam_s, m2, m1)
                                 : plab_from_s(mandelstam_s, m1, m2);
  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;
}

pp_total()

double smash::pp_total

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 390 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;
  }
}

np_elastic()

double smash::np_elastic

(

double

mandelstam_s

)

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

(45)

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 406 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;
  }
}

np_total()

double smash::np_total

(

double

mandelstam_s

)

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

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);
  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;
  }
}

ppbar_elastic()

double smash::ppbar_elastic

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 441 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;
  }
}

ppbar_total()

double smash::ppbar_total

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 458 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;
  }
}

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 475 of file parametrizations.cc.

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

deuteron_nucleon_elastic()

double smash::deuteron_nucleon_elastic

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 480 of file parametrizations.cc.

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

kplusp_total()

double smash::kplusp_total

(

double

mandelstam_s

)

K+ p total cross section parametrization.

Source: Buss:2011mx [13], 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 486 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusp_total_interpolation)(p_lab);
}

kplusn_total()

double smash::kplusn_total

(

double

mandelstam_s

)

K+ n total cross section parametrization.

Source: Buss:2011mx [13], 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 498 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusn_total_interpolation)(p_lab);
}

kminusn_total()

double smash::kminusn_total

(

double

mandelstam_s

)

K- n total cross section parametrization.

Source: Buss:2011mx [13], 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 523 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kminusn_total_interpolation)(p_lab);
}

kminusp_total()

double smash::kminusp_total

(

double

mandelstam_s

)

K- p total cross section parametrization.

Source: Buss:2011mx [13], 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 510 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 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kminusp_total_interpolation)(p_lab);
}

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 [13], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 535 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);
}

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 [13], B.3.8.

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 548 of file parametrizations.cc.

                                                      {
  return 0.25 * kplusp_elastic_background(mandelstam_s);
}

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 [13], B.3.8

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 552 of file parametrizations.cc.

                                       {
  return 0.25 * kplusp_elastic_background(mandelstam_s);
}

kminusp_elastic_background()

double smash::kminusp_elastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 573 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;
 
    const double p_i = p_lab;
    const double p_f = p_lab;
 
    const double ratio = a1 * a1 / (a1 * a1 + p_f * p_f);
    sigma = a0 * p_f / (p_i * 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);
  }
  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;
}

kminusn_elastic_background()

double smash::kminusn_elastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 617 of file parametrizations.cc.

{ return 4.0; }

k0p_elastic_background()

double smash::k0p_elastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 619 of file parametrizations.cc.

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

k0n_elastic_background()

double smash::k0n_elastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 624 of file parametrizations.cc.

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

kbar0p_elastic_background()

double smash::kbar0p_elastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 629 of file parametrizations.cc.

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

kbar0n_elastic_background()

double smash::kbar0n_elastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 634 of file parametrizations.cc.

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

kplusp_inelastic_background()

double smash::kplusp_inelastic_background

(

double

mandelstam_s

)

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 639 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kplusp_total_interpolation)(p_lab)-kplusp_elastic_background(
      mandelstam_s);
}

kplusn_inelastic_background()

double smash::kplusn_inelastic_background

(

double

mandelstam_s

)

K+ n inelastic background cross section parametrization Source: Buss:2011mx [13], 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 652 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);
  }
  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);
}

kminusp_kbar0n()

double smash::kminusp_kbar0n

(

double

mandelstam_s

)

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

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

Parameters

[in]

mandelstam_s

the rest frame total energy squared [GeV^2]

Returns

the parametrized cross-section [mb]

Definition at line 771 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);
  const double p_i = p_lab;
  const double p_f = p_lab;
 
  return a0 * p_f / (p_i * mandelstam_s) *
         pow_int(a1 * a1 / (a1 * a1 + p_f * p_f), a2);
}

kminusp_piminussigmaplus()

double smash::kminusp_piminussigmaplus

(

double

sqrts

)

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

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 784 of file parametrizations.cc.

                                              {
  return 0.0788265 / smash::square(sqrts - 1.38841);
}

kminusp_piplussigmaminus()

double smash::kminusp_piplussigmaminus

(

double

sqrts

)

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

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 788 of file parametrizations.cc.

                                              {
  return 0.0196741 / smash::square(sqrts - 1.42318);
}

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 792 of file parametrizations.cc.

                                       {
  return 0.0403364 / smash::square(sqrts - 1.39830305);
}

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 796 of file parametrizations.cc.

                                       {
  return 0.05932562 / smash::square(sqrts - 1.38786692);
}

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.

Parameters

[in]

sqrts

the rest frame total energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 800 of file parametrizations.cc.

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

kminusn_pi0sigmaminus()

double smash::kminusn_pi0sigmaminus

(

double

sqrts

)

K- n <-> pi0 Sigma- 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]

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 805 of file parametrizations.cc.

                                           {
  return 2. * kminusp_pi0lambda(sqrts);
}

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 [24]).

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 811 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);
}

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 [24]).

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 817 of file parametrizations.cc.

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

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 821 of file parametrizations.cc.

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

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 826 of file parametrizations.cc.

                                                      {
  return lambdasigmaplus_xi0p(sqrts_sqrts0);
}

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 830 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);
  }
}

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 839 of file parametrizations.cc.

                                              {
  return lambdasigma0_ximinusp(sqrts_sqrts0);
}

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 843 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);
  }
}

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 [24]).

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 852 of file parametrizations.cc.

                                              {
  return sigma0sigma0_ximinusp(sqrts_sqrts0);
}

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 856 of file parametrizations.cc.

                                                     {
  return 4 * sigma0sigma0_ximinusp(sqrts_sqrts0);
}

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 [24]).

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.

                                                      {
  return 4 * sigma0sigma0_ximinusp(sqrts_sqrts0);
}

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 864 of file parametrizations.cc.

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

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 [24]).

Parameters

[in]

sqrts_sqrts0

the rest frame total energy minus threshold energy [GeV]

Returns

the parametrized cross-section [mb]

Definition at line 868 of file parametrizations.cc.

                                                     {
  return sigmaplussigmaminus_ximinusp(sqrts_sqrts0);
}

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 165 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;
}

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 250 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);
  }
}

operator-() [3/4]

Parity smash::operator- ( Parity  p )

inline

Parameters

p	Given parity.

Returns

Inverted parity.

Definition at line 46 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 63 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 76 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 775 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];
}

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 1117 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);
}

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 1129 of file pdgcode.h.

                                                {
  return is_dilepton(pdg1, pdg2) || is_dilepton(pdg1, pdg3) ||
         is_dilepton(pdg2, pdg3);
}

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 130 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!
}

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);
}

square()

template<class T >

constexpr T smash::square ( const T  base )

inlineconstexpr

Efficient template for calculating the square.

Template Parameters

T	Type that implements multiplication.

Parameters

[in]

base

value that gets squared

Returns

result of squaring base

Definition at line 37 of file pow.h.

                                        {
  return pow_int(base, 2);
}

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 p == ProcessType::StringSoftSingleDiffractiveAX ||
         p == ProcessType::StringSoftSingleDiffractiveXB ||
         p == ProcessType::StringSoftDoubleDiffractive ||
         p == ProcessType::StringSoftAnnihilation ||
         p == ProcessType::StringSoftNonDiffractive;
}

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 [58]

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;
}

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;
}

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 86 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());
  }
}

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 111 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));
      }
      /* Floating point traps should be raised if the force is not overwritten
       * with a meaningful value */
      const auto sNaN = std::numeric_limits<double>::signaling_NaN();
      ThreeVector force(sNaN, sNaN, sNaN);
      if (pot.use_momentum_dependence()) {
        ThreeVector energy_grad = pot.single_particle_energy_gradient(
            jB_lat, data.position().threevec(), data.momentum().threevec(),
            data.effective_mass(), plist);
        force = -energy_grad * scale.first;
        force +=
            scale.second * data.type().isospin3_rel() *
            (FI3.first + data.momentum().velocity().cross_product(FI3.second));
      } else {
        force = 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.";
  }
}

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.

Definition at line 130 of file scatteractionsfinder.cc.

                                                                   {
  std::pair<double, double> sqrts_range_Npi =
      config.take({"Collision_Term", "String_Transition", "Sqrts_Range_Npi"},
                  InputKeys::collTerm_stringTrans_rangeNpi.default_value());
  std::pair<double, double> sqrts_range_NN =
      config.take({"Collision_Term", "String_Transition", "Sqrts_Range_NN"},
                  InputKeys::collTerm_stringTrans_rangeNN.default_value());
  if (sqrts_range_Npi.first < nucleon_mass + pion_mass) {
    sqrts_range_Npi.first = nucleon_mass + pion_mass;
    if (sqrts_range_Npi.second < sqrts_range_Npi.first)
      sqrts_range_Npi.second = sqrts_range_Npi.first;
    logg[LFindScatter].warn(
        "Lower bound of Sqrts_Range_Npi too small, setting it to mass "
        "threshold. New range is [",
        sqrts_range_Npi.first, ',', sqrts_range_Npi.second, "] GeV");
  }
  if (sqrts_range_NN.first < 2 * nucleon_mass) {
    sqrts_range_NN.first = 2 * nucleon_mass;
    if (sqrts_range_NN.second < sqrts_range_NN.first)
      sqrts_range_NN.second = sqrts_range_NN.first;
    logg[LFindScatter].warn(
        "Lower bound of Sqrts_Range_NN too small, setting it to mass "
        "threshold. New range is [",
        sqrts_range_NN.first, ',', sqrts_range_NN.second, "] GeV.");
  }
  auto xs_strategy =
      config.take({"Collision_Term", "Total_Cross_Section_Strategy"},
                  InputKeys::collTerm_totXsStrategy.default_value());
  if (xs_strategy == TotalCrossSectionStrategy::BottomUp) {
    logg[LFindScatter].info(
        "Evaluating total cross sections from partial processes.");
  } else if (parameters.included_2to2[IncludedReactions::Elastic] == 1 &&
             parameters.included_2to2.count() == 1) {
    throw std::invalid_argument(
        "The BottomUp strategy for total cross section evaluation is needed to "
        "have only elastic interactions, please change the configuration "
        "accordingly.");
  } else if (xs_strategy == TotalCrossSectionStrategy::TopDown) {
    logg[LFindScatter].info(
        "Evaluating total cross sections from parametrizations.");
  } else if (xs_strategy == TotalCrossSectionStrategy::TopDownMeasured) {
    logg[LFindScatter].info(
        "Evaluating total cross sections from parametrizations only for "
        "measured processes.");
  }
  return {
      config.take({"Collision_Term", "Elastic_Cross_Section"}, -1.),
      parameters.low_snn_cut,
      parameters.scale_xs,
      config.take({"Collision_Term", "Additional_Elastic_Cross_Section"}, 0.0),
      parameters.maximum_cross_section,
      parameters.coll_crit,
      parameters.nnbar_treatment,
      parameters.included_2to2,
      parameters.included_multi,
      parameters.testparticles,
      parameters.two_to_one,
      config.take({"Modi", "Collider", "Collisions_Within_Nucleus"}, false),
      parameters.strings_switch,
      config.take({"Collision_Term", "Use_AQM"}, true),
      config.take({"Collision_Term", "Strings_with_Probability"}, true),
      config.take({"Collision_Term", "Only_Warn_For_High_Probability"}, false),
      StringTransitionParameters{
          sqrts_range_Npi, sqrts_range_NN,
          config.take({"Collision_Term", "String_Transition", "Sqrts_Lower"},
                      InputKeys::collTerm_stringTrans_lower.default_value()),
          config.take(
              {"Collision_Term", "String_Transition", "Sqrts_Range_Width"},
              InputKeys::collTerm_stringTrans_range_width.default_value()),
          config.take(
              {"Collision_Term", "String_Transition", "PiPi_Offset"},
              InputKeys::collTerm_stringTrans_pipiOffset.default_value()),
          config.take(
              {"Collision_Term", "String_Transition", "KN_Offset"},
              InputKeys::collTerm_stringTrans_KNOffset.default_value())},
      xs_strategy,
      config.take({"Collision_Term", "Pseudoresonance"},
                  InputKeys::collTerm_pseudoresonance.default_value())};
}

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);
}

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();
}

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);
}

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);
  }
}

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, "⁰");
}

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;
}

join()

std::string smash::join	(	const std::vector< std::string > &	v,
		const std::string &	delim
	)

Join strings using delimiter.

Parameters

[in]	v	Strings to be joint.
[in]	delim	Joining delimiter.

Returns

Joint string.

Definition at line 127 of file stringfunctions.cc.

                                                                      {
  return std::accumulate(std::begin(v), std::end(v), std::string{},
                         [&delim](const std::string &ss, const std::string &s) {
                           return ss.empty() ? s : ss + delim + s;
                         });
}

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 134 of file stringfunctions.cc.

{ return "\"" + s + "\""; }

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 136 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.spectral_function(resonance_mass) *
         pCM(sqrts, stable_mass, resonance_mass);
}

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 165 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.spectral_function(res_mass_1) * t2.spectral_function(res_mass_2) *
         pCM(sqrts, res_mass_1, res_mass_2);
}

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 189 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);
    });
  });
}

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 211 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);
        });
  });
}

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 202 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 215 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 228 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 234 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 242 of file threevector.h.

                                                             {
  return a.x1() * b.x1() + a.x2() * b.x2() + a.x3() * b.x3();
}

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 261 of file threevector.h.

                                                             {
  a /= b;
  return a;
}

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 32 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);
}

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 273 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 28 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;
}

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 47 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;
}

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 70 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;
}

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 91 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));
  }
}

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.;
}

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->spectral_function(mass);
}

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->spectral_function(m1) *
         t2->spectral_function(m2);
}

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;
      }
    }
    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);
}

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;
}

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;
  }
}

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 219 of file isoparticletype.cc.

                               {
  return dir / (prefix + res_name + ".bin");
}

cache_integral()

void 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  )

inline

Definition at line 225 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());
  Tabulation integral;
  if (!dir.empty() && std::filesystem::exists(path)) {
    std::ifstream file(path.string());
    integral = Tabulation::from_file(file, hash);
    if (!integral.is_empty()) {
      // Only print message if the found tabulation was valid.
      std::cout << "Tabulation found at " << path.filename() << '\r'
                << std::flush;
    }
  }
  if (integral.is_empty()) {
    if (!dir.empty()) {
      std::cout << "Caching tabulation to " << path.filename() << '\r'
                << std::flush;
    } else {
      std::cout << "Calculating integral for " << part.name_filtered_prime()
                << res.name_filtered_prime() << '\r' << std::flush;
    }
    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()) {
      std::ofstream file(path.string());
      integral.write(file, hash);
    }
  }
  tabulations.emplace(std::make_pair(res.name(), integral));
  if (antires != nullptr) {
    tabulations.emplace(std::make_pair(antires->name(), integral));
  }
}

create_configuration()

static Configuration smash::create_configuration ( const std::string &  config_file, const std::vector< std::string > &  extra_config  )

static

Definition at line 74 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;
}

do_minimal_loggers_setup_for_config_validation()

static void smash::do_minimal_loggers_setup_for_config_validation ( )

static

Definition at line 89 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));
}

fully_validate_configuration()

static void smash::fully_validate_configuration ( const Configuration &  configuration )

static

Definition at line 98 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.");
  }
}

setup_logging()

static void smash::setup_logging ( Configuration &  configuration )

static

Definition at line 105 of file library.cc.

                                                        {
  set_default_loglevel(
      configuration.take({"Logging", "default"}, einhard::ALL));
  create_all_loggers(configuration.extract_sub_configuration(
      {"Logging"}, Configuration::GetEmpty::Yes));
}

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 112 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({"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({"particles"}) || !particles_path.empty()) {
    configuration.set_value({"particles"}, particles_and_decays.first);
  }
 
  if (configuration.has_value({"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({"decaymodes"}) || !decaymodes_path.empty()) {
    configuration.set_value({"decaymodes"}, particles_and_decays.second);
  }
}

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 75 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 53 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 72 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 85 of file logging.cc.

                     {}

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 102 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);
  logger.setVerbosity(
      config.take({LogAreaTag::textual()}, global_default_loglevel));
  create_all_loggers_impl<index - 1, longest_name>(config);
}

operator<<() [7/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const Nucleus &	n
	)

Definition at line 512 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 163 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piplusp_elastic_interpolation)(p_lab);
}

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);
  }
  const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
  return (*piminusp_elastic_interpolation)(p_lab);
}

kminusp_elastic_pdg()

static double smash::kminusp_elastic_pdg ( double  mandelstam_s )

static

Definition at line 561 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);
  }
  const double p_lab = plab_from_s(mandelstam_s, kaon_mass, nucleon_mass);
  return (*kminusp_elastic_interpolation)(p_lab);
}

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 674 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);
  }
}

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) {
    constexpr char bar[] = "\u0305";
    basename.insert(utf8::sequence_length(basename.begin()), bar);
  }
 
  return basename + charge;
}

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 182 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));
  }
}

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 760 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 [1].

Parameters

[in]

plab

Lab momentum in GeV.

Returns

B coefficients of high-energy elastic proton-proton scatterings.

Definition at line 408 of file scatteraction.cc.

                                           {
  double mandelstam_s = s_from_plab(plab, nucleon_mass, nucleon_mass);
  return 7.6 + 0.66 * std::log(mandelstam_s);
}

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 [18]. 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 425 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.));
  }
}

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 [18].

Parameters

[in]

plab

Lab momentum in GeV.

Returns

Cugnon B coefficient for elastic proton-neutron scatterings.

Definition at line 444 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);
  }
}

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 923 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);
    }
  }
}

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 72 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());
    out << "Adding a " << ptype->name() << " as a jet in the middle "
        << "of the sphere with " << m.jet_mom_ << " GeV 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;
  }
}

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 62 of file tabulation.cc.

                                                  {
  stream.write(reinterpret_cast<const char*>(&x), sizeof(x));
}

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 72 of file tabulation.cc.

                                                {
  double x;
  stream.read(reinterpret_cast<char*>(&x), sizeof(x));
  return x;
}

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 84 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 98 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;
}

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 113 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());
  }
}

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 127 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;
}

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 141 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 153 of file tabulation.cc.

                                                  {
  sha256::Hash x;
  stream.read(reinterpret_cast<char*>(x.data()), x.size());
  return x;
}

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 25 of file clock.h.

hbarc

constexpr double smash::hbarc = 0.197327053

constexpr

GeV <-> fm conversion factor.

Definition at line 25 of file constants.h.

fm2_mb

constexpr double smash::fm2_mb = 0.1

constexpr

mb <-> fm^2 conversion factor.

Definition at line 28 of file constants.h.

gev2_mb

constexpr double smash::gev2_mb = hbarc * hbarc / fm2_mb

constexpr

GeV^-2 <-> mb conversion factor.

Definition at line 31 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 34 of file constants.h.

really_small

constexpr double smash::really_small = 1.0e-6

constexpr

Numerical error tolerance.

Definition at line 37 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 40 of file constants.h.

twopi

constexpr double smash::twopi = 2. * M_PI

constexpr

\( 2\pi \).

Definition at line 45 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 48 of file constants.h.

small_number

constexpr double smash::small_number = 1.0e-4

constexpr

Physical error tolerance.

Definition at line 51 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 58 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 65 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 72 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 79 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 86 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 92 of file constants.h.

fine_structure

constexpr double smash::fine_structure = 7.2973525698e-3

constexpr

Fine-struture constant, approximately 1/137.

Definition at line 95 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 98 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 103 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 111 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 118 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 89 of file experiment.h.

LInitialConditions

constexpr int smash::LInitialConditions = LogArea::InitialConditions::id

staticconstexpr

Definition at line 90 of file experiment.h.

LLattice

constexpr int smash::LLattice = LogArea::Lattice::id

staticconstexpr

Definition at line 25 of file lattice.h.

LOutput [1/2]

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 22 of file outputparameters.h.

kaon_nucleon_ratios

KaonNucleonRatios smash::kaon_nucleon_ratios

Definition at line 769 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_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 32 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 35 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_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 192 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 195 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 590 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 663 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 666 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 686 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 702 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 705 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 714 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 728 of file parametrizations_data.h.

PIPLUSP_RES_SQRTS

const std::initializer_list<double> smash::PIPLUSP_RES_SQRTS

Center-of-mass energy.

Definition at line 731 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 787 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 849 of file parametrizations_data.h.

PIPLUSP_TOT_SQRTS

const std::initializer_list<double> smash::PIPLUSP_TOT_SQRTS

Center-of-mass energy.

Definition at line 852 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 914 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 985 of file parametrizations_data.h.

PIMINUSP_TOT_SQRTS

const std::initializer_list<double> smash::PIMINUSP_TOT_SQRTS

Center-of-mass energy.

Definition at line 988 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 1079 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 1169 of file parametrizations_data.h.

PIPLUSPIMINUS_TOT_SQRTS

const std::initializer_list<double> smash::PIPLUSPIMINUS_TOT_SQRTS

Center-of-mass energy.

Definition at line 1172 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 1236 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 1307 of file parametrizations_data.h.

PIZEROPIZERO_TOT_SQRTS

const std::initializer_list<double> smash::PIZEROPIZERO_TOT_SQRTS

Center-of-mass energy.

Definition at line 1310 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 1374 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 1436 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 26 of file stringprocess.h.

LPauliBlocking [1/2]

constexpr int smash::LPauliBlocking = LogArea::PauliBlocking::id

staticconstexpr

Definition at line 27 of file action.cc.

LHyperSurfaceCrossing [1/5]

constexpr int smash::LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 22 of file binaryoutput.cc.

LBox

constexpr int smash::LBox = LogArea::Box::id

staticconstexpr

Definition at line 29 of file boxmodus.cc.

LScatterAction [1/4]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 17 of file bremsstrahlungaction.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 29 of file collidermodus.cc.

LConfiguration

constexpr int smash::LConfiguration = LogArea::Configuration::id

staticconstexpr

Definition at line 26 of file configuration.cc.

LCrossSections

constexpr int smash::LCrossSections = LogArea::CrossSections::id

staticconstexpr

Definition at line 19 of file crosssections.cc.

LScatterAction [2/4]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 20 of file crosssections.cc.

LCollider [2/2]

constexpr int smash::LCollider = LogArea::Collider::id

staticconstexpr

Definition at line 20 of file customnucleus.cc.

LDecayModes [1/2]

constexpr int smash::LDecayModes = LogArea::DecayModes::id

staticconstexpr

Definition at line 17 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.

LTmn

constexpr int smash::LTmn = LogArea::Tmn::id

staticconstexpr

Definition at line 21 of file energymomentumtensor.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 81 of file grid.cc.

ZERO

const std::initializer_list<GridBase::SizeType> smash::ZERO {0}

static

Definition at line 295 of file grid.cc.

ZERO_ONE

const std::initializer_list<GridBase::SizeType> smash::ZERO_ONE {0, 1}

static

Definition at line 296 of file grid.cc.

MINUS_ONE_ZERO

const std::initializer_list<GridBase::SizeType> smash::MINUS_ONE_ZERO {-1, 0}

static

Definition at line 297 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 298 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 [2/5]

constexpr int smash::LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 16 of file hypersurfacecrossingaction.cc.

LHyperSurfaceCrossing [3/5]

constexpr int smash::LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 18 of file icoutput.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 181 of file isoparticletype.cc.

integrate2d [2/2]

Integrator2d smash::integrate2d

static

Definition at line 182 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 189 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 196 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 203 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 210 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 217 of file isoparticletype.cc.

LMain [2/2]

constexpr int smash::LMain = LogArea::Main::id

staticconstexpr

Definition at line 23 of file library.cc.

LList

constexpr int smash::LList = LogArea::List::id

staticconstexpr

Definition at line 36 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 20 of file logging.cc.

LNucleus

constexpr int smash::LNucleus = LogArea::Nucleus::id

staticconstexpr

Definition at line 23 of file nucleus.cc.

LHyperSurfaceCrossing [4/5]

constexpr int smash::LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 21 of file oscaroutput.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 16 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 17 of file random.cc.

LHyperSurfaceCrossing [5/5]

constexpr int smash::LHyperSurfaceCrossing = LogArea::HyperSurfaceCrossing::id

staticconstexpr

Definition at line 20 of file rootoutput.cc.

LScatterAction [3/4]

constexpr int smash::LScatterAction = LogArea::ScatterAction::id

staticconstexpr

Definition at line 26 of file scatteraction.cc.

LScatterActionMulti

constexpr int smash::LScatterActionMulti = LogArea::ScatterActionMulti::id

staticconstexpr

Definition at line 23 of file scatteractionmulti.cc.

LScatterAction [4/4]

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 26 of file scatteractionsfinder.cc.

LSphere

constexpr int smash::LSphere = LogArea::Sphere::id

staticconstexpr

Definition at line 35 of file spheremodus.cc.

LOutput [2/2]

constexpr int smash::LOutput = LogArea::Output::id

staticconstexpr

Definition at line 20 of file stringprocess.cc.