## Standard-Model Parameters

### The strong coupling

The `AlphaStrong` class is used to provide a first-, second- or third-order running alpha_strong (or, trivially, a zeroth-order fixed one). Formulae are the standard ones found in the 2006 RPP [Yao06]. The higher-order expression used, eq. (9.5), may be somewhat different in other approaches (with differences formally of higher order), so do not necessarily expect perfect agreement, especially not at small Q^2 scales. The starting alpha_strong value is defined at the M_Z mass scale. The Lambda values are matched at the c, b and t flavour thresholds, such that alpha_strong is continuous. For second- or third-order matching an approximate iterative method is used.

For backwards compatibility, the following global switch determines whether 5- or 6-flavour running will be used above the t threshold:

`mode` StandardModel:alphaSnfmax (`default = 6`; `minimum = 5`; `maximum = 6`)
`option` 5 : Use 5-flavour running for all scales above the b flavour threshold (old default).
`option` 6 : Use 6-flavour running above the t threshold (new default).

Since we allow alpha_strong to vary separately for hard processes, timelike showers, spacelike showers and multiparton interactions, all other relevant values are set in each of these classes. The default behaviour is everywhere first-order running.

The alpha_strong calculation is initialized by `init( value, order, nfmax)`, where `value` is the alpha_strong value at M_Z, `order` is the order of the running, 0, 1, 2 or 3, and `nfmax` is the highest number of flavours to include in the running. Thereafter the value can be calculated by `alphaS(scale2)`, where `scale2` is the Q^2 scale in GeV^2.

By default the charm, bottom and top threshold-matching mass values are chosen to be 1.5, 4.8 and 171 GeV, respectively. The `setThresholds(double mc, double mb, double mt)` method can be invoked to select other values. To take effect, this must be done before the `AlphaStrong::init()` method is called, since this is where the flavour-dependent Lambda_i values are calculated and stored. If in doubt, better call it once again.

For applications inside shower programs, a second- or third-order `alpha_s` value can be obtained as the product of the two functions `alphaS1Ord(scale2)` and `alphaS2OrdCorr(scale2)`, where the first gives a simple first-order running (but with the second- or third-order Lambda) and the second the correction factor, below unity, for the second- or third-order terms. This allows a compact handling of evolution equations.

Resummation arguments [Cat91] show that a set of universal QCD corrections can be absorbed in coherent parton showers by applying the so-called CMW rescaling of the MSbar value of Lambda_QCD. This can be accomplished via a fourth (optional) boolean argument to `init( value, order, nfmax, useCMW)`, with default value `useCMW = false`. When set to `true`, the translation amounts to an N_F-dependent rescaling of Lambda_QCD, relative to its MSbar value, by a factor 1.661 for NF=3, 1.618 for NF=4, 1.569 for NF=5, and 1.513 for NF=6. When using this option, be aware that the original CMW arguments were derived using two-loop running and that the CMW rescaling may need be taken into account in the context of matrix-element matching. Note also that this option has only been made available for timelike and spacelike showers, not for hard processes.

Different approaches can be taken to handle the divergence of the strong coupling as the scale argument approaches the 3-flavour value of Lambda_QCD. At the most basic level, PYTHIA implementes a protection against unphysical evaluations via a safety margin, scale → max(scale, SAFETY * Lambda_QCD(NF=3), that prevents evaluations too close to Lambda_QCD(NF=3). Hardcoded values for the SAFETY factor of 1.07 for first-order running and 1.33 for higher-order running effectively freeze the coupling at a value of order 10, beyond which any application of perturbation theory would be senseless anyway. In some cases such as for timelike showers, additional options may also be available, e.g., to shift the scale argument by an amount of order Lambda_QCD and/or to freeze the effective coupling at a lower value than that given by the hard limit above. Where available, such options are documented on the HTML page for the relevant physics model, cf., e.g., the one on Timelike Showers.

### The electromagnetic coupling

The `AlphaEM` class is used to generate a running alpha_em. The input `StandardModel:alphaEMmZ` value at the M_Z mass is matched to a low-energy behaviour with running starting at the electron mass threshold. The matching is done by fitting an effective running coefficient in the region between the light-quark threshold and the charm/tau threshold. This procedure is approximate, but good enough for our purposes.

Since we allow alpha_em to vary separately for hard processes, timelike showers, spacelike showers and multiparton interactions, the choice between using a fixed or a running alpha_em can be made in each of these classes. The default behaviour is everywhere first-order running. The actual values assumed at zero momentum transfer and at M_Z are only set here, however.

`parm` StandardModel:alphaEM0 (`default = 0.00729735`; `minimum = 0.0072973`; `maximum = 0.0072974`)
The alpha_em value at vanishing momentum transfer (and also below m_e).

`parm` StandardModel:alphaEMmZ (`default = 0.00781751`; `minimum = 0.00780`; `maximum = 0.00783`)
The alpha_em value at the M_Z mass scale. Default is taken from [Yao06].

The alpha_em calculation is initialized by `init(order)`, where `order` is the order of the running, 0 or 1, with -1 a special option to use the fix value provided at M_Z. Thereafter the value can be calculated by `alphaEM(scale2)`, where `scale2` is the Q^2 scale in GeV^2.

### The electroweak couplings

There are two degrees of freedom that can be set, related to the electroweak mixing angle:

`parm` StandardModel:sin2thetaW (`default = 0.2312`; `minimum = 0.225`; `maximum = 0.240`)
The sine-squared of the weak mixing angle, as used in all Z^0 and W^+- masses and couplings, except for the vector couplings of fermions to the Z^0, see below. Default is the MSbar value from [Yao06].

`parm` StandardModel:sin2thetaWbar (`default = 0.2315`; `minimum = 0.225`; `maximum = 0.240`)
The sine-squared of the weak mixing angle, as used to derive the vector couplings of fermions to the Z^0, in the relation v_f = a_f - 4 e_f sin^2(theta_W)bar. Default is the effective-angle value from [Yao06].

The Fermi constant is not much used in the currently coded matrix elements, since it is redundant, but it is available:

`parm` StandardModel:GF (`default = 1.16637e-5`; `minimum = 1.0e-5`; `maximum = 1.3e-5`)
The Fermi coupling constant, in units of GeV^-2.

### The quark weak-mixing matrix

The absolute values of the Cabibbo-Kobayashi-Maskawa matrix elements are set by the following nine real values taken from [Yao06] - currently the CP-violating phase is not taken into account in this parametrization. It is up to the user to pick a consistent unitary set of new values whenever changes are made.

`parm` StandardModel:Vud (`default = 0.97383`; `minimum = 0.973`; `maximum = 0.975`)
The V_ud CKM matrix element.

`parm` StandardModel:Vus (`default = 0.2272`; `minimum = 0.224`; `maximum = 0.230`)
The V_us CKM matrix element.

`parm` StandardModel:Vub (`default = 0.00396`; `minimum = 0.0037`; `maximum = 0.0042`)
The V_ub CKM matrix element.

`parm` StandardModel:Vcd (`default = 0.2271`; `minimum = 0.224`; `maximum = 0.230`)
The V_cd CKM matrix element.

`parm` StandardModel:Vcs (`default = 0.97296`; `minimum = 0.972`; `maximum = 0.974`)
The V_cs CKM matrix element.

`parm` StandardModel:Vcb (`default = 0.04221`; `minimum = 0.0418`; `maximum = 0.0426`)
The V_cb CKM matrix element.

`parm` StandardModel:Vtd (`default = 0.00814`; `minimum = 0.006`; `maximum = 0.010`)
The V_td CKM matrix element.

`parm` StandardModel:Vts (`default = 0.04161`; `minimum = 0.039`; `maximum = 0.043`)
The V_ts CKM matrix element.

`parm` StandardModel:Vtb (`default = 0.9991`; `minimum = 0.99907`; `maximum = 0.9992`)
The V_tb CKM matrix element.

### The CoupSM class

The `Pythia` class contains a public instance `coupSM` of the `CoupSM` class. This class contains one instance each of the `AlphaStrong` and `AlphaEM` classes, and additionally stores the weak couplings and the quark mixing matrix mentioned above. This class is used especially in the calculation of cross sections and resonance widths, but could also be used elsewhere. Specifically, as already mentioned, there are separate `AlphaStrong` and `AlphaEM` instances for timelike and spacelike showers and for multiparton interactions, while weak couplings and the quark mixing matrix are only stored here. With the exception of the first two methods below, which are for internal use, the subsequent ones could also be used externally.

CoupSM::CoupSM()
the constructor does nothing. Internal.

void CoupSM::init(Settings& settings, Rndm* rndmPtr)
this is where the `AlphaStrong` and `AlphaEM` instances are initialized, and weak couplings and the quark mixing matrix are read in and set. This is based on the values stored on this page and among the Couplings and Scales. Internal.

double CoupSM::alphaS(double scale2)
the alpha_strong value at the quadratic scale `scale2`.

double CoupSM::alphaS1Ord(double scale2)
a first-order overestimate of the full second-order alpha_strong value at the quadratic scale `scale2`.

double CoupSM::alphaS2OrdCorr(double scale2)
a multiplicative correction factor, below unity, that brings the first-order overestimate above into agreement with the full second-order alpha_strong value at the quadratic scale `scale2`.

double CoupSM::Lambda3()
double CoupSM::Lambda4()
double CoupSM::Lambda5()
the three-, four-, and five-flavour Lambda scale.

double CoupSM::alphaEM(double scale2)
the alpha_em value at the quadratic scale `scale2`.

double CoupSM::sin2thetaW()
double CoupSM::cos2thetaW()
the sine-squared and cosine-squared of the weak mixing angle, as used in the gauge-boson sector.

double CoupSM::sin2thetaWbar()
the sine-squared of the weak mixing angle, as used to derive the vector couplings of fermions to the Z^0.

double CoupSM::GF()
the Fermi constant of weak decays, in GeV^-2.

double CoupSM::ef(int idAbs)
the electrical charge of a fermion, by the absolute sign of the PDF code, i.e. `idAbs` must be in the range between 1 and 18.

double CoupSM::vf(int idAbs)
double CoupSM::af(int idAbs)
the vector and axial charges of a fermion, by the absolute sign of the PDF code (a_f = +-1, v_f = a_f - 4. * sin2thetaWbar * e_f).

double CoupSM::t3f(int idAbs)
double CoupSM::lf(int idAbs)
double CoupSM::rf(int idAbs)
the weak isospin, left- and righthanded charges of a fermion, by the absolute sign of the PDF code (t^3_f = a_f/2, l_f = (v_f + a_f)/2, r_f = (v_f - a_f)/2; you may find other conventions in the literature that differ by a factor of 2).

double CoupSM::ef2(int idAbs)
double CoupSM::vf2(int idAbs)
double CoupSM::af2(int idAbs)
double CoupSM::efvf(int idAbs)
double CoupSM::vf2af2(int idAbs)
common quadratic combinations of the above couplings: e_f^2, v_f^2, a_f^2, e_f * v_f, v_f^2 + a_f^2.

double CoupSM::VCKMgen(int genU, int genD)
double CoupSM::V2CKMgen(int genU, int genD)
the CKM mixing element, or the square of it, for up-type generation index `genU` (1 = u, 2 = c, 3 = t, 4 = t') and down-type generation index `genD` (1 = d, 2 = s, 3 = b, 4 = b').

double CoupSM::VCKMid(int id1, int id2)
double CoupSM::V2CKMid(int id1, int id2)
the CKM mixing element,or the square of it, for flavours `id1` and `id2`, both in the range from -18 to +18. The sign is here not checked (so it can be used both for u + dbar → W+ and u → d + W+, say), but impossible flavour combinations evaluate to zero. The neutrino sector is numbered by flavor eigenstates, so there is no mixing in the lepton-neutrino system.

double CoupSM::V2CKMsum(int id)
the sum of squared CKM mixing element that a given flavour can couple to, excluding the top quark and fourth generation. Is close to unity for the first two generations. Returns unity for the lepton-neutrino sector.

int CoupSM::V2CKMpick(int id)
picks a random CKM partner quark or lepton (with the same sign as `id`) according to the respective squared elements, again excluding the top quark and fourth generation from the list of possibilities. Unambiguous choice for the lepton-neutrino sector.

### Running coupling in an SU(N) group

Included in the code is also a class for the running of the coupling in an arbitrary SU(N) gauge group. This is not part of the Standard Model, but is closely related to the running of alpha_strong, so is therefore documented and encoded in its proximity. Currently it is used in the Hidden Valley scenario.

`class` AlphaSUN
Running couplings in an SU(N) gauge group, to first, second or third order. See definitions in [Rit97], [Yao06] and [Pro07]. There are assumed to be no flavour thresholds, i.e. the number of flavours is a fixed number over the considered range of scales.

AlphaSUN::AlphaSUN()
the constructor does nothing. You need to use one of the following two methods to initialize the generation.

void AlphaSUN::initAlpha( int nC, int nF, int order = 1, double alpha = 0.12, double scale = 91.188)
Set up the required framework for running, given the number of colours, number of flavours, order of running (1, 2 or 3) and the coupling strength at a reference scale (by default the Z^0 mass).

void AlphaSUN::initLambda( int nC, int nF, int order = 1, double Lambda = 0.2)
Set up the required framework for running, given the number of colours, number of flavours, order of running (1, 2 or 3) and the Lambda parameter to the given order.

double AlphaSUN::alpha(double scale2)
return the coupling value at the input scale-squared.

double AlphaSUN::alpha1Ord(double scale2)
double AlphaSUN::alpha2OrdCorr(double scale2)
the first method gives a simple first-order running coupling value (but with the second- or third-order Lambda) and the second method gives the correction factor, below unity, for the second- or third-order terms. This allows a compact handling of shower evolution equations.

double AlphaSUN::Lambda()
return the Lambda determined by a `initAlpha` call. If instead `initLambda` has been used, the input value there will be echoed.