- The strong coupling
- The electromagnetic coupling
- The electroweak couplings
- The quark weak-mixing matrix
- The CoupSM class
- Running coupling in an
**SU(N)**group

`AlphaStrong`

class is used to provide a first-, second-
or third-order running
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.

`AlphaEM`

class is used to generate a running
`StandardModel:alphaEMmZ`

value at the
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.

`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*.

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

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

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