## Fragmentation

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, reflect the set of classes involved in the fragmentation machinery.

The variables collected here have a very wide span of usefulness. Some would be central in any hadronization tuning exercise, others should not be touched except by experts.

The fragmentation flavour-choice machinery is also used in a few other places of the program, notably particle decays, and is thus described on the separate Flavour Selection page.

Several methods are in place to allow the user to reweight generated events in the parameters of the fragmentation model. This allows the user to perform fast parameter variation or oversample rare configurations, and reweight to the correct cross section. These methods are documented on the separate Hadronization Variations page.

Note that the fragmentation in a Hidden Valley scenario is modelled in a similar spirit as for ordinary string fragmentation, but with a separate set of parameters. Relevant parameters for it are closely related to the scenario chosen, and therefore are documented on the same page.

The `StringZ` class handles the choice of longitudinal lightcone fraction z.

- For light quark flavours, only the Lund Symmetric Fragmentation Function (or Lund FF for short) is available in PYTHIA, with several different options for parameterization and parameter values. See the section on light quark flavours below.
- For massive quarks (and exotic coloured particles), the Bowler modification to the Lund FF is the default choice, but the Peterson/SLAC fragmentation function is also available as an alternative. See the section on massive quark flavours below.

The `StringPT` class handles the choice of fragmentation pT. Two models are available in PYTHIA: Gaussian (default) and thermal, with switches and parameters documented in the section on Fragmentation pT below.

Several further options and parameters, e.g., for the joining of jets and for the handling of a number of special systems such as string systems with low invariant masses and string junctions, are also documented on this page.

### The fragmentation function for light quark flavours

The Lund symmetric fragmentation function [And83] is the only option for light quark (and diquark) flavours and is of the form
f(z) = (1/z) * (1-z)^a * exp(-b m_T^2 / z)
with the two main free parameters a and b to be tuned to data. They are set with the following two parameters.

`parm` StringZ:aLund (`default = 0.68`; `minimum = 0.0`; `maximum = 2.0`)
The a parameter of the Lund symmetric fragmentation function.

`parm` StringZ:bLund (`default = 0.98`; `minimum = 0.2`; `maximum = 2.0`)
The b parameter of the Lund symmetric fragmentation function.

In principle, each flavour can have a different a. Then, for going from an old flavour i to a new j one the shape is
f(z) = (1/z) * z^{a_i} * ((1-z)/z)^{a_j} * exp(-b * m_T^2 / z)
This is only implemented for s quarks and diquarks relative to normal quarks:

`parm` StringZ:aExtraSQuark (`default = 0.0`; `minimum = -1.0`; `maximum = 2.0`)
allows a different a for s quarks, with total a = aLund + aExtraSQuark. For negative values, note that the resulting a for strange quarks is not allowed to be smaller than zero.

`parm` StringZ:aExtraDiquark (`default = 0.97`; `minimum = 0.0`; `maximum = 2.0`)
allows a larger a for diquarks, with total a = aLund + aExtraDiquark.

`flag` StringZ:useOldAExtra (`default = off`)
flag which, when on, reproduces an old incorrect behavior of updating `aExtra`. This bug was introduced in the transition from Pythia 6 to Pythia 8, and fixed in Pythia 8.315, when also this flag was introduced. Inadvertently, the type of the old and new strange quark or diquark was flipped in the (1-z)^a factor when updating `aExtra` between string breaks. This flag has now been set to `on` for all past tunes distributed with Pythia, to ensure that these tunes still are valid, since they were tuned with this old behavior. All future tunes should be made with this flag set to `off` (the default value).
Note: If you are using an old custom tune file with Pythia 8.315 or beyond, you should include `StringZ:useOldAExtra = on` to ensure that such a tune remains valid. Conversely, if you are using an old tune but want to study how it would be impacted by a correct z selection, you need to set `StringZ:useOldAExtra = off` to annul the change from the default `off` to `on` when the tune is read.

In the context of fits to experimental data, the a and b parameters typically exhibit a very high degree of correlation. An option for choosing alternative parameterizations of the Lund FF is therefore provided, whereby the user can specify a desired mean of the fragmentation function instead of the b parameter. Optionally, the a parameter can also be derived, from a user-specified root-mean-square (RMS) width of the FF. And, finally, the aExtraDiquark and aExtraSQuark parameters can also be recast in terms of multiplicative (rather than additive) parameters. These options can be enabled via the following switch:

`mode` StringZ:deriveLundPars (`default = 0`; `minimum = 0`; `maximum = 4`)
`option` 0 : The standard parameterization of the Lund FF is used, in terms of `aLund`, `bLund`, `aExtraDiquark`, and `aExtraSQuark`.
`option` 1 : The `avgZLund` parameter below is used. The `bLund` parameter is treated as a derived quantity which is determined during program initialization.
`option` 2 : The `avgZLund` and `rmsZLund` parameters below are used. Both `aLund` and `bLund` are treated as derived quantities which are determined during program initialization.
`option` 3 : As for option `2` but also the `facALundDiquark` parameter below is used instead of `aExtraDiquark`.
`option` 4 : As for option `3` but also the `facALundSQuark` parameter below is used instead of `aExtraSQuark`. with parameters:

`parm` StringZ:avgZLund (`default = 0.550`; `minimum = 0.375`; `maximum = 0.615`)
For `StringZ:deriveLundPars >= 1`, this parameter specifies the average of the fragmentation function for primary rho mesons, evaluated at mT^2 = mRho^2 + 2`StringPT:sigma`^2. The appropriate b-parameter value is computed automatically during initialization and the `StringZ:bLund` parameter is updated accordingly. Note that the derived value is allowed to exceed the nominal limits given for `bLund` above. This is intended to allow fits to see the functional behaviour even outside the nominal limits.

`parm` StringZ:rmsZLund (`default = 0.197`; `minimum = 0.165`; `maximum = 0.225`)
For `StringZ:deriveLundPars >= 2`, this parameter specifies the width of the fragmentation function for primary rho mesons, in terms of the root-mean-square deviation (RMSD), rmsZ = sqrt( <z^2> - <z>^2 ), of the fragmentation function for primary rho mesons. The appropriate a-parameter value is computed automatically during initialization and the `StringZ:aLund` parameter is updated accordingly. Note that the derived value is allowed to exceed the nominal limits given for `aLund` above. This is intended to allow fits to see the functional behaviour even outside the nominal limits. Note however that the initialization step will produce an error if a value for `aLund` less than zero would be required for the requested combination of `avgZLund` and `rmsZLund`. The The `min` and `max` values for the `avgZLund` and `rmsZLund` parameters have been chosen such that this should not happen when these parameters are chosen inside their nominal ranges.

`parm` StringZ:facALundDiquark (`default = 2.430`; `minimum = 1.000`; `maximum = 4.000`)
For `StringZ:deriveLundPars >= 3`, this parameter specifies the ratio of the Lund a parameter for diquarks to that for quarks. The appropriate aExtraDiquark-parameter value is computed automatically during initialization and the `StringZ:aExtraDiquark` parameter is updated accordingly. Note that the derived value is allowed to exceed the nominal limits given for `aExtraDiquark` above. This is intended to allow fits to see the functional behaviour even outside the nominal limits.

`parm` StringZ:facALundSQuark (`default = 1.0`; `minimum = 0.0`; `maximum = 2.0`)
For `StringZ:deriveLundPars = 4`, this parameter specifies the ratio of the Lund a parameter for strange quarks to that for up and down quarks. The appropriate aExtraSQuark-parameter value is computed automatically during initialization and the `StringZ:aExtraSQuark` parameter is updated accordingly. Note that the derived value is allowed to exceed the nominal limits given for `aExtraSQuark` above. This is intended to allow fits to see the functional behaviour even outside the nominal limits.

### Fragmentation functions for massive quarks and exotics

#### The Lund-Bowler FF for massive quark flavours

The Bowler modification [Bow81] introduces an extra factor
1/z^{r_Q * b * m_Q^2}
on the Lund FF for heavy quarks (and/or exotic coloured particles). To keep some flexibility, a multiplicative factor r_Q is introduced, which ought to be unity (provided that quark masses were uniquely defined) but can be set in

`parm` StringZ:rFactC (`default = 1.32`; `minimum = 0.0`; `maximum = 2.0`)
r_c, i.e. the above parameter for c quarks.

`parm` StringZ:rFactB (`default = 0.855`; `minimum = 0.0`; `maximum = 2.0`)
r_b, i.e. the above parameter for b quarks.

`parm` StringZ:rFactH (`default = 1.0`; `minimum = 0.0`; `maximum = 2.0`)
r_h, i.e. the above parameter for heavier hypothetical quarks, or in general any new coloured particle long-lived enough to hadronize.

#### Options for non-universal bLund parameters for massive quark flavours

Within the string framework, the b parameter is universal, i.e. common for all flavours. Nevertheless, for fits to experimental data, better agreement can be obtained if both a_Q and b_Q can be set freely in a general expression
f(z) = 1/z^{1 + r_Q * b_Q * m_Q^2} * (1-z)^a_Q * exp(-b_Q m_T^2 / z)
The below switches and values can be used to achieve this. They should be used with caution and constitute clear deviations from the Lund philosophy.

`flag` StringZ:useNonstandardC (`default = off`)
use the above nonstandard Lund ansatz for c quarks.

`flag` StringZ:useNonstandardB (`default = off`)
use the above nonstandard Lund ansatz for b quarks.

`flag` StringZ:useNonstandardH (`default = off`)
use the above nonstandard Lund ansatz for hypothetical heavier coloured particles.

`parm` StringZ:aNonstandardC (`default = 0.3`; `minimum = 0.0`; `maximum = 2.0`)
The a parameter in the nonstandard Lund ansatz for c quarks.

`parm` StringZ:aNonstandardB (`default = 0.3`; `minimum = 0.0`; `maximum = 2.0`)
The a parameter in the nonstandard Lund ansatz for b quarks.

`parm` StringZ:aNonstandardH (`default = 0.3`; `minimum = 0.0`; `maximum = 2.0`)
The a parameter in the nonstandard Lund ansatz for hypothetical heavier coloured particles.

`parm` StringZ:bNonstandardC (`default = 0.8`; `minimum = 0.2`; `maximum = 2.0`)
The b parameter in the nonstandard Lund ansatz for c quarks.

`parm` StringZ:bNonstandardB (`default = 0.8`; `minimum = 0.2`; `maximum = 2.0`)
The b parameter in the nonstandard Lund ansatz for b quarks.

`parm` StringZ:bNonstandardH (`default = 0.8`; `minimum = 0.2`; `maximum = 2.0`)
The b parameter in the nonstandard Lund ansatz for hypothetical heavier coloured particles.

#### The Peterson/SLAC FF for massive quark flavours

As another nonstandard alternative, it is possible to switch over to the Peterson/SLAC formula [Pet83]
f(z) = 1 / ( z * (1 - 1/z - epsilon/(1-z))^2 )
for charm, bottom and heavier (defined as above) by the three flags

`flag` StringZ:usePetersonC (`default = off`)
use Peterson for c quarks.

`flag` StringZ:usePetersonB (`default = off`)
use Peterson for b quarks.

`flag` StringZ:usePetersonH (`default = off`)
use Peterson for hypothetical heavier coloured particles.

When switched on, the corresponding epsilon values are chosen to be

`parm` StringZ:epsilonC (`default = 0.05`; `minimum = 0.01`; `maximum = 0.25`)
epsilon_c, i.e. the above parameter for c quarks.

`parm` StringZ:epsilonB (`default = 0.005`; `minimum = 0.001`; `maximum = 0.025`)
epsilon_b, i.e. the above parameter for b quarks.

`parm` StringZ:epsilonH (`default = 0.005`; `minimum = 0.0001`; `maximum = 0.25`)
epsilon_h, i.e. the above parameter for hypothetical heavier (and exotic) flavours, normalized to the case where m_h = m_b. The actually used parameter is then epsilon = epsilon_h * (m_b^2 / m_h^2). This allows a sensible scaling to a particle with an unknown higher mass without the need for a user intervention.

### Fragmentation pT

At each string breaking the quark and antiquark of the produced pair are supposed to receive opposite and compensating pT kicks. How they are distributed depends on the following flag:

`flag` StringPT:thermalModel (`default = off`)
If switched off the quark pT is generated according to the traditional Gaussian distribution in p_x and p_y separately. If switched on, the new "thermal model" [Fis16] is instead used, wherein the quark pT is generated such that the resulting hadron receives a pT according to an exponential distribution. Also the hadronic composition is affected, see further below.

#### Gaussian Distribution

For `StringPT:thermalModel = off` the quarks receive pT kicks according to a Gaussian distribution in p_x and p_y separately. Call sigma_q the width of the p_x and p_y distributions separately, i.e.
d(Prob) = exp( -(p_x^2 + p_y^2) / 2 sigma_q^2).
Then the total squared width is
<pT^2> = <p_x^2> + <p_y^2> = 2 sigma_q^2 = sigma^2.
It is this latter number that is stored in

`parm` StringPT:sigma (`default = 0.335`; `minimum = 0.0`; `maximum = 1.0`)
the width sigma in the fragmentation process.

Since a normal hadron receives pT contributions for two string breakings, it has a <p_x^2>_had = <p_y^2>_had = sigma^2, and thus <pT^2>_had = 2 sigma^2.

Some studies on isolated particles at LEP has indicated the need for a slightly enhanced rate in the high-pT tail of the above distribution. This would have to be reviewed in the context of a complete retune of parton showers and hadronization, but for the moment we stay with the current recipe, to boost the above pT by a factor enhancedWidth for a small fraction enhancedFraction of the breakups, where

`parm` StringPT:enhancedFraction (`default = 0.01`; `minimum = 0.0`; `maximum = 1.`)
enhancedFraction,the fraction of string breaks with enhanced width.

`parm` StringPT:enhancedWidth (`default = 2.0`; `minimum = 1.0`; `maximum = 10.0`)
enhancedWidth,the enhancement of the width in this fraction.

In the context of some toy studies [Fis16] the following three options have also been introduced, but are not part of any recommended framework.

`parm` StringPT:widthPreStrange (`default = 1.0`; `minimum = 1.0`; `maximum = 10.0`)
Prefactor multiplying the Gaussian width for strange quarks.

`parm` StringPT:widthPreDiquark (`default = 1.0`; `minimum = 1.0`; `maximum = 10.0`)
Prefactor multiplying the Gaussian width for diquarks. In case of diquarks with one or two strange quarks the prefactor is calculated by multiplying widthPreDiquark once or twice respectively with widthPreStrange.

`flag` StringPT:mT2suppression (`default = off`)
If switched on the flavour composition is chosen based on the hadronic transverse mass, mT^2_had, and not based on the quark masses. This implies a mass suppression factor exp(-m_had^2 / 2 sigma^2) .

#### Thermal Distribution

For `StringPT:thermalModel = on` the quark pT is generated such that the resulting hadron pT follows a thermal distribution
d(Prob) = exp( -pT_had/T) d^2pT_had
with temperature T, whose value is given by

`parm` StringPT:temperature (`default = 0.21`; `minimum = 0.1`; `maximum = 0.5`)
the temperature T in the fragmentation process.

`parm` StringPT:tempPreFactor (`default = 1.21`; `minimum = 1.0`; `maximum = 1.5`)
Temperature prefactor for strange quarks and diquarks. Default is determined to have the same average pT in u/d → s and s → u/d transitions.

### 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, but in a way too complicated to parameterize. The dependence is rather mild, however, so for a sensible range of variation the parameters in this section should not be touched.

`parm` StringFragmentation:stopMass (`default = 1.0`; `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: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).