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

	transit_high_energy
	constants related to transition between low and high collision energies

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

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

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 \( \vec{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	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 , TwoToFive = 13 , Decay = 5 , Wall = 6 , Thermalization = 7 , HyperSurfaceCrossing = 8 , Bremsstrahlung = 9 , MultiParticleThreeMesonsToOne = 10 , MultiParticleThreeToTwo = 11 , MultiParticleFiveToTwo = 12 , StringSoftSingleDiffractiveAX = 41 , StringSoftSingleDiffractiveXB = 42 , StringSoftDoubleDiffractive = 43 , StringSoftAnnihilation = 44 , StringSoftNonDiffractive = 45 , StringHard = 46 , FailedString = 47 }
	Process Types 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	clebsch_gordan (const int j_a, const int j_b, const int j_c, const int m_a, const int m_b, const int m_c)
	Calculate Clebsch-Gordan coefficient \((-1)^{j_a - j_b + m_c} \sqrt{(2 j_c + 1)} \cdot [Wigner 3J symbol] \). 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...

template<typename T , typename... Args>
std::unique_ptr< T >	make_unique (Args &&... args)
	Definition for make_unique Is in C++14's standard library; necessary for older compilers. More...

double	y_l_0 (int l, double cosx)
	Spherical harmonics Y_2_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)

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 (const double energy, const double momentum_sqr, const double temperature)
	Returns the Maxwell-Boltzmann distribution. 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 [6] 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 [6] 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 [6]. 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 [6]. 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 [40]) 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 [6]. More...

std::ostream &	operator<< (std::ostream &, const EnergyMomentumTensor &)
	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)
	Generate the EventInfo object which is passed to outputs_. 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 bf::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 (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...

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

std::unique_ptr< OutputInterface >	create_oscar_output (const std::string &format, const std::string &content, const bf::path &path, const OutputParameters &out_par)

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 [46]. 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	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_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 [53], 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 [53], eq. More...

double	pp_total (double mandelstam_s)
	pp total cross section parametrization Sources: low-p: Cugnon:1996kh [15] highest-p: Buss:2011mx [10] More...

double	np_elastic (double mandelstam_s)
	np elastic cross section parametrization Source: Weil:2013mya [53], eq. More...

double	np_total (double mandelstam_s)
	np total cross section parametrization Sources: low-p: Cugnon:1996kh [15] highest-p: Buss:2011mx [10] More...

double	ppbar_elastic (double mandelstam_s)
	ppbar elastic cross section parametrization Source: Bass:1998ca [4] More...

double	ppbar_total (double mandelstam_s)
	ppbar total cross section parametrization Source: Bass:1998ca [4] 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 [35]. 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 [10], 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 [10], B.3.9. More...

double	kminusn_elastic_background (double mandelstam_s)
	K- n elastic background cross section parametrization Source: Buss:2011mx [10], B.3.9. More...

double	k0p_elastic_background (double mandelstam_s)
	K0 p elastic background cross section parametrization Source: Buss:2011mx [10], B.3.9. More...

double	k0n_elastic_background (double mandelstam_s)
	K0 n elastic background cross section parametrization Source: Buss:2011mx [10], B.3.9. More...

double	kbar0p_elastic_background (double mandelstam_s)
	Kbar0 p elastic background cross section parametrization Source: Buss:2011mx [10], B.3.9. More...

double	kbar0n_elastic_background (double mandelstam_s)
	Kbar0 n elastic background cross section parametrization Source: Buss:2011mx [10], B.3.9. More...

double	kplusp_inelastic_background (double mandelstam_s)
	K+ p inelastic background cross section parametrization Source: Buss:2011mx [10], B.3.8. More...

double	kplusn_inelastic_background (double mandelstam_s)
	K+ n inelastic background cross section parametrization Source: Buss:2011mx [10], 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 [21]). More...

double	kminusp_piplussigmaminus (double sqrts)
	K- p <-> pi+ Sigma- cross section parametrization Taken from UrQMD (Graef:2014mra [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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 [21]). 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...

Parity	operator- (Parity p)

Parity	operator* (Parity x, Parity y)

void	operator*= (Parity &x, Parity y)

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)
	Updates the momenta of all particles at the current time step according to the equations of motion: More...

std::pair< std::string, std::string >	load_particles_and_decaymodes (const char particles_file, const char decaymodes_file)
	Loads particles and decaymodes from provided files particles_file and decaymodes_file. More...

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

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 \vec{a} \). More...

ThreeVector	operator* (const double &a, ThreeVector b)
	multiply a three-vector by constant factor \( a \vec{b} \). More...

double	operator* (ThreeVector a, const ThreeVector &b)

ThreeVector	operator/ (ThreeVector a, const double &b)
	divide a three-vector by constant factor \( \vec{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)

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 bf::path	generate_tabulation_path (const bf::path &dir, const std::string &prefix, const std::string &res_name)

void	cache_integral (std::unordered_map< std::string, Tabulation > &tabulations, const bf::path &dir, sha256::Hash hash, const IsoParticleType &part, const IsoParticleType &res, const IsoParticleType *antires, bool unstable)

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	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	a1_mass = 1.26
	a1 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 >	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 data on K- p total cross section: momentum in lab frame. More...

const std::initializer_list< double >	KMINUSP_TOT_SIG
	PDG 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...

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	LPythia = LogArea::Pythia::id

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

static constexpr int	HyperSurfaceCrossing = 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	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	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 521 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 63 of file file.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 38 of file crosssectionsphoton.h.

38 { Analytic };

smash::ComputationMethod::Analytic

@ 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 24 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 32 of file particletype.h.

                            {
   All,
   Hadronic,
   Dileptons
 };

◆ ProcessType

enum smash::ProcessType

strong

Process Types are used to identify the type of the process.

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

Enumerator
None	nothing
Elastic	elastic scattering: particles remain the same, only momenta change
TwoToOne	resonance formation (2->1)
TwoToTwo	2->2 inelastic scattering
TwoToThree	2->3 scattering
TwoToFive	2->5 scattering
Decay	resonance decay
Wall	box wall crossing
Thermalization	forced thermalization, many particles are replaced by a thermalized ensemble
HyperSurfaceCrossing	Hypersurface crossing Particles are removed from the evolution and printed to a separate output to serve as initial conditions for hybrid models.
Bremsstrahlung	bremsstrahlung process: a + b -> a + b + photon
MultiParticleThreeMesonsToOne	multi particle scattering
MultiParticleThreeToTwo
MultiParticleFiveToTwo
StringSoftSingleDiffractiveAX	(41-45) 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. single diffractive AB->AX. Both quark and anti-/di-quark taken from B.
StringSoftSingleDiffractiveXB	single diffractive AB->XB. Both quark and anti-/di-quark taken from A. It makes sense to distinguish it from AB->AX, because A and B can be particles of different types, for example, a pion and a proton. It matters then, whether the pion creates a string or the proton.
StringSoftDoubleDiffractive	double diffractive. Two strings are formed, one from A and one from B.
StringSoftAnnihilation	a special case of baryon-antibaryon annihilation. One pair qqbar annihilates immediately and then two strings are formed.
StringSoftNonDiffractive	non-diffractive. Two strings are formed both have ends in A and B.
StringHard	hard string process involving 2->2 QCD process by PYTHIA. Here quarks do not simply form a string. They actually scatter on parton level first.
FailedString	Soft String NNbar annihilation process can fail by lack of energy. This is a tag we add to avoid mislabeling the events.

Definition at line 25 of file processbranch.h.

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

◆ 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 322 of file grid.cc.

322 { PlusLength, No, MinusLength };

OutputOnlyFinal::No

@ No

Print initial, intermediate and final-state particles.

smash::NeedsToWrap::PlusLength

@ PlusLength

smash::NeedsToWrap::MinusLength

@ 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 514 of file action.h.

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

◆ enforce_periodic_boundaries()

template<typename Iterator >

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

static

Enforces periodic boundaries on the given collection of values.

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

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

Template Parameters

Iterator Type of the iterator.

Parameters

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

Returns: Whether a correction was done.

Definition at line 53 of file algorithms.h.

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

Here is the caller graph for this function:

◆ all_of()

template<typename Container , typename UnaryPredicate >

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

inline

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

Template Parameters

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

Parameters

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

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

Definition at line 80 of file algorithms.h.

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

Here is the caller graph for this function:

◆ for_each()

template<typename Container , typename UnaryFunction >

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

inline

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

Template Parameters

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

Parameters

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

Returns: The function that was applied to all elements.

Definition at line 96 of file algorithms.h.

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

Here is the caller graph for this function:

◆ dedup_avg()

template<typename T >

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

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

Assumes (x, y) is sorted.

Template Parameters

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

Parameters

x	x-values.
y	y-values.

Returns: New x and y values as a pair of vectors.

Definition at line 65 of file average.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clebsch_gordan()

double smash::clebsch_gordan	(	const int	j_a,
		const int	j_b,
		const int	j_c,
		const int	m_a,
		const int	m_b,
		const int	m_c
	)

Calculate Clebsch-Gordan coefficient \((-1)^{j_a - j_b + m_c} \sqrt{(2 j_c + 1)} \cdot [Wigner 3J symbol] \).

Parameters

[in]	j_a	spin of first particle
[in]	j_b	spin of second particle
[in]	j_c	spin of resonance
[in]	m_a	isospin of first particle
[in]	m_b	isospin of second particle
[in]	m_c	isospin of resonance

Returns: Clebsch-Gordan coefficient for coupling of particles a, b and c

Note that the calculation assumes that the spin/isospin values (j/m) have been multiplied by two (in order to be integer).

Definition at line 18 of file clebschgordan.cc.

                                                                    {
   const double wigner_3j = gsl_sf_coupling_3j(j_a, j_b, j_c, m_a, m_b, -m_c);
   if (std::abs(wigner_3j) < really_small) {
     return 0.;
   }
   assert((j_a - j_b + m_c) % 2 == 0);
   const int j = (j_a - j_b + m_c) / 2;
   double result = std::sqrt(j_c + 1) * wigner_3j;
   result *= (j % 2 == 0) * 2 - 1;  // == (-1)**j
  
   logg[LResonances].debug("CG: ", result, " I1: ", j_a, " I2: ", j_b,
                           " IR: ", j_c, " iz1: ", m_a, " iz2: ", m_b,
                           " izR: ", m_c);
  
   return result;
 }

Here is the caller graph for this function:

◆ isospin_clebsch_gordan_sqr_2to1()

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

inline

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

Parameters

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

Returns: Clebsch-Gordan squared for 2->1 reaction

Definition at line 42 of file clebschgordan.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isospin_clebsch_gordan_sqr_3to1()

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

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

Parameters

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

Returns: Clebsch-Gordan squared for 3->1 reaction

Definition at line 51 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 = clebsch_gordan(I_ab, p_c.isospin(), Res.isospin(), I_abz,
                                    p_c.isospin3(), Res.isospin3()) *
                     clebsch_gordan(p_a.isospin(), p_b.isospin(), I_ab,
                                    p_a.isospin3(), p_b.isospin3(), I_abz);
   return cg * cg;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isospin_clebsch_gordan_sqr_2to2()

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

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

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

Parameters

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

Returns: Clebsch-Gordan squared for 2->2 reaction

Definition at line 84 of file clebschgordan.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cut_off()

double smash::cut_off ( const double sigma_mb )

Cross section after cut off.

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

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

Parameters

[in] sigma_mb cross section before cut off [mb]

Returns: Cross section after cut off [mb]

Definition at line 53 of file crosssectionsphoton.cc.

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

Here is the caller graph for this function:

◆ make_unique()

template<typename T , typename... Args>

std::unique_ptr<T> smash::make_unique ( Args &&... args )

inline

Definition for make_unique Is in C++14's standard library; necessary for older compilers.

See also: http://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique

Definition at line 26 of file cxx14compat.h.

                                                      {
   return std::unique_ptr<T>{new T{std::forward<Args>(args)...}};
 }

Here is the caller graph for this function:

◆ y_l_0()

double smash::y_l_0	(	int	l,
		double	cosx
	)

Spherical harmonics Y_2_0 and Y_4_0.

Parameters

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

Returns: Value of the corresponding spherical harmonic

Exceptions

domain_error if unsupported l is encountered

Definition at line 277 of file deformednucleus.cc.

                                  {
   if (l == 2) {
     return (1. / 4) * std::sqrt(5 / M_PI) * (3. * (cosx * cosx) - 1);
   } else if (l == 4) {
     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_0.");
   }
 }

Here is the caller graph for this function:

◆ operator<<() [1/11]

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

Create the output operator for the densities.

Parameters

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

Returns: An output operator for the densities

Definition at line 276 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 16 of file density.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ smearing_factor_norm()

double smash::smearing_factor_norm ( const double two_sigma_sqr )

inline

Norm of the Gaussian smearing function.

Parameters

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

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

Definition at line 77 of file density.h.

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

Here is the caller graph for this function:

◆ smearing_factor_rcut_correction()

double smash::smearing_factor_rcut_correction ( const double rcut_in_sigma )

inline

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

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

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

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

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

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

Parameters

[in] rcut_in_sigma \( a = r_{cut} / \sigma\)

Returns: \( g(a) \)

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

Here is the caller graph for this function:

◆ unnormalized_smearing_factor()

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

Implements gaussian smearing for any quantity.

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

Parameters

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

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

Definition at line 37 of file density.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ current_eckart() [1/2]

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

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

\[j^{\mu} = (\sqrt{2\pi} \sigma )^{-3} \sum_{i=1}^N C_i u^{\mu}_i exp \left(- \frac{(\vec r -\vec r_i + \frac{\gamma_i^2}{1 + \gamma_i} \vec \beta_i (\vec \beta_i, \vec r - \vec r_i))^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, \( \vec{\nabla}\cdot j^0 \) or a 0 3-vector, \( \vec{\nabla} \times \vec{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 167 of file density.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ current_eckart() [2/2]

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

convenience overload of the above (ParticleList -> Particles)

Definition at line 175 of file density.cc.

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

Here is the call graph for this function:

◆ update_lattice() [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 536 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)
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

◆ breit_wigner()

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

Returns a relativistic Breit-Wigner distribution.

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

Parameters

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

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

Definition at line 24 of file distributions.cc.

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

Here is the caller graph for this function:

◆ breit_wigner_nonrel()

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

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

Parameters

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

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

Definition at line 31 of file distributions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cauchy()

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

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

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

Parameters

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

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

Definition at line 36 of file distributions.cc.

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

Here is the caller graph for this function:

◆ density_integrand()

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

Returns the Maxwell-Boltzmann distribution.

Todo:: rename the following 4 functions to make clear what they are and check if they are actually used

Parameters

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

Returns: \(4\pi p^2 \exp{-\frac{E}{T}}\)

Definition at line 42 of file distributions.cc.

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

◆ 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 47 of file distributions.cc.

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

Here is the caller graph for this function:

◆ density_integrand_1M_IC()

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

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

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 53 of file distributions.cc.

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

Here is the caller graph for this function:

◆ density_integrand_2M_IC()

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

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

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 60 of file distributions.cc.

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

Here is the caller graph for this function:

◆ juttner_distribution_func()

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

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

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

Parameters

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

Returns: the Juttner distribution function

Definition at line 79 of file distributions.cc.

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

Here is the caller graph for this function:

◆ sample_momenta_non_eq_mass()

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

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

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

See also: density_integrand_mass

Parameters

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

Returns: one possible momentum between mass and 50 GeV

Definition at line 91 of file distributions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sample_momenta_1M_IC()

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

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

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 125 of file distributions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sample_momenta_2M_IC()

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

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

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 162 of file distributions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sample_momenta_from_thermal()

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

Samples a momentum from the Maxwell-Boltzmann (thermal) distribution in a faster way, given by Scott Pratt (see Pratt:2014vja [40]) 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 199 of file distributions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sample_momenta_IC_ES()

double smash::sample_momenta_IC_ES ( const double temperature )

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

Parameters

[in] temperature The temperature for the distribution [GeV]

Returns: Radial momentum

Definition at line 248 of file distributions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator+() [1/3]

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

inline

Direct addition operator.

Definition at line 163 of file energymomentumtensor.h.

◆ operator-() [1/4]

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

inline

Direct subtraction operator.

Definition at line 177 of file energymomentumtensor.h.

◆ operator*() [1/8]

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

inline

Direct multiplication operator.

Definition at line 190 of file energymomentumtensor.h.

◆ operator*() [2/8]

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

inline

Direct multiplication operator.

Definition at line 195 of file energymomentumtensor.h.

◆ operator/() [1/3]

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

inline

Direct division operator.

Definition at line 207 of file energymomentumtensor.h.

◆ 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 634 of file experiment.h.

                                                                     {
   out << "End time: " << e.end_time_ << " fm/c\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 [38]). If the cross sections are globally scaled, the maximum cross section is also scaled.

Definition at line 474 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["Modi"].remove_all_but(modus_chooser);
  
   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/c, reasonable value will be set at event initialization
    */
   const double dt = config.take({"General", "Delta_Time"}, 1.);
   const double t_end = config.read({"General", "End_Time"});
  
   // 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 recommended in the boxmodus.");
   }
  
   // 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 = make_unique<CustomClock>(output_times);
   } else {
     const double output_dt = config.take({"Output", "Output_Interval"}, t_end);
     output_clock = make_unique<UniformClock>(0.0, output_dt);
   }
  
   // Add proper error messages if photons are not configured properly.
   // 1) Missing Photon config section.
   if (config["Output"].has_value({"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["Output"].has_value({"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["Output"].has_value({"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["Output"].has_value({"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.");
     }
   }
  
   auto config_coll = config["Collision_Term"];
   /* Elastic collisions between the nucleons with the square root s
    * below low_snn_cut are excluded. */
   const double low_snn_cut =
       config_coll.take({"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_coll.take({"Cross_Section_Scaling"}, 1.0);
  
   const auto criterion =
       config_coll.take({"Collision_Criterion"}, CollisionCriterion::Covariant);
  
   if (config_coll.has_value({"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_coll.has_value({"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;
  
   bool cll_in_nucleus =
       config.take({"Modi", "Collider", "Collisions_Within_Nucleus"}, false);
   double maximum_cross_section = config_coll.take(
       {"Maximum_Cross_Section"}, maximum_cross_section_default);
   maximum_cross_section *= scale_xs;
   return {make_unique<UniformClock>(0.0, dt),
           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_coll.take({"Two_to_One"}, true),
           config_coll.take({"Included_2to2"}, ReactionsBitSet().set()),
           config_coll.take({"Multi_Particle_Reactions"},
                            MultiParticleReactionsBitSet().reset()),
           config_coll.take({"Strings"}, modus_chooser != "Box"),
           config_coll.take({"Use_AQM"}, true),
           config_coll.take({"Resonance_Lifetime_Modifier"}, 1.),
           config_coll.take({"Strings_with_Probability"}, true),
           config_coll.take({"NNbar_Treatment"}, NNbarTreatment::Strings),
           low_snn_cut,
           potential_affect_threshold,
           box_length,
           maximum_cross_section,
           config_coll.take({"Fixed_Min_Cell_Length"}, 2.5),
           cll_in_nucleus,
           scale_xs,
           config_coll.take({"Additional_Elastic_Cross_Section"}, 0.0),
           only_participants};
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hline()

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

String representing a horizontal line.

Here is the caller graph for this function:

◆ format_measurements()

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

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

Parameters

[in]	ensembles	The simulated particles: one Particles object per ensemble. The information about particles is used to check the conservation of the total energy and momentum as well as print other useful information.
[in]	scatterings_this_interval	Number of the scatterings occur within the current timestep.
[in]	conserved_initial	Initial quantum numbers needed to check the conservations.
[in]	time_start	Moment in the REAL WORLD when SMASH starts to run [s].
[in]	time	Current moment in SMASH [fm/c].
[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/c]', '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 679 of file experiment.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_mean_field_energy()

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

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

Using the baryon density lattice is necessary.

Parameters

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

Returns: Total mean field energy in the Box.

Definition at line 727 of file experiment.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_event_info()

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

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

Definition at line 947 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};
   return event_info;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_interactions_total()

void smash::check_interactions_total ( uint64_t interactions_total )

inline

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

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

Parameters

[in] interactions_total Total interaction number

Definition at line 2328 of file experiment.h.

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

Here is the caller graph for this function:

◆ update_fields_lattice()

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

Updates the contents on the lattice of FieldsOnLattice type.

Parameters

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

Definition at line 14 of file fields.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fopen()

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

Open a file with given mode.

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

Parameters

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

Returns: The constructed FilePtr.

Definition at line 14 of file file.cc.

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

Here is the caller graph for this function:

◆ blatt_weisskopf_sqr()

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

inline

Returns: the squared Blatt-Weisskopf functions, which influence the mass dependence of the decay widths. See e.g. Effenberger:1999wlg [18], 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 33 of file formfactors.h.

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

Here is the caller graph for this function:

◆ post_ff_sqr()

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

inline

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

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

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

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

Here is the caller graph for this function:

◆ em_form_factor_ps()

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

inline

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

For the π⁰ see Landsberg:1986fd [30]. For the η the Lambda parameter is fitted to NA60 data, see Arnaldi:2009aa [3].

Parameters

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

Definition at line 97 of file formfactors.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ em_form_factor_sqr_vec()

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

inline

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

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

Parameters

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

Definition at line 120 of file formfactors.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ form_factor_delta()

double smash::form_factor_delta ( 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 144 of file formfactors.h.

                                           {
   SMASH_UNUSED(m);
   return 3.12;
 }

Here is the caller graph for this function:

◆ operator+() [2/3]

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

inline

add two FourVectors

Parameters

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

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

Definition at line 371 of file fourvector.h.

◆ 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 392 of file fourvector.h.

◆ 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 413 of file fourvector.h.

◆ 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 424 of file fourvector.h.

◆ 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 446 of file fourvector.h.

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

40 { return false; }

Here is the caller graph for this function:

◆ setup_default_float_traps()

void smash::setup_default_float_traps ( )

Setup the floating-point traps used throughout SMASH.

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

Definition at line 69 of file fpenvironment.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ without_float_traps()

template<typename F >

void smash::without_float_traps ( F && f )

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

Example:

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

Parameters

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

Template Parameters

F	type of the functor

Definition at line 129 of file fpenvironment.h.

                                 {
   DisableFloatTraps guard;
   f();
 }

◆ operator<<() [3/11]

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

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

Parameters

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

Definition at line 98 of file grandcan_thermalizer.cc.

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

Here is the call graph for this function:

◆ build_error_string()

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

inline

Builds a meaningful error message.

Takes the message and quotes the Line where the error occurs

Parameters

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

Definition at line 42 of file inputfunctions.h.

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

Here is the caller graph for this function:

◆ line_parser()

std::vector< Line > smash::line_parser ( const std::string & input )

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

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

Parameters

[in] input an lvalue reference to an input stream

Definition at line 21 of file inputfunctions.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ensure_all_read()

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

inline

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

Definition at line 59 of file inputfunctions.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_all()

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

inline

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

file) into one string.

Parameters

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

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

Definition at line 80 of file inputfunctions.h.

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

Here is the caller graph for this function:

◆ has_crlf_line_ending()

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

inline

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

This may happen when a file was edited on Windows.

Parameters

[in] in Input string

Returns: True if \r\n was found, else false

Definition at line 91 of file inputfunctions.h.

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

Here is the caller graph for this function:

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

Here is the caller graph for this function:

◆ generate_sort_permutation()

template<typename T , typename Cmp >

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

Calculate the permutations necessary for sorting a vector.

Template Parameters

Cmp	Type of comparison function.

Parameters

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

Returns: Vector of indices into the original vector.

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

Here is the caller graph for this function:

◆ apply_permutation()

template<typename T >

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

Apply a permutation to a vector.

Template Parameters

T	Type of values to be permuted.

Parameters

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

Returns: Permuted vector.

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

Here is the caller graph for this function:

◆ check_duplicates()

template<typename T >

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

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

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

Here is the caller graph for this function:

◆ find_index()

template<typename T >

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

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

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

This assumes v is sorted and uses a binary search.

Template Parameters

T	Type of values to be compared to x.

Parameters

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

Returns: Largest index corresponding to value below upper bound.

Example:

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

0

find_index(x, 3)

1

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

Here is the caller graph for this function:

◆ center_of_velocity_v()

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

inline

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

Parameters

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

Definition at line 26 of file kinematics.h.

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

Here is the caller graph for this function:

◆ fixed_target_projectile_v()

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

inline

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

Parameters

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

Definition at line 39 of file kinematics.h.

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

Here is the caller graph for this function:

◆ pCM_sqr_from_s()

template<typename T >

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

noexcept

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

Parameters

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

Definition at line 52 of file kinematics.h.

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

Here is the caller graph for this function:

◆ pCM_from_s()

template<typename T >

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

noexcept

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

Parameters

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

Definition at line 66 of file kinematics.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pCM()

template<typename T >

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

noexcept

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

Parameters

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

Definition at line 79 of file kinematics.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pCM_sqr()

template<typename T >

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

noexcept

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

Parameters

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

Definition at line 91 of file kinematics.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_t_range()

template<typename T >

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

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

(46.34).

Parameters

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

Returns: array consisting of {t_min, t_max}

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

Definition at line 109 of file kinematics.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_energy()

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

inlinestatic

Helper function for plab_from_s.

Parameters

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

Definition at line 127 of file kinematics.h.

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

Here is the caller graph for this function:

◆ check_radicand()

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

inlinestatic

Helper function for plab_from_s.

Parameters

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

Definition at line 142 of file kinematics.h.

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

Here is the caller graph for this function:

◆ plab_from_s() [1/3]

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

inline

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

This assumes both particles have the given mass.

Parameters

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

Returns: Momentum of the projectile in the lab frame [GeV]

Definition at line 157 of file kinematics.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ plab_from_s() [2/3]

double smash::plab_from_s ( double mandelstam_s )

inline

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

This assumes both particles have the mass of a nucleon.

Parameters

[in] mandelstam_s The Mandelstam variable s [GeV^2]

Returns: Momentum of the projectile in the lab frame [GeV]

Definition at line 173 of file kinematics.h.

                                                {
   return plab_from_s(mandelstam_s, nucleon_mass);
 }

Here is the call graph for this function:

◆ plab_from_s() [3/3]

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

inline

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

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

Parameters

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

Returns: momentum of the projectile in the lab frame [GeV]

Definition at line 185 of file kinematics.h.

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

Here is the call graph for this function:

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

Here is the caller graph for this function:

◆ s_from_Etot() [2/2]

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

inline

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

Parameters

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

Returns: Mandelstam-s [GeV^2]

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ s_from_Ekin() [2/2]

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

inline

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

Parameters

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

Returns: Mandelstam-s [GeV^2]

Definition at line 252 of file kinematics.h.

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

Here is the call graph for this function:

◆ s_from_plab() [1/2]

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

inline

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

Parameters

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

Returns: The Mandelstam variable s [GeV^2]

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

Here is the caller graph for this function:

◆ s_from_plab() [2/2]

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

inline

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

Parameters

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

Returns: Mandelstam-s [GeV^2]

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

Here is the call graph for this function:

◆ smooth()

template<typename T >

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

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

Parameters

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

Returns: Smoothed y-values.

References:

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

Definition at line 289 of file lowess.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

Here is the caller graph for this function:

◆ xs_high_energy()

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

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

This function is a utility function called from specific parametrizations.

Parameters

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

Returns: the parametrized cross-section [mb]

Definition at line 29 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ pp_high_energy()

double smash::pp_high_energy ( double mandelstam_s )

pp total cross section at high energies

See also: xs_high_energy

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 43 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ppbar_high_energy()

double smash::ppbar_high_energy ( double mandelstam_s )

ppbar total cross section at high energies

See also: xs_high_energy

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 47 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ np_high_energy()

double smash::np_high_energy ( double mandelstam_s )

np total cross section at high energies

See also: xs_high_energy

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 51 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ npbar_high_energy()

double smash::npbar_high_energy ( double mandelstam_s )

npbar total cross section at high energies

See also: xs_high_energy

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 55 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piplusp_high_energy()

double smash::piplusp_high_energy ( double mandelstam_s )

pi+p total cross section at high energies

See also: xs_high_energy

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 59 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piminusp_high_energy()

double smash::piminusp_high_energy ( double mandelstam_s )

pi-p total cross section at high energies

See also: xs_high_energy

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 63 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xs_ppbar_annihilation()

double smash::xs_ppbar_annihilation ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 67 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ xs_string_hard()

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

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

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

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

Here is the caller graph for this function:

◆ NN_string_hard()

double smash::NN_string_hard ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

See also: xs_string_hard

Definition at line 90 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Npi_string_hard()

double smash::Npi_string_hard ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

See also: xs_string_hard

Definition at line 94 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pipi_string_hard()

double smash::pipi_string_hard ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

See also: xs_string_hard

Definition at line 98 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piplusp_elastic_AQM()

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piplusp_elastic()

double smash::piplusp_elastic ( double mandelstam_s )

pi+p elastic cross section parametrization, PDG data.

Source: GiBUU:parametrizationBarMes_HighEnergy.f90

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 139 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 =
         make_unique<InterpolateDataSpline>(x, y);
   }
   sigma -= (*piplusp_elastic_res_interpolation)(mandelstam_s);
   if (sigma < 0) {
     sigma = really_small;
   }
   return sigma;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piplusp_sigmapluskplus_pdg()

double smash::piplusp_sigmapluskplus_pdg ( double mandelstam_s )

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

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

Definition at line 173 of file parametrizations.cc.

                                                        {
   if (piplusp_sigmapluskplus_interpolation == nullptr) {
     std::vector<double> x = PIPLUSP_SIGMAPLUSKPLUS_P_LAB;
     std::vector<double> y = PIPLUSP_SIGMAPLUSKPLUS_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.2, 5);
     piplusp_sigmapluskplus_interpolation =
         make_unique<InterpolateDataLinear<double>>(dedup_x, dedup_y);
   }
   const double p_lab = plab_from_s(mandelstam_s, pion_mass, nucleon_mass);
   return (*piplusp_sigmapluskplus_interpolation)(p_lab);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piminusp_elastic()

double smash::piminusp_elastic ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 208 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;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     piminusp_elastic_res_interpolation =
         make_unique<InterpolateDataSpline>(dedup_x, dedup_y);
   }
   sigma -= (*piminusp_elastic_res_interpolation)(mandelstam_s);
   if (sigma < 0) {
     sigma = really_small;
   }
   return sigma;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piminusp_lambdak0_pdg()

double smash::piminusp_lambdak0_pdg ( double mandelstam_s )

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

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

Definition at line 254 of file parametrizations.cc.

                                                   {
   if (piminusp_lambdak0_interpolation == nullptr) {
     std::vector<double> x = PIMINUSP_LAMBDAK0_P_LAB;
     std::vector<double> y = PIMINUSP_LAMBDAK0_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
     piminusp_lambdak0_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piminusp_sigmaminuskplus_pdg()

double smash::piminusp_sigmaminuskplus_pdg ( double mandelstam_s )

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

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

Definition at line 274 of file parametrizations.cc.

                                                          {
   if (piminusp_sigmaminuskplus_interpolation == nullptr) {
     std::vector<double> x = PIMINUSP_SIGMAMINUSKPLUS_P_LAB;
     std::vector<double> y = PIMINUSP_SIGMAMINUSKPLUS_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
     piminusp_sigmaminuskplus_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piminusp_sigma0k0_res()

double smash::piminusp_sigma0k0_res ( double mandelstam_s )

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

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

Definition at line 294 of file parametrizations.cc.

                                                   {
   if (piminusp_sigma0k0_interpolation == nullptr) {
     std::vector<double> x = PIMINUSP_SIGMA0K0_RES_SQRTS;
     std::vector<double> y = PIMINUSP_SIGMA0K0_RES_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
     piminusp_sigma0k0_interpolation =
         make_unique<InterpolateDataLinear<double>>(dedup_x, dedup_y);
   }
   const double sqrts = std::sqrt(mandelstam_s);
   return (*piminusp_sigma0k0_interpolation)(sqrts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pp_elastic()

double smash::pp_elastic ( double mandelstam_s )

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

(44)

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 309 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pp_elastic_high_energy()

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

pp elastic cross section parametrization, with only the high energy part generalized to all energy regimes (used for AQM) Source: Weil:2013mya [53], 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 328 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pp_total()

double smash::pp_total ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 336 of file parametrizations.cc.

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

Here is the call graph for this function:

◆ np_elastic()

double smash::np_elastic ( double mandelstam_s )

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

(45)

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 352 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ np_total()

double smash::np_total ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 371 of file parametrizations.cc.

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

Here is the call graph for this function:

◆ ppbar_elastic()

double smash::ppbar_elastic ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 387 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ppbar_total()

double smash::ppbar_total ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 404 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deuteron_pion_elastic()

double smash::deuteron_pion_elastic ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 421 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ deuteron_nucleon_elastic()

double smash::deuteron_nucleon_elastic ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kplusp_elastic_background()

double smash::kplusp_elastic_background ( double mandelstam_s )

K+ p elastic background cross section parametrization.

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 432 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kplusn_elastic_background()

double smash::kplusn_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 445 of file parametrizations.cc.

                                                       {
   return 0.25 * kplusp_elastic_background(mandelstam_s);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kplusn_k0p()

double smash::kplusn_k0p ( double mandelstam_s )

K+ n charge exchange cross section parametrization.

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 449 of file parametrizations.cc.

                                        {
   return 0.25 * kplusp_elastic_background(mandelstam_s);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_elastic_background()

double smash::kminusp_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusn_elastic_background()

double smash::kminusn_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 517 of file parametrizations.cc.

517 { return 4.0; }

Here is the caller graph for this function:

◆ k0p_elastic_background()

double smash::k0p_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 519 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ k0n_elastic_background()

double smash::k0n_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 524 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kbar0p_elastic_background()

double smash::kbar0p_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 529 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kbar0n_elastic_background()

double smash::kbar0n_elastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 534 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kplusp_inelastic_background()

double smash::kplusp_inelastic_background ( double mandelstam_s )

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

Definition at line 539 of file parametrizations.cc.

                                                         {
   if (kplusp_total_interpolation == nullptr) {
     std::vector<double> x = KPLUSP_TOT_PLAB;
     std::vector<double> y = KPLUSP_TOT_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
     kplusp_total_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kplusn_inelastic_background()

double smash::kplusn_inelastic_background ( double mandelstam_s )

K+ n inelastic background cross section parametrization Source: Buss:2011mx [10], 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 555 of file parametrizations.cc.

                                                         {
   if (kplusn_total_interpolation == nullptr) {
     std::vector<double> x = KPLUSN_TOT_PLAB;
     std::vector<double> y = KPLUSN_TOT_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.05, 5);
     kplusn_total_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_kbar0n()

double smash::kminusp_kbar0n ( double mandelstam_s )

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

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

Parameters

[in] mandelstam_s the rest frame total energy squared [GeV^2]

Returns: the parametrized cross-section [mb]

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_piminussigmaplus()

double smash::kminusp_piminussigmaplus ( double sqrts )

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

Parameters

[in] sqrts the rest frame total energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 690 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_piplussigmaminus()

double smash::kminusp_piplussigmaminus ( double sqrts )

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

Parameters

[in] sqrts the rest frame total energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 694 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_pi0sigma0()

double smash::kminusp_pi0sigma0 ( double sqrts )

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

Parameters

[in] sqrts the rest frame total energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 698 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_pi0lambda()

double smash::kminusp_pi0lambda ( double sqrts )

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

Todo:: clarify this

Parameters

[in] sqrts the rest frame total energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 702 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusn_piminussigma0()

double smash::kminusn_piminussigma0 ( double sqrts )

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

Parameters

[in] sqrts the rest frame total energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 706 of file parametrizations.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusn_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 711 of file parametrizations.cc.

                                            {
   return 2. * kminusp_pi0lambda(sqrts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lambdalambda_ximinusp()

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

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

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

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

Here is the caller graph for this function:

◆ lambdalambda_xi0n()

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

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

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

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

Here is the call graph for this function:

◆ lambdasigmaplus_xi0p()

double smash::lambdasigmaplus_xi0p ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 727 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ lambdasigmaminus_ximinusn()

double smash::lambdasigmaminus_ximinusn ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 732 of file parametrizations.cc.

                                                       {
   return lambdasigmaplus_xi0p(sqrts_sqrts0);
 }

Here is the call graph for this function:

◆ lambdasigma0_ximinusp()

double smash::lambdasigma0_ximinusp ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 736 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ lambdasigma0_xi0n()

double smash::lambdasigma0_xi0n ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 745 of file parametrizations.cc.

                                               {
   return lambdasigma0_ximinusp(sqrts_sqrts0);
 }

Here is the call graph for this function:

◆ sigma0sigma0_ximinusp()

double smash::sigma0sigma0_ximinusp ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 749 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ sigma0sigma0_xi0n()

double smash::sigma0sigma0_xi0n ( double sqrts_sqrts0 )

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

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

                                               {
   return sigma0sigma0_ximinusp(sqrts_sqrts0);
 }

Here is the call graph for this function:

◆ sigmaplussigmaminus_xi0p()

double smash::sigmaplussigmaminus_xi0p ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 762 of file parametrizations.cc.

                                                      {
   return 4 * sigma0sigma0_ximinusp(sqrts_sqrts0);
 }

Here is the call graph for this function:

◆ sigma0sigmaminus_ximinusn()

double smash::sigma0sigmaminus_ximinusn ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 766 of file parametrizations.cc.

                                                       {
   return 4 * sigma0sigma0_ximinusp(sqrts_sqrts0);
 }

Here is the call graph for this function:

◆ sigmaplussigmaminus_ximinusp()

double smash::sigmaplussigmaminus_ximinusp ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 770 of file parametrizations.cc.

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

Here is the caller graph for this function:

◆ sigmaplussigmaminus_xi0n()

double smash::sigmaplussigmaminus_xi0n ( double sqrts_sqrts0 )

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

Parameters

[in] sqrts_sqrts0 the rest frame total energy minus threshold energy [GeV]

Returns: the parametrized cross-section [mb]

Definition at line 774 of file parametrizations.cc.

                                                      {
   return sigmaplussigmaminus_ximinusp(sqrts_sqrts0);
 }

Here is the call graph for this function:

◆ operator-() [3/4]

Parity smash::operator- ( Parity p )

inline

Parameters

p	Given parity.

Returns: Inverted parity.

Definition at line 45 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 62 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 75 of file particletype.h.

                                             {
   if (x == y) {
     x = Parity::Pos;
   } else {
     x = Parity::Neg;
   }
 }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_lepton_pair()

bool smash::has_lepton_pair	(	const PdgCode	pdg1,
		const PdgCode	pdg2,
		const PdgCode	pdg3
	)

inline

Returns: if two of the three given particles represent a lepton pair (e+e- or mu+mu-).

Definition at line 990 of file pdgcode.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pack()

constexpr uint64_t smash::pack	(	int32_t	x,
		int32_t	y
	)

constexpr

Pack two int32_t into an uint64_t.

This is useful for switch statements on pairs.

Parameters

x	First integer to be packed.
y	Second integer to be packed.

Returns: Combined integer.

Definition at line 112 of file pdgcode_constants.h.

                                               {
   return (static_cast<uint64_t>(static_cast<uint32_t>(x)) << 32) |
          static_cast<uint64_t>(static_cast<uint32_t>(y));
   //^ Casting to an intermediate 32-bit integer is important!
 }

Here is the caller graph for this function:

◆ pow_int()

template<class T >

constexpr T smash::pow_int	(	const T	base,
		unsigned const	exponent
	)

inlineconstexpr

Efficient template for calculating integer powers using squaring.

Template Parameters

T	Type that implements multiplication.

Parameters

[in]	base
[in]	exponent

Returns: base^exponent

Definition at line 23 of file pow.h.

                                                                   {
   return (exponent == 0)
              ? 1
              : (exponent % 2 == 0)
                    ? pow_int(base, exponent / 2) * pow_int(base, exponent / 2)
                    : base * pow_int(base, exponent - 1);
 }

Here is the caller graph for this function:

◆ 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 38 of file pow.h.

                                         {
   return pow_int(base, 2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_soft_process()

bool smash::is_string_soft_process ( ProcessType p )

Check if a given process type is a soft string excitation.

Parameters

[in] p The process type

Definition at line 18 of file processbranch.cc.

                                            {
   return p == ProcessType::StringSoftSingleDiffractiveAX ||
          p == ProcessType::StringSoftSingleDiffractiveXB ||
          p == ProcessType::StringSoftDoubleDiffractive ||
          p == ProcessType::StringSoftAnnihilation ||
          p == ProcessType::StringSoftNonDiffractive;
 }

Here is the caller graph for this function:

◆ calc_hubble()

double smash::calc_hubble	(	double	time,
		const ExpansionProperties &	metric
	)

Calculate the Hubble parameter \(H(t)\), which describes how large the expansion flow is.

The flow \(\vec v=H(t) \vec x\) Tindall:2016try [51]

Parameters

[in]	time	time in the computational frame. [fm]
[in]	metric	Struct containing the parameters needed to calculate the metric.

Returns: Hubble parameter [fm^ \({-1}\)]

Definition at line 21 of file propagation.cc.

                                                                    {
   double h;  // Hubble parameter
  
   switch (metric.mode_) {
     case ExpansionMode::NoExpansion:
       h = 0.;
       break;
     case ExpansionMode::MasslessFRW:
       h = metric.b_ / (2 * (metric.b_ * time + 1));
       break;
     case ExpansionMode::MassiveFRW:
       h = 2 * metric.b_ / (3 * (metric.b_ * time + 1));
       break;
     case ExpansionMode::Exponential:
       h = metric.b_ * time;
       break;
     default:
       h = 0.;
   }
  
   return h;
 }

Here is the caller graph for this function:

◆ propagate_straight_line()

double smash::propagate_straight_line	(	Particles *	particles,
		double	to_time,
		const std::vector< FourVector > &	beam_momentum
	)

Propagates the positions of all particles on a straight line to a given moment.

For each particle, the position is shifted:

\[ \vec x^\prime = \vec x + \vec v \Delta t \]

where \(\vec x\) is the current position, \(\vec v\) its velocity and \(\Delta t\) the duration of this timestep.

Parameters

[out]	particles	The particle list in the event
[in]	to_time	final time [fm]
[in]	beam_momentum	This vector of 4-momenta should have non-zero size only if "frozen Fermi motion" is on. The the Fermi momenta are only used for collisions, but not for propagation. In this case beam_momentum is used for propagating the initial nucleons. [GeV]

Returns: dt time interval of propagation which is equal to the difference between the final time and the initial time read from the 4-position of the particle.

Definition at line 44 of file propagation.cc.

                                                                            {
   bool negative_dt_error = false;
   double dt = 0.0;
   for (ParticleData &data : *particles) {
     const double t0 = data.position().x0();
     dt = to_time - t0;
     if (dt < 0.0 && !negative_dt_error) {
       // Print error message once, not for every particle
       negative_dt_error = true;
       logg[LPropagation].error("propagate_straight_line - negative dt = ", dt);
     }
     assert(dt >= 0.0);
     /* "Frozen Fermi motion": Fermi momenta are only used for collisions,
      * but not for propagation. This is done to avoid nucleus flying apart
      * even if potentials are off. Initial nucleons before the first collision
      * are propagated only according to beam momentum.
      * Initial nucleons are distinguished by data.id() < the size of
      * beam_momentum, which is by default zero except for the collider modus
      * with the fermi motion == frozen.
      * todo(m. mayer): improve this condition (see comment #11 issue #4213)*/
     assert(data.id() >= 0);
     const bool avoid_fermi_motion =
         (static_cast<uint64_t>(data.id()) <
          static_cast<uint64_t>(beam_momentum.size())) &&
         (data.get_history().collisions_per_particle == 0);
     ThreeVector v;
     if (avoid_fermi_motion) {
       const FourVector vbeam = beam_momentum[data.id()];
       v = vbeam.velocity();
     } else {
       v = data.velocity();
     }
     const FourVector distance = FourVector(0.0, v * dt);
     logg[LPropagation].debug("Particle ", data, " motion: ", distance);
     FourVector position = data.position() + distance;
     position.set_x0(to_time);
     data.set_4position(position);
   }
   return dt;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_momenta()

void smash::update_momenta	(	std::vector< Particles > &	particles,
		double	dt,
		const Potentials &	pot,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	FB_lat,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	FI3_lat,
		RectangularLattice< std::pair< ThreeVector, ThreeVector >> *	EM_lat
	)

Updates the momenta of all particles at the current time step according to the equations of motion:

\[ \frac{dp}{dt} = \vec E + \vec v \times \vec 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

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 (!pot.use_skyrme() && !pot.use_vdf()) {
         FB = std::make_pair(ThreeVector(0., 0., 0.), ThreeVector(0., 0., 0.));
       }
       if (!pot.use_symmetry()) {
         FI3 = std::make_pair(ThreeVector(0., 0., 0.), ThreeVector(0., 0., 0.));
       }
       if (!use_lattice) {
         const auto tmp = pot.all_forces(r, plist);
         FB = std::make_pair(std::get<0>(tmp), std::get<1>(tmp));
         FI3 = std::make_pair(std::get<2>(tmp), std::get<3>(tmp));
       }
       ThreeVector Force =
           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/c.\n"
         << "In case of Triangular or Discrete smearing you may additionally "
         << "need to increase the number of ensembles or testparticles.";
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_particles_and_decaymodes()

std::pair< std::string, std::string > smash::load_particles_and_decaymodes	(	const char *	particles_file,
		const char *	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 31 of file setup_particles_decaymodes.cc.

                                                              {
   std::string particle_string, decay_string;
   if (particles_file) {
     if (!boost::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(boost::filesystem::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) {
     if (!boost::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(boost::filesystem::ifstream{decaymodes_file});
     if (has_crlf_line_ending(decay_string)) {
       std::stringstream err;
       err << "The decay mode file has CR LF line endings. Please use LF"
              " line endings.";
       throw std::runtime_error(err.str());
     }
   } else {
     decay_string = decaymodes_txt::data;
   }
   return std::make_pair(particle_string, decay_string);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_default_particles_and_decaymodes()

void smash::load_default_particles_and_decaymodes ( )

Loads default smash particle list and decaymodes.

Definition at line 72 of file setup_particles_decaymodes.cc.

                                              {
   const auto pd = load_particles_and_decaymodes(nullptr, nullptr);
   ParticleType::create_type_list(pd.first);
   DecayModes::load_decaymodes(pd.second);
   ParticleType::check_consistency();
 }

Here is the call graph for this function:

◆ trim()

std::string smash::trim ( const std::string & s )

Strip leading and trailing whitespaces.

Parameters

s	String to be trimmed.

Returns: Trimmed string.

Definition at line 75 of file stringfunctions.cc.

                                    {
   const auto begin = s.find_first_not_of(" \t\n\r");
   if (begin == std::string::npos) {
     return {};
   }
   const auto end = s.find_last_not_of(" \t\n\r");
   return s.substr(begin, end - begin + 1);
 }

Here is the caller graph for this function:

◆ remove_substr()

void smash::remove_substr	(	std::string &	s,
		const std::string &	p
	)

Remove all instances of a substring p in a string s.

Parameters

[in,out]	s	String to be searched and modified.
[in]	p	Substring to be removed.

Definition at line 84 of file stringfunctions.cc.

                                                      {
   using str = std::string;
   str::size_type n = p.length();
   for (str::size_type i = s.find(p); i != str::npos; i = s.find(p)) {
     s.erase(i, n);
   }
 }

Here is the caller graph for this function:

◆ isoclean()

void smash::isoclean ( std::string & s )

Remove ⁺, ⁻, ⁰ from string.

Parameters

[in,out] s String to be cleaned.

Definition at line 92 of file stringfunctions.cc.

                             {
   remove_substr(s, "⁺");
   remove_substr(s, "⁻");
   remove_substr(s, "⁰");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ split() [1/2]

std::vector< std::string > smash::split	(	const std::string &	s,
		char	delim
	)

Split string by delimiter.

Parameters

[in]	s	String to be split.
[in]	delim	Splitting delimiter.

Returns: Split string.

Definition at line 120 of file stringfunctions.cc.

                                                            {
   std::vector<std::string> elems;
   split(s, delim, std::back_inserter(elems));
   return elems;
 }

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spec_func_integrand_2res()

double smash::spec_func_integrand_2res	(	double	sqrts,
		double	res_mass_1,
		double	res_mass_2,
		const ParticleType &	t1,
		const ParticleType &	t2
	)

inline

Spectral function integrand for GSL integration, with two resonances in the final state.

The integrand is \( A_1(m_1) A_2(m_2) p_{cm}^f \), where \( m_1 \) and \( m_2 \) are the resonance masses, \( A_1 \) and \( A_2 \) are the spectral functions and \( p_{cm}^f \) is the center-of-mass momentum of the final state.

Parameters

[in]	sqrts	Center-of-mass energy, i.e. sqrt of Mandelstam s [GeV].
[in]	res_mass_1	Actual mass of the first resonance [GeV].
[in]	res_mass_2	Actual mass of the second resonance [GeV].
[in]	t1	Type of the first resonance.
[in]	t2	Type of the second resonance.

Returns: Value of the integrand.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spectral_integral_semistable()

Tabulation smash::spectral_integral_semistable	(	Integrator &	integrate,
		const ParticleType &	resonance,
		const ParticleType &	stable,
		double	range
	)

inline

Create a table for the spectral integral of a resonance and a stable particle.

Parameters

[in,out]	integrate	Numerical integrator.
[in]	resonance	Type of the resonance particle.
[in]	stable	Type of the stable particle.
[in]	range	Distance between tabulation points [GeV].

Returns: Tabulation of the given integral.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spectral_integral_unstable()

Tabulation smash::spectral_integral_unstable	(	Integrator2d &	integrate2d,
		const ParticleType &	res1,
		const ParticleType &	res2,
		double	range
	)

inline

Create a table for the spectral integral of two resonances.

Parameters

[in,out]	integrate2d	Numerical integrator.
[in]	res1	Type of the first resonance particle.
[in]	res2	Type of the second resonance particle.
[in]	range	Distance between tabulation points [GeV].

Returns: Tabulation of the given integral.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator+() [3/3]

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

inline

Returns: sum of two three-vectors \( \vec{a} + \vec{b} \).

Definition at line 190 of file threevector.h.

◆ operator-() [4/4]

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

inline

Returns: difference between two three-vectors \( \vec{a} - \vec{b} \).

Definition at line 203 of file threevector.h.

◆ operator*() [6/8]

ThreeVector smash::operator*	(	ThreeVector	a,
		const double &	b
	)

inline

multiply a three-vector by constant factor \( b \vec{a} \).

Definition at line 216 of file threevector.h.

◆ operator*() [7/8]

ThreeVector smash::operator*	(	const double &	a,
		ThreeVector	b
	)

inline

multiply a three-vector by constant factor \( a \vec{b} \).

Definition at line 222 of file threevector.h.

◆ operator*() [8/8]

double smash::operator*	(	ThreeVector	a,
		const ThreeVector &	b
	)

inline

Returns: inner product of two three-vectors \( \vec{a} \cdot \vec{b} \)

Definition at line 231 of file threevector.h.

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

Here is the call graph for this function:

◆ operator/() [3/3]

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

inline

divide a three-vector by constant factor \( \vec{a} / b \).

Definition at line 254 of file threevector.h.

◆ 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 31 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.insert_jet_) {
     ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_);
     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: clebsch_gordan 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 44 of file clebschgordan.cc.

                                                                           {
   return clebsch_gordan(p_a.isospin(), p_b.isospin(), I_tot, p_a.isospin3(),
                         p_b.isospin3(), I_z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [5/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const ColliderModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The ColliderModus object to write into out

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ detailed_balance_factor_RK()

static double smash::detailed_balance_factor_RK	(	double	sqrts,
		double	pcm,
		const ParticleType &	a,
		const ParticleType &	b,
		const ParticleType &	c,
		const ParticleType &	d
	)

static

Helper function: Calculate the detailed balance factor R such that.

\[ R = \sigma(AB \to CD) / \sigma(CD \to AB) \]

where \(A\) is unstable, \(B\) is a kaon and \(C, D\) are stable.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ detailed_balance_factor_RR()

static double smash::detailed_balance_factor_RR	(	double	sqrts,
		double	pcm,
		const ParticleType &	a,
		const ParticleType &	b,
		const ParticleType &	c,
		const ParticleType &	d
	)

static

Helper function: Calculate the detailed balance factor R such that.

\[ R = \sigma(AB \to CD) / \sigma(CD \to AB) \]

where \(A\) and \(B\) are unstable, and \(C\) and \(D\) are stable.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ append_list()

static void smash::append_list	(	CollisionBranchList &	main_list,
		CollisionBranchList	in_list,
		double	weight = `1.`
	)

static

Helper function: Append a list of processes to another (main) list of processes.

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

Here is the caller graph for this function:

◆ min_angular_momentum() [1/2]

static int smash::min_angular_momentum	(	int	s0,
		int	s1,
		int	s2
	)

static

Definition at line 139 of file decaymodes.cc.

                                                         {
   int min_L = std::min(std::abs(s0 - s1 - s2), std::abs(s0 - s1 + s2));
   min_L = std::min(min_L, std::abs(s0 + s1 - s2));
   if (min_L % 2 != 0) {
     throw std::runtime_error(
         "min_angular_momentum: sum of spins should be integer");
   }
   return min_L / 2.;
 }

Here is the caller graph for this function:

◆ min_angular_momentum() [2/2]

static int smash::min_angular_momentum	(	int	s0,
		int	s1,
		int	s2,
		int	s3
	)

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ integrand_rho_Manley_2res()

static double smash::integrand_rho_Manley_2res	(	double	sqrts,
		double	m1,
		double	m2,
		ParticleTypePtr	t1,
		ParticleTypePtr	t2,
		int	L
	)

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ arrange_particles()

static ParticleTypePtrList& smash::arrange_particles ( ParticleTypePtrList & part_types )

static

Rearrange the particle list such that the first particle is the stable one.

Parameters

[in,out] part_types Particle list to be rearranged.

Returns: Reference to rearranged particle list.

Definition at line 110 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 270 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{(\vec r -\vec r_i + \frac{\gamma_i^2}{1 + \gamma_i} \vec \beta_i (\vec \beta_i, \vec r - \vec r_i))^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, \( \vec{\nabla}\cdot j^0 \) or a 0 3-vector, \( \vec{\nabla} \times \vec{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 67 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();
     }
   }
   return std::make_tuple(rho_eck, (jmu_pos + jmu_neg) * par.norm_factor_sf(),
                          grad_j0, curl_vecj, djmu_dt, djmu_dx, djmu_dy,
                          djmu_dz);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ try_find_private()

static IsoParticleType* smash::try_find_private ( const std::string & name )

static

Helper function for IsoParticleType::try_find and friends.

Definition at line 45 of file isoparticletype.cc.

                                                                 {
   auto found =
       std::lower_bound(iso_type_list.begin(), iso_type_list.end(), name,
                        [](const IsoParticleType &l, const std::string &r) {
                          return l.name() < r;
                        });
   if (found == iso_type_list.end() || found->name() != name) {
     return {};  // The default constructor creates an invalid pointer.
   }
   return &*found;
 }

Here is the caller graph for this function:

◆ multiplet_name()

static std::string smash::multiplet_name ( std::string name )

static

Construct the name-string for an isospin multiplet from the given name-string for the particle.

Parameters

[in] name name-string of the particle

Returns: the name-string for an isospin multiplet

Definition at line 90 of file isoparticletype.cc.

                                                 {
   if (name.find("⁺⁺") != std::string::npos) {
     return name.substr(0, name.length() - sizeof("⁺⁺") + 1);
   } else if (name.find("⁺") != std::string::npos) {
     return name.substr(0, name.length() - sizeof("⁺") + 1);
   } else if (name.find("⁻⁻") != std::string::npos) {
     return name.substr(0, name.length() - sizeof("⁻⁻") + 1);
   } else if (name.find("⁻") != std::string::npos) {
     return name.substr(0, name.length() - sizeof("⁻") + 1);
   } else if (name.find("⁰") != std::string::npos) {
     return name.substr(0, name.length() - sizeof("⁰") + 1);
   } else {
     return name;
   }
 }

Here is the caller graph for this function:

◆ generate_tabulation_path()

static bf::path smash::generate_tabulation_path	(	const bf::path &	dir,
		const std::string &	prefix,
		const std::string &	res_name
	)

static

Definition at line 220 of file isoparticletype.cc.

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

Here is the caller graph for this function:

◆ cache_integral()

void smash::cache_integral	(	std::unordered_map< std::string, Tabulation > &	tabulations,
		const bf::path &	dir,
		sha256::Hash	hash,
		const IsoParticleType &	part,
		const IsoParticleType &	res,
		const IsoParticleType *	antires,
		bool	unstable
	)

inline

Definition at line 226 of file isoparticletype.cc.

                                                                                {
   constexpr double spacing = 2.0;
   constexpr double spacing2d = 3.0;
   const auto path = generate_tabulation_path(dir, part.name_filtered_prime(),
                                              res.name_filtered_prime());
   Tabulation integral;
   if (!dir.empty() && bf::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;
     }
     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));
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [6/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const ListModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The ListModus object to write into out

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

86 {}

Here is the caller graph for this function:

◆ create_all_loggers_impl() [2/2]

template<std::size_t index, int longest_name = find_longest_logger_name<index - 1>()>

std::enable_if<(index != 0)>::type smash::create_all_loggers_impl ( Configuration & config )

inline

Recurse over the log areas in the LogArea::AreaTuple type. (The recursion is ended via the overload above.)

For every entry in the list the corresponding Logger object in logg is set up with area name and verbosity.

Template Parameters

index	Recursion index.
longest_name	Length of longest log area name.

Parameters

[in,out] config Configuration object.

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

Here is the call graph for this function:

◆ operator<<() [7/11]

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

Definition at line 509 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 107 of file parametrizations.cc.

                                                        {
   if (piplusp_elastic_interpolation == nullptr) {
     std::vector<double> x = PIPLUSP_ELASTIC_P_LAB;
     std::vector<double> y = PIPLUSP_ELASTIC_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
     piplusp_elastic_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ piminusp_elastic_pdg()

static double smash::piminusp_elastic_pdg ( double mandelstam_s )

static

Definition at line 193 of file parametrizations.cc.

                                                         {
   if (piminusp_elastic_interpolation == nullptr) {
     std::vector<double> x = PIMINUSP_ELASTIC_P_LAB;
     std::vector<double> y = PIMINUSP_ELASTIC_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.2, 6);
     piminusp_elastic_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ kminusp_elastic_pdg()

static double smash::kminusp_elastic_pdg ( double mandelstam_s )

static

Definition at line 458 of file parametrizations.cc.

                                                        {
   if (kminusp_elastic_interpolation == nullptr) {
     std::vector<double> x = KMINUSP_ELASTIC_P_LAB;
     std::vector<double> y = KMINUSP_ELASTIC_SIG;
     std::vector<double> dedup_x;
     std::vector<double> dedup_y;
     std::tie(dedup_x, dedup_y) = dedup_avg(x, y);
     dedup_y = smooth(dedup_x, dedup_y, 0.1, 5);
     kminusp_elastic_interpolation =
         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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize()

static void smash::initialize ( std::unordered_map< std::pair< uint64_t, uint64_t >, double, pair_hash > & ratios )

static

Calculate and store isospin ratios for K N -> K Delta reactions.

See the documentation of KaonNucleonRatios for details.

Parameters

[in] ratios An empty map where the ratios for K N -> K Delta reactions are stored.

Definition at line 580 of file parametrizations.cc.

                                                               {
   const auto& type_p = ParticleType::find(pdg::p);
   const auto& type_n = ParticleType::find(pdg::n);
   const auto& type_K_p = ParticleType::find(pdg::K_p);
   const auto& type_K_z = ParticleType::find(pdg::K_z);
   const auto& type_Delta_pp = ParticleType::find(pdg::Delta_pp);
   const auto& type_Delta_p = ParticleType::find(pdg::Delta_p);
   const auto& type_Delta_z = ParticleType::find(pdg::Delta_z);
   const auto& type_Delta_m = ParticleType::find(pdg::Delta_m);
  
   /* Store the isospin ratio of the given reaction relative to all other
    * possible isospin-symmetric reactions. */
   auto add_to_ratios = [&](const ParticleType& a, const ParticleType& b,
                            const ParticleType& c, const ParticleType& d,
                            double weight_numerator, double weight_other) {
     assert(weight_numerator + weight_other != 0);
     const auto key =
         std::make_pair(pack(a.pdgcode().code(), b.pdgcode().code()),
                        pack(c.pdgcode().code(), d.pdgcode().code()));
     const double ratio = weight_numerator / (weight_numerator + weight_other);
     ratios[key] = ratio;
   };
  
   /* All inelastic channels are K N -> K Delta -> K pi N or charge exchange,
    * with identical cross section, weighted by the isospin factor.
    *
    * For charge exchange, the isospin factors are 1,
    * so they are excluded here. */
   {
     const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
         type_p, type_K_p, type_K_z, type_Delta_pp);
     const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
         type_p, type_K_p, type_K_p, type_Delta_p);
  
     add_to_ratios(type_p, type_K_p, type_K_z, type_Delta_pp, weight1, weight2);
     add_to_ratios(type_p, type_K_p, type_K_p, type_Delta_p, weight2, weight1);
   }
   {
     const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
         type_n, type_K_p, type_K_z, type_Delta_p);
     const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
         type_n, type_K_p, type_K_p, type_Delta_z);
  
     add_to_ratios(type_n, type_K_p, type_K_z, type_Delta_p, weight1, weight2);
     add_to_ratios(type_n, type_K_p, type_K_p, type_Delta_z, weight2, weight1);
   }
   /* K+ and K0 have the same mass and spin, their cross sections are assumed to
    * only differ in isospin factors. */
   {
     const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
         type_p, type_K_z, type_K_z, type_Delta_p);
     const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
         type_p, type_K_z, type_K_p, type_Delta_z);
  
     add_to_ratios(type_p, type_K_z, type_K_z, type_Delta_p, weight1, weight2);
     add_to_ratios(type_p, type_K_z, type_K_p, type_Delta_z, weight2, weight1);
   }
   {
     const auto weight1 = isospin_clebsch_gordan_sqr_2to2(
         type_n, type_K_z, type_K_z, type_Delta_z);
     const auto weight2 = isospin_clebsch_gordan_sqr_2to2(
         type_n, type_K_z, type_K_p, type_Delta_m);
  
     add_to_ratios(type_n, type_K_z, type_K_z, type_Delta_z, weight1, weight2);
     add_to_ratios(type_n, type_K_z, type_K_p, type_Delta_m, weight2, weight1);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator<<() [8/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const Particles &	particles
	)

Parameters

[in]	out	The ostream into which to output
[in]	particles	The Particles object to write into out

Definition at line 148 of file particles.cc.

                                                                     {
   out << particles.size() << " Particles:\n";
   for (unsigned i = 0; i < particles.data_size_; ++i) {
     const auto &p = particles.data_[i];
     if (p.id() < 0) {
       out << "------  ";
     } else {
       out << std::setw(5) << std::setprecision(3) << p.momentum().abs3()
           << p.type().name();
     }
     if ((i & 15) == 0) {
       out << '\n';
     }
   }
   return out;
 }

◆ antiname()

static std::string smash::antiname	(	const std::string &	name,
		PdgCode	code
	)

static

Construct an antiparticle name-string from the given name-string for the particle and its PDG code.

Parameters

[in]	name	the name-string of the particle to convert
[in]	code	the pdgcode of the particle to convert

Returns: the name-string of the converted antiparticle

Definition at line 143 of file particletype.cc.

                                                                {
   std::string basename, charge;
  
   if (name.find("⁺⁺") != std::string::npos) {
     basename = name.substr(0, name.length() - sizeof("⁺⁺") + 1);
     charge = "⁻⁻";
   } else if (name.find("⁺") != std::string::npos) {
     basename = name.substr(0, name.length() - sizeof("⁺") + 1);
     charge = "⁻";
   } else if (name.find("⁻⁻") != std::string::npos) {
     basename = name.substr(0, name.length() - sizeof("⁻⁻") + 1);
     charge = "⁺⁺";
   } else if (name.find("⁻") != std::string::npos) {
     basename = name.substr(0, name.length() - sizeof("⁻") + 1);
     charge = "⁺";
   } else if (name.find("⁰") != std::string::npos) {
     basename = name.substr(0, name.length() - sizeof("⁰") + 1);
     charge = "⁰";
   } else {
     basename = name;
     charge = "";
   }
  
   // baryons & strange mesons: insert a bar
   if (code.baryon_number() != 0 || code.strangeness() != 0) {
     constexpr char bar[] = "\u0305";
     basename.insert(utf8::sequence_length(basename.begin()), bar);
   }
  
   return basename + charge;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ chargestr()

static std::string smash::chargestr ( int charge )

static

Construct a charge string, given the charge as integer.

Parameters

[in] charge charge of a particle

Returns: the corresponding string to write out this charge

Exceptions

runtime_error if the charge is not an integer between -2 and 2

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

Here is the caller graph for this function:

◆ operator<<() [9/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const ParticleType &	type
	)

Parameters

[out]	out	The ostream into which to output
[in]	type	The ParticleType object to write into out

Definition at line 761 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 ]";
 }

◆ 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 [15]. Note: The original Cugnon parametrization is only applicable for plab < 6 GeV and keeps rising above that. We add an upper limit of b <= 9, in order to be compatible with high-energy data (up to plab ~ 25 GeV).

Parameters

[in] plab Lab momentum in GeV.

Returns: Cugnon B coefficient for elatic proton-proton scatterings.

Definition at line 264 of file scatteraction.cc.

                                       {
   if (plab < 2.) {
     double p8 = pow_int(plab, 8);
     return 5.5 * p8 / (7.7 + p8);
   } else {
     return std::min(9.0, 5.334 + 0.67 * (plab - 2.));
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cugnon_bnp()

static double smash::Cugnon_bnp ( double plab )

static

Computes the B coefficients from the Cugnon parametrization of the angular distribution in elastic np scattering.

See equation (10) in Cugnon:1996kh [15].

Parameters

[in] plab Lab momentum in GeV.

Returns: Cugnon B coefficient for elastic proton-neutron scatterings.

Definition at line 283 of file scatteraction.cc.

                                       {
   if (plab < 0.225) {
     return 0.;
   } else if (plab < 0.6) {
     return 16.53 * (plab - 0.225);
   } else if (plab < 1.6) {
     return -1.63 * plab + 7.16;
   } else {
     return Cugnon_bpp(plab);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

                                                                            {
   std::sort(final_state_xs.begin(), final_state_xs.end(),
             [](const FinalStateCrossSection& a,
                const FinalStateCrossSection& b) { return a.name_ < b.name_; });
   auto current = final_state_xs.begin();
   while (current != final_state_xs.end()) {
     auto adjacent = std::adjacent_find(
         current, final_state_xs.end(),
         [](const FinalStateCrossSection& a, const FinalStateCrossSection& b) {
           return a.name_ == b.name_;
         });
     current = adjacent;
     if (adjacent != final_state_xs.end()) {
       adjacent->cross_section_ += (adjacent + 1)->cross_section_;
       final_state_xs.erase(adjacent + 1);
     }
   }
 }

Here is the caller graph for this function:

◆ operator<<() [10/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const SphereModus &	m
	)

Parameters

[in]	out	The ostream into which to output
[in]	m	The SphereModus object to write into out

Definition at line 194 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.insert_jet_) {
     ParticleTypePtr ptype = &ParticleType::find(m.jet_pdg_);
     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 111 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));
 }

Here is the caller graph for this function:

◆ sread_double()

static double smash::sread_double ( std::ifstream & stream )

static

Read binary representation of a double.

Parameters

[in] stream Input stream.

Returns: Read value.

Definition at line 72 of file tabulation.cc.

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

Here is the caller graph for this function:

◆ swrite() [2/4]

static void smash::swrite	(	std::ofstream &	stream,
		size_t	x
	)

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

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

Here is the caller graph for this function:

◆ swrite() [3/4]

static void smash::swrite	(	std::ofstream &	stream,
		const std::vector< double >	x
	)

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

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

Here is the call graph for this function:

◆ sread_vector()

static std::vector<double> smash::sread_vector ( std::ifstream & stream )

static

Read binary representation of a vector of doubles.

Parameters

[in] stream Input stream.

Returns: Read value.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ swrite() [4/4]

static void smash::swrite	(	std::ofstream &	stream,
		sha256::Hash	x
	)

static

Write binary representation to stream.

Parameters

stream	Output stream.
x	Value to be written.

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

Here is the caller graph for this function:

◆ operator<<() [11/11]

std::ostream& smash::operator<<	(	std::ostream &	out,
		const TimeStampCounter &	tsc
	)

Definition at line 18 of file tsc.cc.

                                                                      {
   auto c = tsc.cycles();
   int blocks[10];
   int n = 0;
   for (int digits = std::log10(c); digits > 0; digits -= 3) {
     blocks[n++] = c % 1000;
     c /= 1000;
   }
   if (n == 0) {
     return out;
   }
   const auto lastFill = out.fill('0');
   out << blocks[--n];
   while (n > 0) {
     out << '\'' << std::setw(3) << blocks[--n];
   }
   out.fill(lastFill);
   return out << " Cycles";
 }

Variable Documentation

◆ LAction

constexpr int smash::LAction = LogArea::Action::id

staticconstexpr

Definition at line 25 of file action.h.

constexpr double smash::fine_structure = 7.2973525698e-3

constexpr

Fine-struture constant, approximately 1/137.

Definition at line 101 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 104 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 109 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 117 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 124 of file constants.h.

◆ BREMS_SQRTS

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

Initial value:

= {
3,  0.31, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.4,  0.41,
42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.5,  0.51, 0.52, 0.53,
54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6,  0.61, 0.62, 0.63, 0.64, 0.65,
66, 0.67, 0.68, 0.69, 0.7,  0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77,
78, 0.79, 0.8,  0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89,
9,  0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99, 1.0,  1.01,
02, 1.03, 1.04, 1.05, 1.06, 1.07, 1.08, 1.09, 1.1,  1.11, 1.12, 1.13,
14, 1.15, 1.16, 1.17, 1.18, 1.19, 1.2,  1.21, 1.22, 1.23, 1.24, 1.25,
26, 1.27, 1.28, 1.29, 1.3,  1.31, 1.32, 1.33, 1.34, 1.35, 1.36, 1.37,
38, 1.39, 1.4,  1.41, 1.42, 1.43, 1.44, 1.45, 1.46, 1.47, 1.48, 1.49,
5,  1.51, 1.52, 1.53, 1.54, 1.55, 1.56, 1.57, 1.58, 1.59, 1.6,  1.61,
62, 1.63, 1.64, 1.65, 1.66, 1.67, 1.68, 1.69, 1.7,  1.71, 1.72, 1.73,
74, 1.75, 1.76, 1.77, 1.78, 1.79, 1.8,  1.81, 1.82, 1.83, 1.84, 1.85,
86, 1.87, 1.88, 1.89, 1.9,  1.91, 1.92, 1.93, 1.94, 1.95, 1.96, 1.97,
98, 1.99, 2.03, 2.06, 2.09, 2.12, 2.15, 2.18, 2.21, 2.24, 2.27, 2.3,
33, 2.36, 2.39, 2.42, 2.45, 2.48, 2.51, 2.54, 2.57, 2.6,  2.63, 2.66,
69, 2.72, 2.75, 2.78, 2.81, 2.84, 2.87, 2.9,  2.93, 2.96, 2.99, 3.02,
05, 3.08, 3.11, 3.14, 3.17, 3.2,  3.23, 3.26, 3.29, 3.32, 3.35, 3.38,
41, 3.44, 3.47, 3.5,  3.53, 3.56, 3.59, 3.62, 3.65, 3.68, 3.71, 3.74,
77, 3.8,  3.83, 3.86, 3.89, 3.92, 3.95, 3.98, 4.01, 4.04, 4.07, 4.1,
13, 4.16, 4.19, 4.22, 4.25, 4.28, 4.31, 4.34, 4.37, 4.4,  4.43, 4.46,
49, 4.52, 4.55, 4.58, 4.61, 4.64, 4.67, 4.7,  4.73, 4.76, 4.79, 4.82,
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:

= {
001,      0.00107227, 0.00114976, 0.00123285, 0.00132194, 0.00141747,
00151991, 0.00162975, 0.00174753, 0.00187382, 0.00200923, 0.00215443,
00231013, 0.00247708, 0.00265609, 0.00284804, 0.00305386, 0.00327455,
00351119, 0.00376494, 0.00403702, 0.00432876, 0.00464159, 0.00497702,
0053367,  0.00572237, 0.00613591, 0.00657933, 0.0070548,  0.00756463,
00811131, 0.00869749, 0.00932603, 0.01,       0.0107227,  0.0114976,
0123285,  0.0132194,  0.0141747,  0.0151991,  0.0162975,  0.0174753,
0187382,  0.0200923,  0.0215443,  0.0231013,  0.0247708,  0.0265609,
0284804,  0.0305386,  0.0327455,  0.0351119,  0.0376494,  0.0403702,
0432876,  0.0464159,  0.0497702,  0.053367,   0.0572237,  0.0613591,
0657933,  0.070548,   0.0756463,  0.0811131,  0.0869749,  0.0932603,
1,        0.107227,   0.114976,   0.123285,   0.132194,   0.141747,
151991,   0.162975,   0.174753,   0.187382,   0.200923,   0.215443,
231013,   0.247708,   0.265609,   0.284804,   0.305386,   0.327455,
351119,   0.376494,   0.403702,   0.432876,   0.464159,   0.497702,
53367,    0.572237,   0.613591,   0.657933,   0.70548,    0.756463,
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.039767, 0.079534, 0.119301, 0.159068, 0.198835, 0.238602,
278369, 0.318136, 0.357903, 0.39767,  0.437437, 0.477204, 0.516971,
556738, 0.596505, 0.636272, 0.676039, 0.715806, 0.755573, 0.79534,
835107, 0.874874, 0.914641, 0.954408, 0.994175, 1.03394,  1.07371,
11348,  1.15324,  1.19301,  1.23278,  1.27254,  1.31231,  1.35208,
39184,  1.43161,  1.47138,  1.51115,  1.55091,  1.59068,  1.63045,
67021,  1.70998,  1.74975,  1.78951,  1.82928,  1.86905,  1.90882,
94858,  1.98835,  2.02812,  2.06788,  2.10765,  2.14742,  2.18718,
22695,  2.26672,  2.30649,  2.34625,  2.38602,  2.42579,  2.46555,
50532,  2.54509,  2.58485,  2.62462,  2.66439,  2.70416,  2.74392,
78369,  2.82346,  2.86322,  2.90299,  2.94276,  2.98252,  3.02229,
06206,  3.10183,  3.14159}

staticconstexpr

Definition at line 19 of file outputparameters.h.

◆ kaon_nucleon_ratios

KaonNucleonRatios smash::kaon_nucleon_ratios

Definition at line 675 of file parametrizations.cc.

◆ 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 20 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 68 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 107 of file parametrizations_data.h.

◆ KMINUSP_TOT_PLAB

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

PDG data on K- p total cross section: momentum in lab frame.

Definition at line 110 of file parametrizations_data.h.

◆ KMINUSP_TOT_SIG

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

PDG data on K- p total cross section: cross section.

Definition at line 165 of file parametrizations_data.h.

◆ KMINUSP_RES_SQRTS

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

Initial value:

= {
4355, 1.4530, 1.4730, 1.4929, 1.5129, 1.5329, 1.5529, 1.5729,
5929, 1.6128, 1.6328, 1.6528, 1.6728, 1.6928, 1.7127, 1.7327,
7527, 1.7727, 1.7927, 1.8127, 1.8326, 1.8526, 1.8726, 1.8926,
9126, 1.9325, 1.9525, 1.9725, 1.9925, 2.0125, 2.0325, 2.0524,
0724, 2.0924, 2.1124, 2.1324, 2.1523, 2.1723, 2.1923, 2.2123,
2323, 2.2523, 2.2722, 2.2922, 2.3122, 2.3322, 2.3522, 2.3721,
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 210 of file parametrizations_data.h.

◆ KMINUSP_RES_SIG

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

Initial value:

= {
46856081097,  0.68994120313, 1.00475205957,  1.66469547655,
63530052434,  4.17372028288, 4.50737036469,  8.00913400697,
29205365102,  2.72859364291, 3.30822314603,  4.44740017628,
95697831919,  5.05350905117, 4.87562017799,  7.48383422000,
29845755438,  9.71940157530, 11.10200040600, 12.00610574630,
06137989140, 7.47886042856, 6.11390219499,  5.19531126779,
38090191191,  3.95316327084, 3.53446044755,  3.46497827089,
63741875589,  3.77762079044, 0.87409952036,  4.19070149234,
38097308237,  4.27752586136, 4.12637945445,  3.70027602474,
31806303484,  2.88526838044, 2.58141493751,  2.36391939397,
18133708906,  1.39193162095, 2.03247269918,  2.00726146262,
13817978212,  2.16907178433, 2.08118209913,  1.83166338166,
56038155638,  1.27216056674, 1.03167072054,  0.85006416230,
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 226 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 244 of file parametrizations_data.h.

◆ KPLUSN_TOT_PLAB

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

Initial value:

= {
770,   0.888,   0.939,   0.970,   0.989,   1.040,   1.091,   1.141,
191,   1.242,   1.292,   1.300,   1.342,   1.392,   1.440,
442,   1.492,   1.550,   1.593,   1.600,   1.643,   1.690,   1.693,
700,   1.743,   1.750,   1.793,   1.800,   1.850,   1.893,   1.900,
950,   1.970,   1.993,   2.000,   2.050,   2.093,   2.100,   2.150,
193,   2.200,   2.260,   2.300,   2.350,   2.393,   2.400,   2.450,
500,   2.550,   2.550,   2.600,   2.650,   2.700,   2.750,   2.800,
830,   2.850,   2.900,   2.950,   3.000,   3.050,   3.100,   3.150,
200,   3.250,   3.300,   6.000,   8.000,   10.000,  12.000,  14.000,
000,  16.000,  18.000,  20.000,  20.000,  25.000,  30.000,  35.000,
000,  40.000,  45.000,  50.000,  50.000,  50.000,  55.000,  70.000,
000, 100.000, 120.000, 150.000, 150.000, 170.000, 200.000, 200.000,
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 252 of file parametrizations_data.h.

◆ KPLUSN_TOT_SIG

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

Initial value:

= {
50, 16.85, 17.60, 17.80, 18.53, 18.91, 20.61, 21.25,  20.87,
26, 19.68, 18.50, 19.32, 19.22, 18.10, 19.07, 18.95, 18.91,
79, 18.89, 18.67, 18.50, 18.69, 18.83, 18.88, 18.86, 18.73,
53, 18.66, 18.50, 18.69, 18.70, 18.60, 18.55, 18.79, 18.54,
67, 18.49, 18.43, 18.40, 18.40, 17.70, 18.27, 18.26, 18.63,
09, 18.25, 18.11, 17.10, 18.17, 18.09, 18.02, 18.11, 18.06,
01, 17.50, 17.95, 17.85, 17.81, 17.81, 17.83, 17.85, 17.61,
61, 17.66, 17.55, 17.50, 17.60, 17.50, 17.60, 17.50, 17.87,
40, 17.60, 17.94, 17.70, 17.78, 17.69, 18.29, 18.12, 18.15,
30, 18.66, 18.56, 18.02, 18.43, 18.60, 19.04, 18.99, 19.23,
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 273 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 288 of file parametrizations_data.h.

◆ KPLUSP_TOT_PLAB

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

Initial value:

= {
178,   0.265,   0.321,   0.351,   0.366,   0.405,   0.440,   0.451,
475,   0.475,   0.506,   0.522,   0.536,   0.566,   0.569,   0.588,
589,   0.592,   0.593,   0.596,   0.618,   0.620,   0.627,   0.643,
644,   0.657,   0.668,   0.686,   0.698,   0.713,   0.717,   0.727,
757,   0.768,   0.770,   0.786,   0.817,   0.823,   0.846,   0.864,
864,   0.881,   0.891,   0.900,   0.904,   0.916,   0.938,   0.942,
951,   0.969,   0.969,   0.970,   0.970,   0.985,   0.992,   1.020,
029,   1.043,   1.055,   1.060,   1.084,   1.090,   1.094,   1.125,
130,   1.140,   1.144,   1.160,   1.170,   1.189,   1.194,   1.207,
210,   1.238,   1.245,   1.250,   1.293,   1.295,   1.300,   1.320,
345,   1.347,   1.380,   1.395,   1.408,   1.440,   1.445,   1.455,
468,   1.480,   1.495,   1.550,   1.563,   1.596,   1.600,   1.646,
690,   1.696,   1.700,   1.746,   1.750,   1.796,   1.800,   1.850,
896,   1.900,   1.945,   1.950,   1.960,   1.970,   1.996,   2.000,
050,   2.096,   2.100,   2.150,   2.196,   2.200,   2.260,   2.300,
350,   2.396,   2.400,   2.450,   2.473,   2.500,   2.530,   2.550,
550,   2.600,   2.650,   2.700,   2.750,   2.760,   2.800,   2.830,
850,   2.900,   2.950,   3.000,   3.050,   3.100,   3.150,   3.200,
200,   3.250,   3.250,   3.300,   3.700,   4.000,   4.200,   4.750,
000,   5.500,   6.000,   7.000,   7.000,   8.000,   8.200,   8.500,
000,  10.000,  10.000,  10.000,  10.900,  11.500,  12.000,  12.500,
400,  14.000,  15.000,  15.000,  16.000,  16.000,  16.900,  18.000,
000,  20.000,  20.000,  25.000,  30.000,  32.000,  35.000,  35.000,
000,  42.500,  45.000,  50.000,  50.000,  50.000,  52.200,  55.000,
000,  100.000, 100.000, 100.000, 100.000, 120.000, 147.000, 150.000,
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 291 of file parametrizations_data.h.

◆ KPLUSP_TOT_SIG

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

Initial value:

= {
40, 13.00, 14.00, 12.20, 13.20, 13.69, 12.81, 16.30, 12.70, 13.58, 13.02,
20, 12.09, 13.20, 12.70, 12.60, 16.30, 14.36, 13.05, 13.04, 12.65, 12.91,
18, 12.50, 12.88, 12.43, 13.10, 11.25, 12.60, 11.14, 11.10, 12.45, 12.65,
65, 13.00, 12.80, 13.20, 12.97, 13.45, 14.07, 13.21, 13.90, 14.39, 13.10,
23, 14.20, 14.59, 15.57, 14.95, 15.28, 15.63, 15.40, 15.25, 16.20, 15.97,
10, 15.69, 17.39, 16.95, 16.40, 17.04, 17.60, 17.12, 17.55, 18.08, 18.02,
09, 17.95, 18.10, 18.06, 18.47, 19.85, 18.58, 18.11, 18.54, 20.71, 18.44,
61, 17.90, 19.33, 18.44, 18.27, 18.64, 18.27, 17.97, 18.10, 18.04, 18.20,
94, 18.04, 17.93, 17.70, 17.66, 17.75, 17.71, 17.86, 17.50, 17.85, 17.73,
80, 17.83, 17.80, 17.98, 17.77, 17.81, 17.79, 17.41, 17.75, 19.40, 16.90,
60, 17.63, 17.72, 17.51, 17.56, 17.57, 17.54, 17.60, 17.10, 17.44, 17.52,
55, 17.56, 17.48, 17.25, 17.49, 17.47, 17.10, 17.44, 17.50, 17.47, 17.41,
41, 17.41, 17.40, 16.70, 17.30, 17.34, 17.30, 17.19, 17.14, 17.08, 17.15,
13, 17.13, 17.13, 17.50, 17.14, 21.00, 17.60, 17.10, 21.30, 17.20, 17.90,
00, 17.20, 18.40, 17.30, 17.20, 18.70, 17.20, 17.30, 18.80, 17.30, 18.10,
00, 17.30, 18.30, 17.50, 17.40, 18.50, 17.31, 17.10, 17.00, 18.80, 17.10,
30, 17.50, 17.42, 17.68, 17.72, 18.40, 17.82, 17.80, 18.05, 17.91, 17.88,
06, 18.03, 18.37, 18.28, 18.17, 18.52, 18.40, 18.88, 18.70, 18.85, 19.14,
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 320 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 343 of file parametrizations_data.h.

◆ PIMINUSP_ELASTIC_P_LAB

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

Initial value:

= {
09875, 0.14956, 0.21648, 0.21885, 0.22828, 0.24684, 0.25599, 0.26733,
27071, 0.2752,  0.29303, 0.29303, 0.33138, 0.33571, 0.33788, 0.35052,
378,   0.38261, 0.404,   0.40626, 0.408,   0.42188, 0.427,   0.44888,
452,   0.471,   0.49008, 0.49008, 0.49008, 0.509,   0.523,   0.52845,
53155, 0.547,   0.54911, 0.54911, 0.556,   0.565,   0.57281, 0.582,
586,   0.609,   0.6139,  0.61698, 0.625,   0.64054, 0.657,   0.65793,
658,   0.6753,  0.683,   0.687,   0.69061, 0.699,   0.70692, 0.71399,
72628, 0.731,   0.73257, 0.74257, 0.75,    0.76189, 0.775,   0.77714,
77714, 0.77827, 0.798,   0.82586, 0.83803, 0.848,   0.84954, 0.854,
87466, 0.90386, 0.91903, 0.924,   0.95947, 1.03016, 1.106,   1.12339,
164,   1.165,   1.174,   1.214,   1.21659, 1.23,    1.25,    1.26,
279,   1.323,   1.339,   1.347,   1.355,   1.365,   1.375,   1.385,
395,   1.405,   1.415,   1.425,   1.435,   1.445,   1.455,   1.465,
475,   1.485,   1.495,   1.497,   1.499,   1.503,   1.5031,  1.509,
567,   1.59,    1.6,     1.603,   1.71,    1.85,    2.1,     2.14,
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 346 of file parametrizations_data.h.

◆ PIMINUSP_ELASTIC_SIG

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

Initial value:

= {
847,  2.9,    9.6,    11.3,   12.8,   17.,    20.1,   21.4,   22.5,
2,   22.5,   18.2,   19.5,   16.,    17.4,   15.1,   12.29,  12.4,
1,   13.8,   10.41,  11.4,   9.,     10.3,   8.9,    9.2,    10.42,
9,   10.8,   9.15,   9.8,    11.4,   11.4,   9.99,   13.,    13.,
24,  10.8,   12.19,  16.2,   11.34,  12.86,  13.71,  13.9,   12.19,
8,   13.92,  16.2,   15.32,  16.98,  18.9,   17.07,  18.86,  19.07,
95,  20.5,   19.87,  18.9,   16.6,   19.4,   19.91,  18.94,  17.56,
19,  17.82,  16.1,   14.91,  15.75,  14.9,   13.2,   14.1,   14.47,
4,   14.8,   14.1,   18.8,   18.,    18.6,   17.95,  17.7,   13.66,
01,  15.73,  12.45,  14.1,   14.6,   13.31,  13.8,   12.8,   13.09,
627, 12.987, 12.763, 12.367, 12.852, 12.67,  12.126, 12.972, 12.478,
594, 12.532, 11.801, 11.568, 11.413, 11.119, 11.643, 11.368, 11.523,
163, 11.69,  10.,    10.39,  10.21,  9.65,   9.,     9.82,   10.4,
1,   9.69,   9.3,    8.91,   8.5,    7.7,    7.2,    7.2,    7.8,
57,   6.1}

PDG data on pi- p elastic cross section: cross section.

Definition at line 365 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 384 of file parametrizations_data.h.

◆ PIMINUSP_LAMBDAK0_P_LAB

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

Initial value:

= {
904, 0.91,  0.919, 0.922, 0.926, 0.93,  0.931, 0.942, 0.945, 0.958, 0.964,
968, 0.98,  0.98,  0.983, 0.993, 0.997, 1.001, 1.002, 1.007, 1.012, 1.017,
02,  1.02,  1.021, 1.022, 1.023, 1.027, 1.031, 1.035, 1.04,  1.04,  1.04,
043, 1.048, 1.054, 1.059, 1.065, 1.078, 1.081, 1.091, 1.091, 1.094, 1.095,
097, 1.116, 1.129, 1.13,  1.135, 1.144, 1.159, 1.194, 1.223, 1.235, 1.277,
287, 1.326, 1.331, 1.332, 1.395, 1.433, 1.455, 1.5,   1.508, 1.515, 1.575,
59,  1.6,   1.615, 1.645, 1.69,  1.69,  1.705, 1.775, 1.85,  1.875, 1.94,
95,  1.98,  2.,    2.05,  2.05,  2.055, 2.115, 2.14,  2.15,  2.235, 2.25,
35,  2.375, 2.494, 2.605, 2.7,   2.75,  2.75,  2.86,  3.01,  3.125, 3.21,
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 387 of file parametrizations_data.h.

◆ PIMINUSP_LAMBDAK0_SIG

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

Initial value:

= {
056, 0.122,  0.18,  0.14,  0.227, 0.212,  0.13,  0.3,   0.336, 0.43,
427, 0.52,   0.467, 0.45,  0.576, 0.59,   0.652, 0.56,  0.588, 0.634,
686, 0.665,  0.67,  0.69,  0.809, 0.675,  0.94,  0.737, 0.734, 0.73,
926, 0.59,   0.92,  0.57,  0.568, 0.651,  0.899, 0.64,  0.794, 0.58,
82,  0.58,   0.7,   0.68,  0.729, 0.575,  0.592, 0.462, 0.541, 0.64,
48,  0.58,   0.46,  0.485, 0.447, 0.25,   0.367, 0.32,  0.29,  0.25,
32,  0.29,   0.334, 0.214, 0.22,  0.21,   0.214, 0.238, 0.208, 0.16,
199, 0.174,  0.14,  0.13,  0.181, 0.16,   0.185, 0.182, 0.184, 0.15,
182, 0.179,  0.11,  0.16,  0.162, 0.192,  0.15,  0.172, 0.174, 0.12,
16,  0.106,  0.12,  0.09,  0.09,  0.109,  0.084, 0.094, 0.087, 0.067,
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 400 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 415 of file parametrizations_data.h.

◆ PIMINUSP_SIGMAMINUSKPLUS_P_LAB

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

Initial value:

= {
091, 1.128, 1.17, 1.22,  1.235, 1.284, 1.326, 1.5,  1.59,
615, 1.69,  1.69, 1.85,  1.94,  1.95,  1.98,  2.05, 2.14,
15,  2.25,  2.35, 2.494, 2.61,  2.7,   2.75,  2.86, 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 418 of file parametrizations_data.h.

◆ PIMINUSP_SIGMAMINUSKPLUS_SIG

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

Initial value:

= {
25,  0.218,  0.231,  0.27,   0.235,  0.209, 0.245, 0.242, 0.262,
18,  0.153,  0.19,   0.099,  0.098,  0.099, 0.09,  0.087, 0.069,
065, 0.057,  0.053,  0.051,  0.03,   0.031, 0.032, 0.022, 0.015,
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 425 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 436 of file parametrizations_data.h.

◆ PIMINUSP_SIGMA0K0_RES_SQRTS

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

Initial value:

= {
5,   1.516, 1.532, 1.548, 1.564, 1.58,  1.596, 1.612, 1.628, 1.644, 1.66,
676, 1.692, 1.708, 1.724, 1.74,  1.756, 1.772, 1.788, 1.804, 1.82,  1.836,
852, 1.868, 1.884, 1.9,   1.916, 1.932, 1.948, 1.964, 1.98,  1.996, 2.012,
028, 2.044, 2.06,  2.076, 2.092, 2.108, 2.124, 2.14,  2.156, 2.172, 2.188,
204, 2.22,  2.236, 2.252, 2.268, 2.284, 2.3,   2.316, 2.332, 2.348, 2.364,
38,  2.396, 2.412, 2.428, 2.444, 2.46,  2.476, 2.492, 2.508, 2.524, 2.54,
556, 2.572, 2.588, 2.604, 2.62,  2.636, 2.652, 2.668, 2.684, 2.7,   2.716,
732, 2.748, 2.764, 2.78,  2.796, 2.812, 2.828, 2.844, 2.86,  2.876, 2.892,
908, 2.924, 2.94,  2.956, 2.972, 2.988, 3.004, 3.02,  3.036, 3.052, 3.068,
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 439 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.,
0386981,  0.09589789, 0.11956695, 0.11685363, 0.12053117, 0.13208736,
14949223, 0.16688579, 0.18830654, 0.20611132, 0.22231072, 0.23099061,
23734563, 0.23334048, 0.22794051, 0.21559531, 0.20134617, 0.18763246,
1723282,  0.15814744, 0.14757816, 0.13750278, 0.12698656, 0.11719809,
11024985, 0.1044732,  0.09623321, 0.09092108, 0.08670191, 0.08147493,
0772165,  0.07346243, 0.0719974,  0.06805902, 0.06496733, 0.06264939,
05904799, 0.05762721, 0.05588871, 0.05393479, 0.0517673,  0.05165839,
05087591, 0.04885535, 0.04730724, 0.04651682, 0.04604065, 0.04529776,
04406593, 0.04367817, 0.04230014, 0.04144308, 0.04171145, 0.04073006,
03996921, 0.03902337, 0.03939531, 0.03895125, 0.03904553, 0.03816119,
03772662, 0.03710955, 0.0361001,  0.03632378, 0.03549849, 0.03549987,
03527251, 0.034535,   0.03314715, 0.0335742,  0.03326698, 0.0330181,
0324203,  0.03227253, 0.0315376,  0.03065083, 0.03041305, 0.03023753,
03008669, 0.02900321, 0.02827017, 0.02805024, 0.02785525, 0.02753706,
02692862, 0.02603758, 0.02591122, 0.02537291, 0.02467199, 0.02466657,
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 457 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 482 of file parametrizations_data.h.

◆ PIMINUSP_RES_SQRTS

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

Center-of-mass energy.

Definition at line 485 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 560 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 633 of file parametrizations_data.h.

◆ PIPLUSP_ELASTIC_P_LAB

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

Initial value:

= {
09875, 0.13984, 0.14956, 0.33138, 0.378,   0.408,   0.4093,  0.427,
42736, 0.453,   0.471,   0.49008, 0.509,   0.5214,  0.53155, 0.547,
57281, 0.574,   0.586,   0.5891,  0.59,    0.591,   0.6139,  0.625,
625,   0.635,   0.645,   0.645,   0.657,   0.65793, 0.6753,  0.687,
698,   0.7,     0.70692, 0.725,   0.72628, 0.72628, 0.752,   0.752,
77714, 0.807,   0.809,   0.82,    0.82586, 0.85,    0.895,   0.895,
9,     0.91,    0.93926, 0.945,   0.945,   0.995,   0.995,   1.0029,
02,    1.04,    1.04,    1.0402,  1.05,    1.12091, 1.12091, 1.195,
207,   1.2217,  1.232,   1.375,   1.3925,  1.44384, 1.46,    1.493,
5,     1.53,    1.585,   1.585,   1.6,     1.68881, 1.69,    1.77,
8,     1.869,   1.9,     1.99,    2.,      2.0199,  2.07,    2.077,
11,    2.19,    2.3,     2.35,    2.5,     2.77,    2.9,     3.,
05,    3.56,    3.63,    3.65,    3.67,    3.9,     4.,      5.,
,      6.,      6.8001,  8.,      8.04,    8.8,     10.8,    11.7,
8,    14.8,    16.,     16.2,    16.7,    29.,     32.1,    43.,
,     60.,     70.,     100.,    140.,    147.,    175.,    200.,
}

PDG data on pi+ p elastic cross section: momentum in lab frame.

Definition at line 636 of file parametrizations_data.h.

◆ PIPLUSP_ELASTIC_SIG

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

Initial value:

= {
15,  15.8,  20.4,  140.9, 91.6,  71.6,  67.5,  57.3,  60.19, 46.6,  40.8,
74, 30.6,  29.6,  30.59, 24.74, 24.31, 28.16, 19.83, 20.4,  20.64, 20.63,
55, 15.75, 18.5,  17.2,  14.85, 16.16, 14.71, 15.32, 14.38, 12.2,  12.93,
96, 12.17, 11.6,  11.06, 11.5,  10.62, 10.55, 8.82,  9.36,  8.97,  9.1,
02,  8.38,  8.37,  8.14,  11.1,  9.3,   11.,   10.32, 9.87,  11.7,  11.15,
05, 11.1,  12.37, 11.83, 10.3,  12.8,  14.54, 15.3,  14.3,  13.59, 12.6,
3,  17.87, 16.5,  19.31, 18.73, 16.68, 13.8,  15.86, 16.7,  16.7,  15.05,
04, 13.57, 12.46, 12.3,  11.81, 10.9,  9.84,  10.6,  9.1,   9.52,  9.46,
44,  9.15,  8.45,  10.2,  6.9,   7.7,   8.3,   7.84,  7.02,  6.93,  7.07,
88,  7.15,  6.5,   6.4,   5.85,  5.79,  5.33,  5.47,  4.9,   4.9,   5.02,
75,  4.2,   4.54,  4.46,  4.21,  4.21,  3.98,  3.19,  3.37,  3.16,  3.29,
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 656 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 672 of file parametrizations_data.h.

◆ PIPLUSP_SIGMAPLUSKPLUS_P_LAB

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

Initial value:

= {
041, 1.105, 1.111, 1.15,  1.157, 1.17,  1.195, 1.206, 1.218, 1.222, 1.265,
28,  1.282, 1.328, 1.34,  1.377, 1.39,  1.41,  1.419, 1.43,  1.456, 1.49,
508, 1.518, 1.549, 1.55,  1.58,  1.582, 1.614, 1.63,  1.68,  1.687, 1.7,
712, 1.76,  1.77,  1.775, 1.808, 1.84,  1.879, 1.906, 1.95,  1.971, 1.997,
067, 2.08,  2.099, 2.152, 2.197, 2.241, 2.291, 2.344, 2.379, 2.437, 2.473,
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 675 of file parametrizations_data.h.

◆ PIPLUSP_SIGMAPLUSKPLUS_SIG

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

Initial value:

= {
034,  0.146,  0.144, 0.214,  0.248, 0.205, 0.24,  0.214, 0.242, 0.25,
278,  0.34,   0.369, 0.412,  0.4,   0.467, 0.44,  0.49,  0.523, 0.51,
662,  0.529,  0.692, 0.545,  0.604, 0.53,  0.53,  0.465, 0.494, 0.47,
505,  0.434,  0.47,  0.436,  0.38,  0.415, 0.418, 0.393, 0.405, 0.332,
37,   0.31,   0.338, 0.298,  0.3,   0.29,  0.28,  0.273, 0.26,  0.25,
23,   0.242,  0.22,  0.217,  0.234, 0.165, 0.168, 0.104, 0.059, 0.059,
0297, 0.0371, 0.02,  0.0202, 0.0143}

PDG data on pi+ p to Sigma+ K+ section: cross section.

Definition at line 684 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 698 of file parametrizations_data.h.

◆ PIPLUSP_RES_SQRTS

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

Center-of-mass energy.

Definition at line 701 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 757 of file parametrizations_data.h.

◆ piplusp_elastic_res_interpolation

std::unique_ptr<InterpolateDataSpline> smash::piplusp_elastic_res_interpolation = nullptr

◆ integrate [1/2]

Integrator smash::integrate

static

Definition at line 144 of file decaytype.cc.

◆ integrate2d [1/2]

Tabulation of all N R integrals.

Keys are the multiplet names (which are unique).

Definition at line 190 of file isoparticletype.cc.

◆ piR_tabulations

std::unordered_map<std::string, Tabulation> smash::piR_tabulations

static

Tabulation of all pi R integrals.

Keys are the multiplet names (which are unique).

Definition at line 197 of file isoparticletype.cc.

◆ RK_tabulations

std::unordered_map<std::string, Tabulation> smash::RK_tabulations

static

Tabulation of all K R integrals.

Keys are the multiplet names (which are unique).

Definition at line 204 of file isoparticletype.cc.

◆ DeltaR_tabulations

std::unordered_map<std::string, Tabulation> smash::DeltaR_tabulations

static

Tabulation of all Delta R integrals.

Keys are the pairs of multiplet names (which are unique).

Definition at line 211 of file isoparticletype.cc.

◆ rhoR_tabulations

std::unordered_map<std::string, Tabulation> smash::rhoR_tabulations

static

Tabulation of all rho rho integrals.

Keys are the pairs of multiplet names (which are unique).

Definition at line 218 of file isoparticletype.cc.

◆ LList

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

staticconstexpr

Definition at line 37 of file listmodus.cc.

◆ global_default_loglevel

einhard::LogLevel smash::global_default_loglevel = einhard::ALL

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

staticconstexpr

Definition at line 19 of file stringprocess.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ SystemTimePoint

◆ SystemClock

◆ SystemTimeSpan

◆ DensityLattice

◆ FieldsLattice

◆ FilePtr

◆ Permutation

Enumeration Type Documentation

◆ ComputationMethod

◆ DensityType

◆ HadronClass

◆ GridOptions

◆ CellSizeStrategy

◆ CellNumberLimitation

◆ LatticeUpdate

◆ BelongsTo

◆ Parity

◆ WhichDecaymodes

◆ ProcessType

◆ Extrapolation

◆ NeedsToWrap

Function Documentation

◆ operator+=()

◆ enforce_periodic_boundaries()

◆ all_of()

◆ for_each()

◆ dedup_avg()

◆ clebsch_gordan()

◆ isospin_clebsch_gordan_sqr_2to1()

◆ isospin_clebsch_gordan_sqr_3to1()

◆ isospin_clebsch_gordan_sqr_2to2()

◆ cut_off()

◆ make_unique()

◆ y_l_0()

◆ operator<<() [1/11]

◆ density_factor()

◆ smearing_factor_norm()

◆ smearing_factor_rcut_correction()

◆ unnormalized_smearing_factor()

◆ current_eckart() [1/2]

◆ current_eckart() [2/2]

◆ update_lattice() [1/2]

◆ update_lattice() [2/2]

◆ breit_wigner()

◆ breit_wigner_nonrel()

◆ cauchy()

◆ density_integrand()

◆ density_integrand_mass()

◆ density_integrand_1M_IC()

◆ density_integrand_2M_IC()

◆ juttner_distribution_func()

◆ sample_momenta_non_eq_mass()

◆ sample_momenta_1M_IC()

◆ sample_momenta_2M_IC()

◆ sample_momenta_from_thermal()

◆ sample_momenta_IC_ES()

◆ operator+() [1/3]

◆ operator-() [1/4]

◆ operator*() [1/8]

◆ operator*() [2/8]

◆ operator/() [1/3]

◆ operator<<() [2/11]

◆ create_experiment_parameters()

◆ hline()

◆ format_measurements()

◆ calculate_mean_field_energy()

◆ fill_event_info()

◆ check_interactions_total()

◆ update_fields_lattice()

◆ fopen()

◆ blatt_weisskopf_sqr()

◆ post_ff_sqr()

◆ em_form_factor_ps()