**A calculation is** only as good as the trustworthiness
of its uncertainty bands. Although not foolproof, VINCIA attempts to
make comprehensive and explicit estimates of the theoretical accuracy
of the answers it provides, event by event in phase space.
Obviously, VINCIA can only make these estimates for the parts of the
calculation that it handles itself - hence the automatic uncertainty
estimates are currently limited to the perturbative parts of the
calculation.

When switched on, the uncertainty variations are provided as, and can be accessed by the user through, a vector of alternative weights that is provided for each event. If the event is in a phase space region that VINCIA believes to be under good perturbative control (according to the showering and matching criteria specified by the user), the spread in weights will be small, whereas it will be larger for events populating less well controlled phase space regions.

Since the uncertainty estimate is fully differential in phase space, cuts can be imposed post facto without causing any special problems. E.g., if the cuts isolate a poorly controlled region, all the accepted events will have relatively large event weight spreads, and hence the overall relative uncertainty will increase, as expected.

Needless to say, these uncertainties still have to be interpreted with caution, but due to a large amount of flexibility in the VINCIA formalism, VINCIA can perform quite a few variations that are not possible with other generators. We therefore believe that the uncertainties quoted by VINCIA are, at least, reasonably meaningful.

Note also that the "central" set of weights (corresponding to the
settings chosen by the user for the current run) is normally
unweighted
by default in VINCIA. I.e., all the events have identical
weights and can be trivially added together statistically.
The uncertainty weight sets are computed in such a way that
this still holds true on average for each uncertainty variation
individually. I.e., although the weights
corresponding to uncertainty variation *n* fluctuate about
unity, event to event, their average over many events will still be
unity. Formally, this is due to the variations being done in a way
that conserves unitarity. Practically, it means that none of the
variations change the input total (Born-level) normalisation - they
only change how it is distributed across phase space. The user
should therefore be aware that there can
still be an overall "K" factor, not addressed by these
uncertainty bands.

**The speed of** the calculation is not significantly affected by
adding uncertainty variations, but the code does run
slightly faster without them. We therefore advise to keep them
switched off whenever they
are not going to be used. See speed below for
more on the impact on performance.

**Note** that the variations in VINCIA are similar to the ones included
in Pythia. The set of switches and parameters is therefore similar to what
is available in Pythia.

**Note** that the variations only represent variations of the perturbative
shower parameters. Since VINCIA does not handle the non-perturbative phase of
fragmentation, uncertainty estimates for parameters related to that part must
still be performed in the traditional way. Especially for infrared sensitive
observables, the user is therefore advised to carry out separate variations of
the non-perturbative parameters, such as the a and b parameters of the Lund
symmetric fragmentation function and of other hadronisation and hadron decay
parameters that may be of relevance to the study at hand.

VINCIA provides a possibility for evaluating the variations described above automatically. For every event it generates, it will then tell you the effective spread of weights it found for that particular phase space point, which saves you the effort to make separate additional runs, one for each variation. It also saves computing time, since the uncertainty evaluation only mildly affects the overall speed of the generator.

`flag `

** Vincia:uncertaintyBands **
(`default = `

)**off**

Main switch for VINCIA's automatic evaluation of theoretical uncertainty
bands. When set to `on`

VINCIA internally keeps track of
several variations of the shower approximation
and outputs a vector of weights for each event.

By default, the automated shower uncertainty variations are enabled for the showers off the hardest interaction (and associated resonance decays), but not for the showers off MPI systems which would be more properly labeled as underlying-event uncertainties. If desired, the variations can be applied also to showers off MPI systems via the following switch:

`flag `

** Vincia:uncertaintyInMPIshowers **
(`default = `

)**off**

Flag specifying whether the automated shower variations include
showers off MPI systems or not. Note that substantially larger
weight fluctuations must be expected when including shower
variations for MPI, due to the (many) more systems which then
enter in the reweightings.

**UserHooks Warning:** the calculation of uncertainty variations
will only be consistent in the absence of any external modifications
to the shower branching probabilities via the UserHooks framework. It is
therefore strongly advised to avoid combining the automated uncertainty
calculations with any such UserHooks modifications.

When `Vincia:uncertaintyBands`

is switched on, the user
can define an arbitrary number of (combinations of) uncertainty variations
to perform. Each variation is defined by a string with the following
generic format:

label keyword1=value keyword2=value ...The user has complete freedom to specify the label, and each keyword must be selected from the list below.

Once a list of variations defined as above has been decided on, the whole list should be passed to Pythia/VINCIA in the form of a single vector of strings, defined as follows:

`wvec `

** Vincia:UncertaintyBandsList **
(`default = `

)**{alphaShi ff:muRfac=0.5 if:muRfac=0.5 ii:muRfac=0.5, alphaSlo ff:muRfac=2.0 if:muRfac=2.0 ii:muRfac=2.0, hardHi ff:cNS=2.0 if:cNS=2.0 ii:cNS=2.0, hardLo ff:cNS=-2.0 if:cNS=-2.0 ii:cNS=-2.0}**

Vector of uncertainty-variation strings defining which variations will be
calculated by VINCIA when `Vincia:uncertaintyBands`

is switched on.

The following list includes all keywords that can currently be processed:

`ff:muRfac`

: multiplicative factor applied to the renormalization scale in GeV for FF branchings.`if:muRfac`

: multiplicative factor applied to the renormalization scale in GeV for IF branchings.`ii:muRfac`

: multiplicative factor applied to the renormalization scale in GeV for II branchings.`ff:cNS`

: additive non-singular ("finite") term in the FF splitting functions (applied as*+ff:cNS/sIK*).`if:cNS`

: additive non-singular ("finite") term in the IF splitting functions (applied as*+if:cNS/sAK*).`ii:cNS`

: additive non-singular ("finite") term in the II splitting functions (applied as*+ii:cNS/sAB*).

Optionally, a further level of detail can be accessed by specifying
variations for specific types of branchings, with the global keywords
above corresponding to setting the same value for all branchings. Using
the `if:muRfac`

parameter for illustration, the individual
branching types that can be specified are:

`if:QQemit:muRfac`

: variation for gluon emission off initial-final qq pair.`if:GQemit:muRfac`

: variation for gluon emission off initial-final gq pair.`if:QGemit:muRfac`

: variation for gluon emission off initial-final qg pair.`if:GGemit:muRfac`

: variation for gluon emission off initial-final gg pair.`if:QXsplit:muRfac`

: variation for an initial state quark backwards evolving into a gluon and emitting an antiquark in the final state.`if:GXconv:muRfac`

: variation for an initial state gluon backwards evolving into a quark and emitting a quark in the final state.`if:XGsplit:muRfac`

: variation for a gluon splitting in the final state.

Similarly defined are `ii:QQemit:muRfac`

,
`ii:GQemit:muRfac`

, `ii:GGemit:muRfac`

,
`ii:QXsplit:muRfac`

, `ii:GXconv:muRfac`

,
`ff:QQemit:muRfac`

, `ff:QGemit:muRfac`

,
`ff:GGemit:muRfac`

, and `ff:XGsplit:muRfac`

.

To exemplify, an uncertainty variation corresponding to simultaneously increasing both the ISR and FSR renormalisation scales by a factor of two would be defined as follows

alphaSlo ff:muRfac=2.0 if:muRfac=2.0 ii:muRfac=2.0Different histograms can then be filled with each set of weights as desired (see accessing the uncertainty weights below). Variations by smaller or larger factors can obviously also be added in the same way, again within one and the same run.

The main intended purpose of these variations is to estimate perturbative uncertainties associated with the parton showers. Due to the pole at LambdaQCD, however, branchings near the perturbative cutoff can nominally result in very large reweighting factors, which is unwanted for typical applications. We therefore enable to limit the absolute (plus/minus) magnitude by which alphaS is allowed to vary by

`parm `

** Vincia:deltaAlphaSmax **
(`default = `

; **0.2**`minimum = 0.0`

; `maximum = 1.0`

)

The allowed range of variation of alphaS, interpreted as abs(alphaSprime
- alphaS) < deltaAlphaSmax.

Likewise, non-singular-term variations are mainly intended to capture uncertainties related to missing higher-order tree-level matrix elements and are hence normally uninteresting for very soft branchings. The following parameter allows to switch off the variations of non-singular terms below a fixed perturbative threshold:

`parm `

** Vincia:cNSpTmin **
(`default = `

; **5.0**`minimum = 0.0`

; `maximum = 20.0`

)

Variations of non-singular terms will not be performed for branchings
occurring below this threshold.

Additionally, there is a run-time parameter:

`flag `

** Vincia:muSoftCorr **
(`default = `

)**on**

This flags tells the shower to apply an O(αS^{2})
compensation term to the renormalization-scale variations, which
reduces their magnitude for soft emissions.

The first (zero'th) entry in the vector of event weights always corresponds to the settings chosen by the user, and will normally have weights equal to unity (if showering an unweighted set of events), see the page on weights. If showering a weighted set of events, the nominal (user) weights are propagated through VINCIA and can be obtained through the method

`vincia.weight();`

The uncertainty bands are represented by alternative
sets of weights, where the spread of weights for each indidivual event
gives an estimate of how "sure" VINCIA is about the weight for that
particular event. Regions of phase space where the theoretical
uncertainty is large are thus reflected by large
weight spreads, while regions where the shower approximations work
well have smaller differences.
After showering, the weights corresponding to the uncertainty bands
are accessible via the same method as that used for the central weight
set, by giving a non-zero index to the `weight()`

method,

`vincia.weight(int iVar);`

where `iVar`

is an integer code specifying the particular
variation you want the weight for. The numbering corresponds to the order
of the variations specified above. The number of available
variations you can access is given by

`vincia.nVariations();`

Finally you can access the label of the variation (as specified in
`Vincia:UncertaintyBandsList`

) by

`vincia.weightLabel(int iVar);`

Numerical tests indicate that the additional computational overhead caused by activating the automatic uncertainty evaluation is not very large, generally increasing the runtime for a fully unweighted event sample by less than ten percent, for order of 10 different variations.

Moreover, since the events generated are the same for all the variations, only one event set needs to be passed, e.g., to models for hadronisation and/or detector corrections. The bands are correctly propagated through these models by simply keeping track of the different weight sets and applying these at any stage after the shower evolution has finished. Hence substantial overall speed gains compared to a full-fledged traditional uncertainty estimation should be possible.