Lund String Fragmentation
- Jet joining procedure
- Colour tracing
- Simplifying systems
- Ministrings
- String junctions
The standard fragmentation in PYTHIA is based on the Lund string model
[And83, Sjo84]. Several different aspects are involved in
the physics description, which here therefore is split accordingly.
This also, at least partly, reflects the set of classes involved in
the fragmentation machinery. See the
Hadronization Overview
to understand how the key classes are related, and also how
the basic Lund String Fragmentation machinery is the starting point
for a number of alternatives or extensions.
There are three main auxiliary classes for string fragmentation,
each handling an important physics step. Many of the settings for
each of them play a key role in the tuning to data, while some others
should not be touched except by experts.
- The choice of quark flavours at string breaks, and the choice of
a hadron from a given flavour combination, is managed in the
StringFlav class, with settings as described on the
Flavour Selection page.
The fragmentation flavour-choice machinery is also used in a few
other places of the program, notably in particle decays.
- The choice of pT transverse momentum kicks in string breaks
is managed by the
StringPT class, with settings as described
on the pT Selection page.
- The choice of the z variable, representing the
energy-momentum lightcone fraction that a new hadron takes out of the
remaining (i.e. not yet fragmented) amount,
is managed by the
StringZ class, with settings as described
on the z Selection page.
Several further options and parameters, e.g., for the joining of jets
and for the handling of a number of special systems, such as low-mass
strings and string junctions, are documented below. Most of them are
intended for experts, and can be left at their default values.
Jet joining procedure
String fragmentation is carried out iteratively from both string ends
inwards, which means that the two chains of hadrons have to be joined
up somewhere in the middle of the event. This joining is described by
parameters that in principle follow from the standard fragmentation
parameters. Ideally, these joining parameters should be tuned such
that the rapidity spacing and mass distribution of hadrons produced in
the joining step match those produced in the standard fragmentation
process as closely as possible. The current default values were
determined for the JETSET tune and have not been retuned since. Recent
studies have shown that these choices do not produce a smooth joining
for the current default Monash tune settings. Work is underway to
improve the smoothness - and robustness - of this procedure. As a
temporary step, the stopMass below was somewhat reduced
in version 8.316, from 1.0 to 0.8 GeV.
parm StringFragmentation:stopMass
(default = 0.8; minimum = 0.0; maximum = 2.0)
Is used to define a W_min = m_q1 + m_q2 + stopMass,
where m_q1 and m_q2 are the masses of the two
current endpoint quarks or diquarks.
parm StringFragmentation:stopNewFlav
(default = 2.0; minimum = 0.0; maximum = 2.0)
Add to W_min an amount stopNewFlav * m_q_last,
where q_last is the last q qbar pair produced
between the final two hadrons.
parm StringFragmentation:stopSmear
(default = 0.2; minimum = 0.0; maximum = 0.5)
The W_min above is then smeared uniformly in the range
W_min_smeared = W_min * [ 1 - stopSmear, 1 + stopSmear ].
This W_min_smeared is then compared with the current remaining
W_transverse to determine if there is energy left for further
particle production. If not, i.e. if
W_transverse < W_min_smeared, the final two particles are
produced from what is currently left, if possible. (If not, the
fragmentation process is started over.)
Colour tracing
flag StringFragmentation:TraceColours
(default = off)
In some cases it is interesting to trace the primary hadrons back
to the string pieces from which they were
formed. If StringFragmentation:TraceColours is switched
on, this is done by setting colour and anticolour
indices for the primary hadrons to the indices of the string piece
where the corresponding break-ups are assumed to have happened. To
avoid the possible confusion of having colour indices on colour
singlet particles, this flag is by default off.
Simplifying systems
There are a few situations when it is meaningful to simplify the
original task, one way or another.
parm HadronLevel:mStringMin
(default = 1.; minimum = 0.5; maximum = 1.5)
Decides whether a partonic system should be considered as a normal
string or a ministring, the latter only producing one or two primary
hadrons. The system mass should be above mStringMin plus the
sum of quark/diquark constituent masses for a normal string description,
else the ministring scenario is used.
parm FragmentationSystems:mJoin
(default = 0.3; minimum = 0.2; maximum = 1.)
When two colour-connected partons are very nearby, with at least
one being a gluon, they can be joined into one, to avoid technical
problems of very small string regions. The requirement for joining is
that the invariant mass of the pair is below mJoin, where a
gluon only counts with half its momentum, i.e. with its contribution
to the string region under consideration. (Note that, for technical
reasons, the 0.2 GeV lower limit is de facto hardcoded.)
parm FragmentationSystems:mJoinJunction
(default = 1.0; minimum = 0.5; maximum = 2.)
When the invariant mass of two of the quarks in a three-quark junction
string system becomes too small, the system is simplified to a
quark-diquark simple string. The requirement for this simplification
is that the diquark mass, minus the two quark masses, falls below
mJoinJunction. Gluons on the string between the junction and
the respective quark, if any, are counted as part of the quark
four-momentum. Those on the two combined legs are clustered with the
diquark when it is formed.
Ministrings
The MiniStringFragmentation machinery is only used when a
string system has so small invariant mass that normal string fragmentation
is difficult/impossible. Instead one or two particles are produced,
in the former case shuffling energy-momentum relative to another
colour singlet system in the event, while preserving the invariant
mass of that system. With one exception parameters are the same as
defined for normal string fragmentation, to the extent that they are
at all applicable in this case.
A discussion of the relevant physics is found in [Nor00].
The current implementation does not completely abide to the scheme
presented there, however, but has in part been simplified. (In part
for greater clarity, in part since the class is not quite finished yet.)
mode MiniStringFragmentation:nTry
(default = 2; minimum = 1; maximum = 10)
Whenever the machinery is called, first this many attempts are made
to pick two hadrons that the system fragments to. If the hadrons are
too massive the attempt will fail, but a new subsequent try could
involve other flavour and hadrons and thus still succeed.
After nTry attempts, instead an attempt is made to produce a
single hadron from the system. Should also this fail, some further
attempts at obtaining two hadrons will be made before eventually
giving up.
flag MiniStringFragmentation:tryAfterFailedFrag
(default = off)
If normal string fragmentation fails for a parton system, it is optionally
possible to attempt to fragment it as if it had been a ministring
(c.f. HadronLevel:mStringMin). This is mainly relevant for
heavy-ion collisions and for the QCD-based colour-reconnection model,
where many high-multiplicity events have a higher probability to have
failed fragmentation (hence throwing the whole event away may skew the
multiplicity distribution).
String junctions
A junction topology corresponds to an Y arrangement of strings
i.e. where three string pieces have to be joined up in a junction.
Such topologies can arise if several valence quarks are kicked out
from a proton beam, or in baryon-number-violating SUSY decays.
Special attention is necessary to handle the region just around the
junction, where the baryon number topologically is located. The
junction fragmentation scheme is described in [Sjo03] and
[Alt24]. The parameters in this section should not be
touched except by experts.
parm StringFragmentation:pNormJunction
(default = 2.0; minimum = 0.5; maximum = 10)
Used to find the effective rest frame of the junction, which is
complicated when the three string legs may contain additional
gluons between the junction and the endpoint. Should in principle be
(close to) sqrt((1 + a) / b), with a and b
the parameters of the Lund symmetric fragmentation function.
parm StringFragmentation:eJunctionCutoff
(default = 0.0)
Used as a stopping condition for the fragmentation of the first two
junction legs. Fragmentation of the given junction leg is stopped if
performing another break would leave the remaining energy of the
junction leg below eJunctionCutoff. Value should be less than
eBothLeftJunction.
parm StringFragmentation:mJunctionCutoff
(default = 0.0)
Used as a stopping condition for the fragmentation of the first two
junction legs. Fragmentation of the given junction leg is stopped if
performing another break would leave the mass of the junction diquark
below mJunctionCutoff.
parm StringFragmentation:eBothLeftJunction
(default = 1.0; minimum = 0.5)
Retry (up to 10 times) when the first two considered strings in to a
junction both have a remaining energy (in the junction rest frame)
above this number.
parm StringFragmentation:eMaxLeftJunction
(default = 10.0; minimum = 0.)
Retry (up to 10 times) when the first two considered strings in to a
junction has a highest remaining energy (in the junction rest frame)
above a random energy evenly distributed between
eBothLeftJunction and
eBothLeftJunction + eMaxLeftJunction
(drawn anew for each test).
parm StringFragmentation:eMinLeftJunction
(default = 0.2; minimum = 0.)
Retry (up to 10 times) when the invariant mass-squared of the final leg
and the leftover momentum of the first two treated legs falls below
eMinLeftJunction times the energy of the final leg (in the
junction rest frame).
flag StringFragmentation:doStrangeJunctions
(default = off)
Switching this parameter on allows strangeness enhancement for string breaks
next to a junction.
parm StringFragmentation:enhanceStrangeJunction
(default = 0.5; minimum = 0.; maximum = 1.0)
This parameter, sJ, scales how much strangeness
enhancement around a junction by modifying the probability
StringFlav:probStoUD,
P'(s:u/d) = P(s:u/d)(1 - s_J).