Heavy Ion Collisions
PYTHIA does not normally handle collisions involving heavy ions, but it
includes a facility where a model for combining several nucleon-nucleon
collisions into one heavy ion collision can be implemented. One such model,
called Angantyr, is provided with PYTHIA
and is inspired by the old Fritiof program from the Lund group
[And87] with recent improvements [Bie16a] (see below).
To allow for the generation of collisions with heavy ions, PYTHIA includes a
handful of nuclei with PDG numbers on the form 100ZZZAAAI:
4He (1000020040),
6Li (1000030060),
12C (1000060120),
16O (1000080160),
63Cu (1000290630),
129Xe (1000541290),
197Au (1000791970), and
208Pb (1000822080), but more can be added using the function
ParticleData::addParticle
.
mode
HeavyIon:mode
(default = 1
; minimum = 1
; maximum = 2
)
This is the master switch for heavy ions, and determines the mode
of operation of the HeavyIon model.
option
1 : The heavy ion machinery will be used in case of ion beams.
option
2 : Even collisions without ions are treated using
the heavy ion machinery. (Typically only used
for debugging purposes.)
If HeavyIon:mode
is on, the normal initialization in
Pythia::init()
is early on diverted to an object with
the base class HeavyIons
which may instantiate
secondary Pythia
objects needed to generate different types of
nucleon-nucleon collisions that can be merged together into a full
heavy ion event. This is all done in the virtual
HeavyIons::init()
function. Subsequent calls to
Pythia::next()
will then also be diverted to the virtual
function HeavyIons::next()
which will be responsible for
building up the heavy ion collision. The final event will be available in the
primary Pythia
object.
flag
HeavyIon:showInit
(default = on
)
Please note: this flag is not currently in use due to
conflicts with the Parallelism
framework, but is expected to be reintroduced in the future. Output
detailed initialization information from the heavy ion
model. Typically there will be several Pythia
object
initialised in a heavy ion run, this flag can be used to reduce the
amount of output. If off, only the output from initialisation of the
primary Pythia
object will be shown.
The HeavyIon
class is very simple and flexible and basically only
specifies that the HeavyIons::init()
and
HeavyIons::next()
functions are overridden in a subclass. But
there are a few additional helper classes that should be generic enough to be
used by any model implemented.
- The
Nucleon
class represents a single nucleon in a nuclei.
It can be a proton or a neutron (id()
), it has a position in
impact parameter space (Vec2
),
both absolute (bPos()
) and relative to the nuclei
(nPos()
), and optionally it can be in a particular state
represented by a vector of real numbers which are completely model dependent.
- The
SubCollision
class represents a potential
nucleon-nucleon collision between a projectile and a target
Nucleon
.
- The
NucleusModel
class is a base class for implementing a
model for the distribution in impact parameter
space of nucleons in a nucleus. There are two ready-made subclasses called
WoodsSaxonModel
, implementing a standard Woods-Saxon
distribution, and GLISSANDOModel
, implementing the more
advanced model in [Bro09,Ryb14].
flag
HeavyIon:WSHardCore
(default = on
)
In the default Woods-Saxon model for nucleon distributions, assume
that there is a minimum distance between nucleons defined by a hard
core radius in
HeavyIon:WSRh
.
parm
HeavyIon:WSRh
(default = 0.9
; minimum = 0.0
)
The hard core radius in units of fermi, defining the minimum
distance between nucleons in a nucleus in the default Woods-Saxon
model for nucleon distributions.
flag
HeavyIon:gaussHardCore
(default = off
)
Option to use a Gaussian profile of the hard core instead of a sharp
cut-off, inspired by [Bay95].
parm
HeavyIon:WSR
(default = 0.0
; minimum = 0.0
)
The radius of a nucleon in units of fermi in the default Woods-Saxon
model for nucleon distributions. If zero, the size is given by the
formulae [Ryb14], based on the number of nucleons in the
nuclei and whether a hard core is used or not.
parm
HeavyIon:WSa
(default = 0.0
; minimum = 0.0
)
The skin width of a nucleus in units of fermi in the default
Woods-Saxon model for nucleon distributions. If zero, the size is
given by the numbers in [Ryb14], based on the number of
nucleons in the nuclus and whether a hard core is used or not.
- The
ImpactParameterGenerator
is used to sample the impact
parameter space for the colliding nuclei. The base class implements a Gaussian
sampling, which means that the events produced will always be weighted. Other
distributions can be implemented in subclasses.
parm
HeavyIon:bWidth
(default = 0.0
; minimum = 0.0
)
The width in fermi of the distribution by which the impact parameter
is sampled. If zero, a suitable width must be guessed by the
ImpactParamerGenerator
itself.
- The
SubCollisionModel
is used to generate individual,
potential nucleon-nucleon SubCollision
s. Two subclasses are
available, one called NaiveSubCollisionModel
which treats
nucleons as simple black disks, and one implementing a more advanced
model called DoubleStrikman
described below.
- The
HIInfo
class contains information related to the
generated heavy ion events.
- The
HIUserHooks
class is provided to simplify the
customization of a model implemented as a HeavyIons
subclass. It
can be used to eg. change the ImpactParamerGenerator
used, in a
way similar to how the UserHooks
and MergingHooks
classes are used.
Angantyr - the default heavy ion model
The default model in PYTHIA is called Angantyr and is inspired by the old
Fritiof model [And86] with improvements described in
[Bie16a]. The main idea is to stack parton level events,
corresponding to individual nucleon-nucleon sub-collisions, on top of
each other and hadronise them together.
Please note: although it is possible to use
Rope Hadronisation in heavy ion collisions,
these two modules have not yet been validated to work properly together.
Also the parameters in the model have not been properly tuned, so the
results from running must not be taken as definitive predictions.
To determine which projectile nucleon interacts with which target nucleon,
special care is taken to determine in which way the nucleons interact. In
a standard Glauber calculations one typicaly only cares about if a
sub-collision is inelastic or not, but in Angantyr this is divided up, so that
each inelastic sub-collision can either be single-diffractive,
double-diffractive or absorptive (ie. non-diffractive). To achieve this,
Angantyr uses a model with fluctuating radii of the nucleons resulting in a
fluctuating nucleon-nucleon cross section inspired by the model by Strikman et
al. [Alv13]. The model for this includes a number of parameters which
should be fitted to reproduce inclusive nucleon-nucleon cross sections. To be
consistent, the values used comes from PYTHIA's internal model of
total cross sections.
The default model for nucleon fluctuations has three parameters, the general
fitting machinery in SubCollisionModel
allows for up to eight
parameters.
pvec
HeavyIon:SigFitDefPar
(default = {17.24,2.15,0.33,0.0,0.0,0.0,0.0,0.0}
)
These are the default values of the parameters of the
SubCollisionModel
in Angantyr. They will be used as starting
point when fitting to the inclusive nucleon cross sections.
The fitting procedure in SubCollisionModel
is a kind of genetic
algorith where a population of parameter values are allowed to evolve for a
number of generations. In the end the the parameter set in the final
population which gives the best inclusive cross sections is picked.
Eight different cross sections may be fitted to but it is possible to select
only some of them:
pvec
HeavyIon:SigFitErr
(default = {0.02,0.02,0.1,0.05,0.05,0.0,0.1,0.0}
; minimum = 0.0
; maximum = 1.0
)
The relative error assumed in the calculation of goodness of fit
corresponding to the different cross sections fitted to. The cross
sections are obtained from the
SigmaTotal
and are given
as (in order) total, non-diffractive, double diffractive, wounded
target, wounded projectile, central diffractive, and elastic cross
sections, and in addition the elastic slope parameter. A relative
error of zero for one of these cross sections means the corresponding
cross section not be used in the fit.
mode
HeavyIon:SigFitNInt
(default = 100000
; minimum = 0
)
The number of integration points used for each parameter setting to calculate
the cross sections.
mode
HeavyIon:SigFitNPop
(default = 20
; minimum = 1
)
The number individuals (parameter settings) in a population in each
generation.
mode
HeavyIon:SigFitNGen
(default = 20
; minimum = 0
)
The number of generation used in the genetic algorithm. If set to zero, no
fitting will be performed and the values in HeavyIon:SigFitDefPar
will be used.
parm
HeavyIon:SigFitFuzz
(default = 0.2
; minimum = 0.0
; maximum = 0.5
)
A parameter determining the probability that an individual parameter setting
will evolves further away from the best parameter set in each generation.
flag
HeavyIon:SigFitPrint
(default = on
)
fitting procedure. If on, extensive information about the fitting will be
printed.
mode
Angantyr:CollisionModel
(default = 1
; minimum = 0
; maximum = 3
)
The Angantyr model has a couple of option for the SubCollisionModel
option
0 : A simplified model with fixed nucleon radii.
option
1 : The default model with fluctuating radii and cross
sections.
option
2 : Fluctuating radii and cross sections but different
treatment of opacity.
option
3 : Black disks with no fluctuations, ie. no diffraction.
flag
Angantyr:GlauberOnly
(default = off
)
event generation will stop after SubCollisions has been determined, allowing
the user to read out the nucleon configuration only.
After all possible nucleon-nucleon sub-collisions has been determined,
they are ordered in increasing nucleon-nucleon impact parameter. This
list is then gone through in order several time. First all absorptive
sub-collisions are treated. One full nucleon-nucleon non-diffractive
minimum bias event is generated for each possible absorptive
sub-colision. These are also ordered in impact parameter. Note that
one target nucleon can interact absorptively with several target
nucleons, in a first round only those absorptive sub-collisions
involving nucleons that have not already interacted absorptively are
are assigned a non-diffractive event.
If PYTHIA is not set up to generate minimum bias events, one or more of the
generated non-diffractive events will be replaced by events generated with the
selected signal process, and the cross section reported will be modified
accordingly.
In a second round only those potential absorptive sub-collisions are
considered where one nucleon has already been assinged a full
non-diffractive event. In the Angantyr model it is then assumed that
the other nuclean will contribute to the final state as if it had just
been diffractively excited. Therefore a corresponding
single-diffractive event is generated, the elastically scattered beam
particle is discarded and the rest is added to the previous
non-diffractive event, shuffling a bit with the kinematics so that the
total emergy and momentum is conserved.
To generate these single-diffraction events to emulate multiple
absorptive sub-collisions a special Pythia
object is
used. To allow flexibility this object need not have exactly the same
settings as the the one generating events for normal
single-diffraction sub-collisions. To manipulate this Pythia
object a special form of settings can be used. All settings available for
Diffraction
,
MultipartonInteractions
,
PDF
,
SigmaDiffractive
and
PDF
can be set separately for this Pythia
object by prefixing
their names with HI
.
As an example, setting HISigmaDiffractive:PomFlux
and
HIPDF:PomSet
will set the
SigmaDiffractive:PomFlux
and PDF:PomSet
options
for this Pythia
object.
mode
Angantyr:SASDmode
(default = 4
; minimum = 0
; maximum = 4
)
Determines how to generate single-diffraction events as secondary absorptive
(SASD) sub-collisions.
option
0 : Standard singel-diffraction events as speicfied by
HIDiffraction
settings above.
option
1 : Always use HIPDF:PomSet = 11
and use the
same initial HIMultipartonInteractions:pT0Ref
as for
non-diffractive events for the total nucleon-nucleon collision energy,
independent of the mass of the diffractive system.
option
2 : (Experimental) As for option 1
but also
rescale the pomeron
proton non-diffractive cross section to match the pp non-diffractive one.
option
3 : (Experimental) As for option 1
but use the
full nucleon-nucleon cross section for the non-diffractive nucleon-Pomeron
in the multiple interaction machinery. Also rescale the Pomeron PDF with
the log of the ratio of maximum and minimum Pomeron-nucleon collision
energy.
option
4 : As for option 3
but no rescaling of the
Pomeron PDF.
mode
Angantyr:impactMode
(default = 2
; minimum = 0
; maximum = 2
)
Determines how to bias non-diffractive minimum-bias sub-collisions in
PYTHIA to be appropriately central.
option
0 : If we have N pirmary sub-collisions and Na secondary
sub-collisions, generate N+Na non-diffractive events and pick the N most
central.
option
1 : Use UserHooks to force Pythia to produce events with a
particular impact parameter for the N primary sub collisions according to the
generated impact parameter in the SubCollisionModel.
option
2 : As for option 1
but also the secondary
absorptive sub-collisions have their impact parameter set.
parm
Angantyr:impactFudge
(default = 0.85
; minimum = 0.0
; maximum = 4.0
)
Multiplicative factor used to compensate for the fact that the
SubColllisionModel
in Angantyr may have a different
impact parameter profile than what is assumed in the MPI overlap
calculation in Pythia.
mode
Angantyr:SDTries
(default = 1
; minimum = 1
)
When adding single diffractive sub-collisions to other
sub-collisions, there might not be enough energy for the
diffractive mass. One option here is to say that the diffractive
sub-event simply fails, but setting this larger than unity allows
for regenerating the single diffractive sub-event a number of times
to see if a small enough diffractive system is produced.
mode
Angantyr:SDRecoil
(default = 1
; minimum = 1
; maximum = 2
)
Determines which particles in a primary sub-collision will take the
recoil when adding single diffractive sub-collisions to other
sub-collisions. The choice may be overridded by a user-defined
HIUserHooks::findRecoilers
function.
option
1 : Only elastically scattered nucleons and nucleon
remnants will take recoil.
option
2 : All particles outside the added diffractive system's
rapidity range are considered.
flag
Angantyr:SDTest
(default = off
)
Used in conjunction with HeavyIon:mode = 2
and proton
beams to generate single diffractive events that would be used as
secondary non-diffractive scatterings in the Angantyr heavy ion model
for the given nucleon energies. Used for tuning special
HI
-prefixed parameters of the secondary absorptive
sub-collisions.
parm
Angantyr:SDTestB
(default = -1.0
)
In conjunction with Angantyr:SDTest = on
and
Angantyr:impactMode = 2
only pick diffractive
events with a particular impact parameter (as defined by the scaled value
given in Info::bMPI()
). If negative, the standard impact
parameter distribution is used.
After all absorptive sub-collisions have been dealt with, the
diffractive and elastic sub-collisions are dealt with in a similar
way. In the end there will be a number of parton level events which
are finally stacked together, and then hadronised. Finally nucleus
remnants constructed from the non-interacting nucleans, are added to
complete the full nucleaus-nucleus collision.