## The Antenna Shower Model (VINCIA)

### Overview

The antenna shower model was initially developed as a standalone plugin (VINCIA), but since Pythia version 8.300 it has been incorporated into the Pythia 8 source code.

The shower evolution is driven by 2→3 antenna functions which have DGLAP kernels as their collinear limits and eikonal factors as their soft limits. They hence should exhibit improved colour coherence effects relative to the old (DGLAP-based) simple shower model. Likewise, the QED antenna-shower module is based on a fully coherent (multipole) treatment of photon radiation patterns. For both QCD and QED, the effects of parton masses (e.g., bottom and top quark masses) are systematically included, and the massive antenna functions have the appropriate quasi-collinear limits.

### Main Switches

`mode` Vincia:nFlavZeroMass (`default = 4`; `minimum = 2`; `maximum = 6`)
Controls the number of flavours that will be treated as massless by VINCIA, ie with massless kinematics and no mass corrections. The remaining flavours will be bookkept with massive kinematics and mass-corrected antenna functions. Note that, even for flavours treated as massless, an elementary phase-space check is still made eg on all g→QQ branchings to ensure m(QQ) >= 2mQ. Likewise, all heavy flavours in the initial state are forced to undergo a conversion into a gluon when the evolution variable reaches their mass threshold (with the threshold determined by the maximum of the PDF threshold and the relevant user-specifiable mass parameter given below).

`flag` Vincia:helicityShower (`default = off`)
Switch to use helicity-dependent antenna functions (or not). Only meaningful when helicity information is present in the Born-level events.

### Shower Starting Scales (Wimpy vs Power Showers)

Similarly to PYTHIA, for processes that include at least one quark, gluon, or photon in the final state, the default choice in VINCIA is to start the shower from the factorisation scale used for the hard process (as given by PYTHIA for internal processes, or defined by the `scale` value for Les Houches input),while processes that do not include any such partons are allowed to populate the full phase space. This behaviour can be changed by the following option, which is anologous to the `SpaceShower:PTmaxMatch` option in PYTHIA.

`mode` Vincia:pTmaxMatch (`default = 0`; `minimum = 0`; `maximum = 2`)
`option` 0 : Showers off processes that include at least one final-state quark, gluon, or photon, are started at the factorisation scale, while processes that do not include any such partons are started at the phase-space maximum.
`option` 1 : Showers are always started at the factorisation scale.
`option` 2 : Showers are always started at the phase-space maximum. This option is not recommended for physics runs as it will lead to unphysical double counting in many cases.

When the first branching is limited by the factorisation scale for the hard process, a multiplicative factor can be applied to either increase or decrease the shower starting scale relative to the factorisation scale:

`parm` Vincia:pTmaxFudge (`default = 1.0`; `minimum = 0.1`; `maximum = 10.0`)

`parm` Vincia:pTmaxFudgeMPI (`default = 1.0`; `minimum = 0.1`; `maximum = 10.0`)
Same as above but for MPI systems, affecting the underlying event.

Note that for any (combination of) choices that result in ISR showers not using the factorisation scale as the starting scale, the generated Sudakov factor will effectively produce leftover PDF ratios in the exclusive cross sections produced by the shower.

### Settings for the QCD Antenna Showers

The settings for the QCD antenna shower modules are described here.

### Settings for the QED Antenna Showers

The settings for the QED antenna shower module are described here.

### Evolution with Enhanced (Biased) Kernels

VINCIA's shower evolution can be biased to populate the multi-jet phase space more efficiently and/or enhance the rate of rare processes such as g→bb and g→cc splittings. It is also possible to inhibit radiation (e.g., to focus on Sudakov regions), by choosing enhancement factors smaller than unity. When these options are used, it is important to note that the event weights will be modified, reflecting that some types of events (e.g., multijet events, or events with gluon splittings to heavy quarks) will be "overrepresented" statistically, and others (events with few jets, or events with no gluon splittings to heavy quarks) underrepresented. Averages and histograms will therefore only be correct if computed using the correct weight for each generated event. A description and proof of the algorithm can be found in [MS16]. Note that care has been taken to ensure that the weights remain positive definite; under normal circumstances, VINCIA's enhancement algorithm should not result in any negative weights.

`flag` Vincia:enhanceInHardProcess (`default = on`)
This flag controls whether the enhancement factors are applied to shower branchings in the hard-process system.

`flag` Vincia:enhanceInResonanceDecays (`default = on`)
This flag controls whether the enhancement factors are applied to shower branchings inside resonance-decay systems (like Z/W/H decays) that are treated as factorised from the hard process.

`flag` Vincia:enhanceInMPIshowers (`default = off`)
This flag controls whether the enhancement factors are applied to shower branchings in MPI systems.

`parm` Vincia:enhanceFacAll (`default = 1.0`; `minimum = 0.01`; `maximum = 100.0`)
This enhancement factor is applied as a multiplicative factor common to all antenna functions, increasing the likelihood of all shower branchings by the same amount. Values greater than unity thus more frequently yields "busy" events, with many shower branchings. Values smaller than unity suppress additional branchings, yielding more Sudakov-like events.

`parm` Vincia:enhanceFacBottom (`default = 1.0`; `minimum = 1.0`; `maximum = 100.0`)
This enhances the probability for all branchings that increase the number of bottom quarks (i.e., FSR g→bb splittings and the corresponding ISR flavour-excitation process). Note: this factor is applied on top of `Vincia:biasAll`.

`parm` Vincia:enhanceFacCharm (`default = 1.0`; `minimum = 1.0`; `maximum = 100.0`)
Same as `Vincia:enhanceFacBottom` but for charm quarks. Note: this factor is applied on top of `Vincia:biasAll`.

`parm` Vincia:enhanceCutoff (`default = 10.0`; `minimum = 0.0`; `maximum = 1000.0`)
Do not apply enhancement factors to branchings below this scale. Intended to be used to focus on enhancements of hard branchings only.

### VINCIA Tunes

VINCIA has its own set of dedicated tune presets, which can be specified by the user.

`mode` Vincia:Tune (`default = 0`; `minimum = -1`; `maximum = 0`)
`option` -1 : None. No VINCIA-specific tune parameter settings will be used during initialisation.
`option` 0 : Hadronisation and MPI parameters optimised for use with the VINCIA shower model, used as default VINCIA parameters since PYTHIA 8.302.

Note: the requested tune parameters will only be activated when VINCIA is switched on, in order not to interfere with the PYTHIA settings when VINCIA is switched off.

Note 2: as with ordinary Pythia tune parameters, the tuned parameter values will be superseded by any user modifications made in the user's command file or main program. This should allow sufficient flexibility to explore user variations away from the tuned values.

#### Advice on Tuning

Although there are obviously parameters that it makes more sense to tune than others, there is no explicit restriction imposed on what parameters are allowed to be present in the tune file. This implies some responsibility on the part of the user.

As a guideline, the main parameters that need to be properly tuned are the non-perturbative hadronisation parameters used in PYTHIA's string fragmentation model. Since PYTHIA and VINCIA treat soft radiation somewhat differently, there can be important differences between the two in the soft region that the hadronisation model will not re-absorb automatically and which therefore only a retuning can address.

The strategy used for the default tune of VINCIA is to take the reference value for alphaS from the current world average value in the MSbar scheme, and let the effective shower scheme tuning be done by first translating to the CMW scheme and then fine-tune by modifying the renormalisation-scale prefactors used for shower branchings.

An alternative (but equivalent) strategy that is often used in PYTHIA tunes, is to perceive of the value of the strong coupling itself as a tuning parameter. In this case the interpretation is that extracting alphaS from, e.g., event shapes, can be done equally well using a shower code as with more analytical approaches. The difference is that the alphaS value extracted with the shower code is in an a priori unknown scheme, defined by the shower algorithm. If the shower only includes LO/LL accuracy for the given observable(s), the extraction should be compared with other LO/LL extractions. This typically yields alphaS values ~ 0.13 - 0.14. When explicit NLO corrections are included for the relevant observable(s), values comparable to other NLO extractions should result, around 0.12.

### About VINCIA

The main references for the current version of VINCIA are:

- VINCIA for Hadron Colliders.
- Coherent Showers in Decays of Coloured Resonances (for showers in top quark decays).

The name VINCIA stands for "VIrtual Numerical Collider with Interleaved Antennae". The naming of VINCIA is intended to allude to a progression from PYTHIA - a name originating in ancient Greece - to the renaissance era of Leonardo da Vinci. The logo of VINCIA is the "Vitruvian Man", by da Vinci, a choice which also reflects the combination of art and accuracy which is necessary to write a good event generator. Classical antiquity is still indirectly represented, via the namesake of the logo, Vitruvius, a first-century (BC) Roman author, architect, and engineer.

### Expert Settings

Importante Note: the parameters in this section are intended for use only by authors or expert users.

#### Sector Shower

`flag` Vincia:sectorShower (`default = off`)
Switch to activate the sector shower in VINCIA.

`parm` Vincia:sectorDamp (`default = 0.0`; `minimum = 0.0`; `maximum = 1.0`)
In the symmetrisation over post-branching gluons that is done to derive the sector antenna functions from the global ones, the branching invariant with swapped gluons is nominally given by yijSym = yik = 1 - yij - yjk. If the swapped gluons are j and k (and straightforwardly generalised if they are i and j) then the collinear yjk→0 limit does not change by adding or subtracting a term of order yjk. Therefore one could equally well use yijSym = 1 - yij (or something inbetween). This is still guaranteed to be positive definite and was indeed the choice in the original sector antenna shower papers. Since the latter definition produces a value for yijSym which is slightly larger than the former, the corresponding 1/yijSym singularities in the antenna function are damped slightly, so that larger values of the `sectorDamp` parameter produces sector antenna functions which have slightly smaller magnitudes outside the collinear limits. Strictly speaking this choice is an ambiguity that should be varied for uncertainty estimates, in which context we note that we expect it to be almost entirely degenerate with variations of nonsingular terms.

#### Octet Partitioning

Within the antenna formalism, the collinear singularity of two gluons j and k is distributed between two neighboring antennae. One contains the singularity for j becoming soft, one the singularity for k becoming soft. In showers based on so-called global antenna functions (as opposed to sector functions, which are no longer implemented in VINCIA), the two antennae share the collinear singularity, j||k, point by point in phase space, and only after summing over both is the full collinear AP splitting kernel recovered. The parameter below controls the repartition ambiguity and gives the value of "half" the gluon splitting function on its finite end.

`parm` Vincia:octetPartitioning (`default = 0.0`; `minimum = 0.0`; `maximum = 1.0`)
Gluon-collinear α parameter. Only used for final-final global antennae. Note: only the default value (0) is consistent with the initial-final (and initial-initial) antenna functions in VINCIA. Special values of interest are: α=0, which corresponds to the Gehrmann-Gehrmann-de Ridder-Glover (GGG) partitioning, and α=1, which corresponds to the Gustafson (ARIADNE) partitioning.

#### Verbose Level

`mode` Vincia:verbose (`default = 1`; `minimum = 0`; `maximum = 9`)
Level of detail of information written to standard output on what goes on inside `VINCIA`. Settings different from zero and one are intended for debugging purposes and hence should not be used for normal runs.
`option` 0 : No runtime output.
Note: options 1-3 only generate output when something goes wrong, i.e., a check fails, etc.
`option` 1 : Normal runtime output. Warnings and errors are printed, but no additional diagnostic output is given.
`option` 2 : Enhanced runtime output. As for =1, but limited additional diagnostic info is given. Some previously silent warnings are added. Also, internal VINCIA diagnostics histograms are booked and filled, especially for matching. These can be printed by the user at any time (e.g., after a run) using the `VinciaPlugin::printHistos()` method.
`option` 3 : Debug runtime output. As for =2, but as much diagnostic output as possible is given for each error or warning. Also, a consistency check is added to each branching by reclustering the resulting momenta back using the corresponding inverse kinematics map and checking that the original momenta are recovered within the desired numerical precision. Note: the kinematics check will slow down the speed of event generation.
Note: options above 4 will always generate output for each event, so will cause very large amounts of output if generating many events.
`option` 4 : As for =3. And: each `prepare()` and `pTnext()` call is explicitly announced, with system number and restart scale printed out, respectively. .
`option` 5 : As for =4. And: momentum listings are printed for each configuration that violates `Paccept <= 1`.
`option` 6 : As for =5. And: each main function call is explicitly announced with begin and end printed to output.
`option` 7 : As for =6. And: most function calls are explicitly announced with begin and end printed to output (still only partly implemented).
`option` 8 : As for =7. And: last semi-sensible level of output.
`option` 9 : As for =8. And: all possible output.

#### Shower Uncertainty Bands

Automated uncertainty bands are not available in this version of the VINCIA code.

#### Numerical Checks

`flag` Vincia:CheckAntennae (`default = on`)
By default, Vincia checks antenna functions for positivity and absence of dead zones. Switch to control whether to perform antenna self-consistency checks or not.

`mode` Vincia:nPointsCheck (`default = 1000`; `minimum = 0`; `maximum = 1e6`)
Number of random points to check each antenna functions for positivity.

`parm` Vincia:deadZoneAvoidance (`default = 0.0001`; `minimum = 0.0`; `maximum = 1.0`)
During initialisation, warnings are issued if any antenna functions (in dimensionless form, with the Eikonal proportional to 2/y1/y2) become smaller than this number, anywhere in the resolved part of phase space (away from phase-space boundaries). This is to warn against spurious radiation zeroes or large negative finite terms creating "dead zones", or near-dead zones, in the shower. For LL showering and matching up to NLO, there is in principle no problem in taking this parameter to zero if so desired. However, for the NLL and higher-order matching corrections, very small values of this parameter may result in weights greater than unity being generated, since the corrections are multiplicative and large reweighting factors may be needed to "make up" for any near-dead zones at the previous branching step.

#### Matrix-Element Corrections Level

`word` Vincia:MEplugin
name of the plugin library to use for matrix element corrections.