StringFragmentation

## Lund String Fragmentation

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