a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
StandardModel Class Reference

A model class for the Standard Model. More...

#include <StandardModel.h>

+ Inheritance diagram for StandardModel:

Detailed Description

A model class for the Standard Model.

Author
HEPfit Collaboration

This is a Model class containing parameters and functions associated with the Standard Model. This class is inherited from the QCD class, which defines parameters related to QCD.

Initialization

The constructor StandardModel() initializes some of the model flags to their default values. After creating an instance of the current class, it is required to call the initialization method InitializeModel(), which allocates memory to the pointers defined in the current class. These pointers are then used in computing EW precision and flavour observables, respectively. In the Monte Carlo run, the constructor as well as the initialization method are called in InputParser::ReadParameters().

The initializations and updates of the model parameters and flags are explained below.

Model parameters

The model parameters of StandardModel are summarized below:

Label LaTeX symbol Description
Mz \(M_Z\) The mass of the \(Z\) boson in GeV.
AlsMz \(\alpha_s(M_Z)\) The strong coupling constant at the Z-boson mass.
GF \(G_\mu\) The Fermi constant in \({\rm GeV}^{-2}\), measured through muon decays.
ale \(\alpha\) The fine-structure constant.
dAle5Mz \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\) The five-flavour hadronic contribution to the electromagnetic coupling.
mHl \(m_h\) The Higgs mass in GeV.
delMw \(\delta\,M_W\) The theoretical uncertainty in \(M_W\) in GeV, which is applicable only when EWSMApproximateFormulae::Mw() is employed for \(M_W\). See also the model flag Mw.
delSin2th_l \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_l() is employed for \(\sin^2\theta_{\rm eff}^{\rm lept}\). See also the model flag KappaZ.
delSin2th_q \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_q() is employed for \(\sin^2\theta_{\rm eff}^{q\not = b,t}\). See also the model flag KappaZ.
delSin2th_b \(\delta\sin^2\theta_{\rm eff}^{b}\) The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), which is applicable only when EWSMApproximateFormulae::sin2thetaEff_b() is employed for \(\sin^2\theta_{\rm eff}^{b}\). See also the model flag KappaZ.
delGammaZ \(\delta\,\Gamma_Z\) The theoretical uncertainty in \(\Gamma_Z\) in GeV, which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(\Gamma_Z\). See also the model flag NoApproximateGammaZ.
delsigma0H \(\delta\,\sigma_{Hadron}^0\) The theoretical uncertainty in \(\sigma_{Hadron}^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(\sigma_{Hadron}^0\).
delR0l \(\delta\,R_l^0\) The theoretical uncertainty in \(R_l^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_l^0\).
delR0c \(\delta\,R_c^0\) The theoretical uncertainty in \(R_c^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_c^0\).
delR0b \(\delta\,R_b^0\) The theoretical uncertainty in \(R_b^0\), which is applicable only when EWSMApproximateFormulae::X_full_2_loop() is employed for \(R_b^0\).
mneutrino_1 \(m_{\nu_1}\) The mass of the first-generation neutrino in GeV.
mneutrino_2 \(m_{\nu_2}\) The mass of the second-generation neutrino in GeV.
mneutrino_3 \(m_{\nu_3}\) The mass of the third-generation neutrino in GeV.
melectron \(m_e\) The electron mass in GeV.
mmu \(m_\mu\) The muon mass in GeV.
mtau \(m_\tau\) The tau mass in GeV.
lambda \(\lambda\) The CKM parameter \(\lambda\) in the Wolfenstein parameterization.
A \(A\) The CKM parameter \(A\) in the Wolfenstein parameterization.
rhob \(\bar{\rho}\) The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.
etab \(\bar{\eta}\) The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.
muw \(\mu_W\) A matching scale around the weak scale in GeV.

The set of the model parameters are initialized and updated with the methods Init() and Update(), respectively, where the former calls the latter actually. In Update(), the methods PreUpdate() and PostUpdate() are called to run all the procedures that are need to be executed before and after the model parameters are updated. The CKM and PMNS matrices and the Yukawa matrices are recomputed in PostUpdate() with the updated parameters. Inside the Update() method, the individual model parameter is assigned with the protected member function setParameter().

The parameters delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b represent theoretical uncertainties in the \(W\)-boson mass, the leptonic and quark effective weak mixing angles at the \(Z\)-boson mass scale, the total decay width of the \(Z\) boson, the hadronic cross section at the peak, and the ratios \(R_l^0\), \(R_c^0\) and \(R_b^0\), respectively, originating from missing higher-order corrections. The contributions from these parameters are incorporated into their two-loop approximate formulae: EWSMApproximateFormulae::Mw(), EWSMApproximateFormulae::sin2thetaEff_l(), EWSMApproximateFormulae::sin2thetaEff_q(), EWSMApproximateFormulae::sin2thetaEff_b(), EWSMApproximateFormulae::X_full_2_loop("GammaZ"), EWSMApproximateFormulae::X_full_2_loop("sigmaHadron"), EWSMApproximateFormulae::X_full_2_loop("R0_lepton"), EWSMApproximateFormulae::X_full_2_loop("R0_charm") and EWSMApproximateFormulae::X_full_2_loop("R0_bottom"). Therefore, the parameters are applicable only when the corresponding approximate formulae are employed. See also the model flags below.

Model flags

The flags of StandardModel are summarized below, where the values of the boolean flags (TRUE or FALSE) are case insensitive, while those of the other flags are case sensitive. The default values of the flags are indicated in bold:

Label Value Description
Wolfenstein TRUE / FALSE This flag controls the way the CKM matrix is parameterized. If set to TRUE, the CKM matrix is computed starting from the Wolfenstein parameters. If set to FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). The default value is TRUE.
CacheInStandardModel TRUE / FALSE This flag controls the use of the cashing method implemented in EWSM class. The default value is TRUE.
CacheInEWSMcache TRUE / FALSE This flag controls the use of the cashing method implemented in EWSMcache class. The default value is TRUE.
WithoutNonUniversalVC TRUE / FALSE This flag controls if flavour non-universal vertex corrections are not added to the epsilon parameterization for the EW precision observables. The default value is FALSE; the non-universal corrections are taken into account.
NoApproximateGammaZ TRUE / FALSE This flag is set to true if the two-loop approximate formulae of the partial and total decay widths of the \(Z\) boson defined with the function EWSMApproximateFormulae::X_full_2_loop() are NOT employed. The default value is FALSE.
Mw NORESUM / OMSI / INTERMEDIATE / OMSII / APPROXIMATEFORMULA This flag controls the formula used in computing the \(W\)-boson mass. The default flag is APPROXIMATEFORMULA. See EWSM::Mw_SM(), EWSM::resumMw() and EWSMApproximateFormulae::Mw() for detail.
RhoZ NORESUM / OMSI / INTERMEDIATE / OMSII This flag controls the formula used in computing the \(Zf\bar{f}\) couplings \(\rho_Z^f\). The default flag is NORESUM. See EWSM::rhoZ_l_SM(), EWSM::rhoZ_q_SM() and EWSM::resumRhoZ() for detail.
KappaZ NORESUM / OMSI / INTERMEDIATE / OMSII / APPROXIMATEFORMULA This flag controls the formula used in computing the \(Zf\bar{f}\) couplings \(\kappa_Z^f\). The default flag is APPROXIMATEFORMULA. See EWSM::kappaZ_l_SM(), EWSM::kappaZ_q_SM() and EWSM::resumKappaZ() for detail.
SMAux TRUE / FALSE This auxiliary flag is used for testing new options. The default value is FALSE.

These flags can be set via the method setFlag() or setFlagStr(), where the former is applicable for the boolean flags, while the latter is for the other flags. The method CheckFlags() is responsible for checking whether the flags are sane. The public member functions IsFlagWithoutNonUniversalVC(), IsFlagNoApproximateGammaZ() getFlagMw(), getFlagRhoZ() and getFlagKappaZ() are used to retrieve the values of each flag.

The first two flags CacheInStandardModel and CacheInEWSMcache for the cashing methods in EWSM and EWSMcache classes are relevant to the computations of the electroweak precision observables. Those caches are effective when the \(W\)-boson mass, the decay widths of the \(Z\) boson and the \(Zf\bar{f}\) effective couplings \(\kappa_Z^f\) are calculated without using their two-loop approximate formulae.

Notation

The on-mass-shell renormalization scheme [168], [160], [34], [35] is adopted for UV divergences, and the weak mixing angle is defined in terms of the physical masses of the gauge bosons:

\[ s_W^2 \equiv \sin^2\theta_W = 1 - \frac{M_W^2}{M_Z^2}\,, \]

and \(c_W^2=1-s_W^2\).

The Fermi constant \(G_\mu\) in \(\mu\) decay is taken as an input quantity instead of the \(W\)-boson mass, since the latter has not been measured very precisely compared to the former. The relation between \(G_\mu\) and \(M_W\) is written as

\[ G_\mu = \frac{\pi\,\alpha}{\sqrt{2} s_W^2 M_W^2} (1+\Delta r)\,, \]

where \(\Delta r\) represents radiative corrections. From this relation, the \(W\)-boson mass is calculated as

\[ M_W^2 = \frac{M_Z^2}{2} \left( 1+\sqrt{1-\frac{4\pi\alpha}{\sqrt{2}G_\mu M_Z^2}\,(1+\Delta r)}\ \right). \]

The interaction between the \(Z\) boson and the neutral current can be written in terms of the effective \(Zf\bar{f}\) couplings \(g_{V}^f\) and \(g_{A}^f\), of \(g_{R}^f\) and \(g_{L}^f\), or of \(\rho_Z^f\) and \(\kappa_Z^f\):

\begin{eqnarray} \mathcal{L} &=& \frac{e}{2 s_W c_W}\, Z_\mu \sum_f \bar{f} \left( g_{V}^f\gamma_\mu - g_{A}^f \gamma_\mu\gamma_5 \right)\, f\,, \\ &=& \frac{e}{2s_W c_W}\, Z_\mu \sum_f \bar{f} \left[ g_{R}^f \gamma_\mu (1 + \gamma_5) + g_{L}^f \gamma_\mu (1 - \gamma_5) \right]\, f\,, \\ &=& \frac{e}{2 s_W c_W}\sqrt{\rho_Z^f}\, Z_\mu \sum_f \bar{f} \left[( I_3^f - 2Q_f\kappa_Z^f s_W^2)\gamma^\mu - I_3^f\gamma^\mu\gamma_5\right]\,f\,, \end{eqnarray}

where \(\rho_Z^f\) and \(\kappa_Z^f\) are related to \(g_{V}^f\) and \(g_{A}^f\) as the relations:

\begin{eqnarray} g_V^f &=& \sqrt{\rho_Z^f} I_3^f (1 - 4|Q_f|\kappa_Z^fs_W^2) = \sqrt{\rho_Z^f} (I_3^f - 2Q_f\kappa_Z^fs_W^2)\,, \qquad g_A^f &=& \sqrt{\rho_Z^f} I_3^f\,, \end{eqnarray}

and

\begin{eqnarray} \rho_Z^f &=& \left( \frac{g_A^f}{I_3^f} \right)^2, \qquad \kappa_Z^f &=& \frac{1}{4|Q_f|s_W^2} \left( 1 - \frac{g_V^{f}}{g_A^{f}}\right). \end{eqnarray}

Important member functions

The current class handles the following quantities:

  • \(M_W\)   (with Mw_SM()),
  • \(\Delta r\)   (with DeltaR_SM()),
  • \(c_W^2\) and \(s_W^2\)   (with cW2_SM() and sW2_SM()),
  • \(\Gamma_W\)   (with GammaW_SM()),
  • \(\rho_Z^f\)   (with rhoZ_l() and rhoZ_q()),
  • \(\kappa_Z^f\)   (with kappaZ_l() and kappaZ_q()),
  • \(g_V^f\)   (with gVl() and gVq()),
  • \(g_A^f\)   (with gAl() and gAq()),
  • \(\varepsilon_{1,2,3,b}\)   (with epsilon1_SM(), epsilon2_SM(), epsilon3_SM() and epsilonb_SM()).

Moreover, the functions Mzbar(), MwbarFromMw(), MwFromMwbar() and DeltaRbar_SM() can be used for the quantities in the complex-pole/fixed-width scheme.

Schemes

The formulae used for the \(W\)-boson mass \(M_W\) and the effective couplings \(\rho_Z^f\) and \(\kappa_Z^f\) are controlled with the model flags Mw, RhoZ and KappaZ of StandardModel. For each flag, the available schemes are as follows:

  • NORESUM:   No resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   the approximate two-loop formula given in EWSMApproximateFormulae class is employed.

The scheme APPROXIMATEFORMULA provides the most accurate SM predictions for \(M_W\) and \(\kappa_Z^f\), while the approximate two-loop formula is not available for \(\rho_Z^f\).

See resumMw(), resumRhoZ() and resumKappaZ() for details on the other schemes.

Caches

This class contains caching methods for the following functions: DeltaAlphaLepton(), DeltaAlpha(), Mw_SM(), GammaW_SM(), rhoZ_l_SM(), rhoZ_q_SM(), kappaZ_l_SM() and kappaZ_q_SM(), to improve the performance of the Monte Carlo run. The caching methods are implemented with the function checkSMparams().

The use of the caching methods can be controlled with the model flag CacheInStandardModel of StandardModel.

Examples
myModel.cpp, myModel.h, myObservables.cpp, and myObservables.h.

Definition at line 474 of file StandardModel.h.

Public Types

enum  LEP2RCs { Weak = 0, WeakBox, ISR, QEDFSR, QCDFSR, NUMofLEP2RCs }
 
enum  orders_EW { EW1 = 0, EW1QCD1, EW1QCD2, EW2, EW2QCD1, EW3, orders_EW_size }
 An enumerated type representing perturbative orders of radiative corrections to EW precision observables. More...
 
- Public Types inherited from QCD
enum  lepton { NEUTRINO_1, ELECTRON, NEUTRINO_2, MU, NEUTRINO_3, TAU, NOLEPTON }
 An enum type for leptons. More...
 
enum  meson { P_0, P_P, K_0, K_P, D_0, D_P, B_D, B_P, B_S, B_C, PHI, K_star, K_star_P, D_star_P, RHO, RHO_P, OMEGA, MESON_END }
 An enum type for mesons. More...
 
enum  quark { UP, DOWN, CHARM, STRANGE, TOP, BOTTOM }
 An enum type for quarks. More...
 

Public Member Functions

virtual double A_f (const Particle f) const
 The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\). More...
 
virtual double AFB (const Particle f) const
 
double Ale (double mu, orders order, bool Nf_thr=true) const
 The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme. More...
 
double ale_OS (const double mu, orders order=FULLNLO) const
 The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme. More...
 
double alphaMz () const
 The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\). More...
 
double Als (double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
 The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections. More...
 
double AlsByOrder (double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
 
double Alstilde5 (const double mu) const
 The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections. More...
 
double Beta_e (int nm, unsigned int nf) const
 QED beta function coefficients - eq. (36) hep-ph/0512066. More...
 
double Beta_s (int nm, unsigned int nf) const
 QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066. More...
 
double c02 () const
 The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections. More...
 
virtual bool CheckFlags () const
 A method to check the sanity of the set of model flags. More...
 
virtual bool CheckParameters (const std::map< std::string, double > &DPars)
 A method to check if all the mandatory parameters for StandardModel have been provided in model initialization. More...
 
bool checkSMparamsForEWPO ()
 A method to check whether the parameters relevant to the EWPO are updated. More...
 
double computeBrHtobb () const
 The Br \((H\to bb)\) in the Standard Model. More...
 
double computeBrHtocc () const
 The Br \((H\to cc)\) in the Standard Model. More...
 
double computeBrHtogaga () const
 The Br \((H\to\gamma\gamma)\) in the Standard Model. More...
 
double computeBrHtogg () const
 The Br \((H\to gg)\) in the Standard Model. More...
 
double computeBrHtomumu () const
 The Br \((H\to \mu\mu)\) in the Standard Model. More...
 
double computeBrHtoss () const
 The Br \((H\to ss)\) in the Standard Model. More...
 
double computeBrHtotautau () const
 The Br \((H\to \tau\tau)\) in the Standard Model. More...
 
double computeBrHtoWW () const
 The Br \((H\to WW)\) in the Standard Model. More...
 
double computeBrHtoZga () const
 The Br \((H\to Z\gamma)\) in the Standard Model. More...
 
double computeBrHtoZZ () const
 The Br \((H\to ZZ)\) in the Standard Model. More...
 
double computeBrHtoZZinv () const
 The Br \((H\to ZZ \to inv)\) in the Standard Model. More...
 
void ComputeDeltaR_rem (const double Mw_i, double DeltaR_rem[orders_EW_size]) const
 A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses. More...
 
void ComputeDeltaRho (const double Mw_i, double DeltaRho[orders_EW_size]) const
 A method to collect \(\Delta\rho\) computed via subclasses. More...
 
double computeGammaHgaga_tt () const
 The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
double computeGammaHgaga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
double computeGammaHgaga_WW () const
 The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
double computeGammaHgg_bb () const
 The bottom loop contribution to \(H\to gg\) in the Standard Model. More...
 
double computeGammaHgg_tb () const
 The top-bottom interference contribution to \(H\to gg\) in the Standard Model. More...
 
double computeGammaHgg_tt () const
 The top loop contribution to \(H\to gg\) in the Standard Model. More...
 
double computeGammaHTotal () const
 The Higgs total width in the Standard Model. More...
 
double computeGammaHZga_tt () const
 The top loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
double computeGammaHZga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
double computeGammaHZga_WW () const
 The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [137]. More...
 
double computeSigmaggH (const double sqrt_s) const
 The ggH cross section in the Standard Model. More...
 
double computeSigmaggH_bb (const double sqrt_s) const
 The square of the bottom-quark contribution to the ggH cross section in the Standard Model. More...
 
double computeSigmaggH_tb (const double sqrt_s) const
 The top-bottom interference contribution to the ggH cross section in the Standard Model. More...
 
double computeSigmaggH_tt (const double sqrt_s) const
 The square of the top-quark contribution to the ggH cross section in the Standard Model. More...
 
double computeSigmattH (const double sqrt_s) const
 The ttH production cross section in the Standard Model. More...
 
double computeSigmaVBF (const double sqrt_s) const
 The VBF cross section in the Standard Model. More...
 
double computeSigmaWF (const double sqrt_s) const
 The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model. More...
 
double computeSigmaWH (const double sqrt_s) const
 The WH production cross section in the Standard Model. More...
 
double computeSigmaZF (const double sqrt_s) const
 The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model. More...
 
double computeSigmaZH (const double sqrt_s) const
 The ZH production cross section in the Standard Model. More...
 
double computeSigmaZWF (const double sqrt_s) const
 The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model. More...
 
virtual double cW2 () const
 
virtual double cW2 (const double Mw_i) const
 The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\). More...
 
double DeltaAlpha () const
 The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\). More...
 
double DeltaAlphaL5q () const
 The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\). More...
 
double DeltaAlphaLepton (const double s) const
 Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\). More...
 
double DeltaAlphaTop (const double s) const
 Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\). More...
 
virtual gslpp::complex deltaKappaZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\). More...
 
virtual double DeltaR () const
 The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass. More...
 
virtual double DeltaRbar () const
 The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass. More...
 
virtual gslpp::complex deltaRhoZ_f (const Particle f) const
 Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\). More...
 
virtual double epsilon1 () const
 The SM contribution to the epsilon parameter \(\varepsilon_1\). More...
 
virtual double epsilon2 () const
 The SM contribution to the epsilon parameter \(\varepsilon_2\). More...
 
virtual double epsilon3 () const
 The SM contribution to the epsilon parameter \(\varepsilon_3\). More...
 
virtual double epsilonb () const
 The SM contribution to the epsilon parameter \(\varepsilon_b\). More...
 
virtual gslpp::complex gA_f (const Particle f) const
 The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM. More...
 
virtual double Gamma_had () const
 The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\). More...
 
virtual double Gamma_inv () const
 The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\). More...
 
virtual double Gamma_Z () const
 The total decay width of the \(Z\) boson, \(\Gamma_Z\). More...
 
virtual double GammaW () const
 The total width of the \(W\) boson, \(\Gamma_W\). More...
 
virtual double GammaW (const Particle fi, const Particle fj) const
 A partial decay width of the \(W\) boson decay into a SM fermion pair. More...
 
virtual double GammaZ (const Particle f) const
 The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\). More...
 
double getAle () const
 A get method to retrieve the fine-structure constant \(\alpha\). More...
 
double getAlsMz () const
 A get method to access the value of \(\alpha_s(M_Z)\). More...
 
virtual double getCBd () const
 The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value. More...
 
virtual double getCBs () const
 The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value. More...
 
virtual double getCCC1 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC2 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC3 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC4 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCCC5 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual double getCDMK () const
 The ratio of the real part of the $K$ mixing amplitude over the Standard Model value. More...
 
virtual double getCepsK () const
 The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value. More...
 
CKM getCKM () const
 A get method to retrieve the member object of type CKM. More...
 
double getDAle5Mz () const
 A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). More...
 
double getDelGammaZ () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\). More...
 
double getDelMw () const
 A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\). More...
 
double getDelR0b () const
 A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
double getDelR0c () const
 A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
double getDelR0l () const
 A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
double getDelSigma0H () const
 A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\). More...
 
double getDelSin2th_b () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
double getDelSin2th_l () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
double getDelSin2th_q () const
 A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
std::string getFlagKappaZ () const
 A method to retrieve the model flag KappaZ. More...
 
std::string getFlagMw () const
 A method to retrieve the model flag Mw. More...
 
std::string getFlagRhoZ () const
 A method to retrieve the model flag RhoZ. More...
 
const FlavourgetFlavour () const
 
double getGF () const
 A get method to retrieve the Fermi constant \(G_\mu\). More...
 
int getIterationNo () const
 
Particle getLeptons (const QCD::lepton p) const
 A get method to retrieve the member object of a lepton. More...
 
virtual StandardModelMatchinggetMatching () const
 A get method to access the member reference of type StandardModelMatching. More...
 
virtual double getMHl () const
 A get method to retrieve the Higgs mass \(m_h\). More...
 
virtual double getmq (const QCD::quark q, const double mu) const
 
double getMuw () const
 A get method to retrieve the matching scale \(\mu_W\) around the weak scale. More...
 
EWSMApproximateFormulaegetMyApproximateFormulae () const
 A get method to retrieve the member pointer of type EWSMApproximateFormulae. More...
 
EWSMcachegetMyEWSMcache () const
 A get method to retrieve the member pointer of type EWSMcache. More...
 
LeptonFlavourgetMyLeptonFlavour () const
 
EWSMOneLoopEWgetMyOneLoopEW () const
 A get method to retrieve the member pointer of type EWSMOneLoopEW,. More...
 
EWSMThreeLoopEWgetMyThreeLoopEW () const
 
EWSMThreeLoopEW2QCDgetMyThreeLoopEW2QCD () const
 
EWSMThreeLoopQCDgetMyThreeLoopQCD () const
 
EWSMTwoLoopEWgetMyTwoLoopEW () const
 
EWSMTwoLoopQCDgetMyTwoLoopQCD () const
 
double getMz () const
 A get method to access the mass of the \(Z\) boson \(M_Z\). More...
 
virtual double getPhiBd () const
 Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual double getPhiBs () const
 Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual StandardModel getTrueSM () const
 
gslpp::matrix< gslpp::complexgetUPMNS () const
 A get method to retrieve the object of the PMNS matrix. More...
 
gslpp::matrix< gslpp::complexgetVCKM () const
 A get method to retrieve the CKM matrix. More...
 
gslpp::matrix< gslpp::complexgetYd () const
 A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
gslpp::matrix< gslpp::complexgetYe () const
 A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
gslpp::matrix< gslpp::complexgetYn () const
 A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\). More...
 
gslpp::matrix< gslpp::complexgetYu () const
 A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual gslpp::complex gV_f (const Particle f) const
 The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM. More...
 
virtual bool Init (const std::map< std::string, double > &DPars)
 A method to initialize the model parameters. More...
 
virtual bool InitializeModel ()
 A method to initialize the model. More...
 
bool IsFlagNoApproximateGammaZ () const
 A method to retrieve the model flag NoApproximateGammaZ. More...
 
bool IsFlagWithoutNonUniversalVC () const
 A method to retrieve the model flag WithoutNonUniversalVC. More...
 
virtual gslpp::complex kappaZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM. More...
 
virtual double Mw () const
 The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\). More...
 
virtual double Mw_tree () const
 The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\). More...
 
double MwbarFromMw (const double Mw) const
 A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme. More...
 
double MwFromMwbar (const double Mwbar) const
 A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme. More...
 
double Mzbar () const
 The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme. More...
 
virtual double N_nu () const
 The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\). More...
 
virtual bool PostUpdate ()
 The post-update method for StandardModel. More...
 
virtual bool PreUpdate ()
 The pre-update method for StandardModel. More...
 
virtual double R0_f (const Particle f) const
 The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\). More...
 
virtual double R_inv () const
 The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\). More...
 
virtual double rho_GammaW (const Particle fi, const Particle fj) const
 EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\). More...
 
virtual gslpp::complex rhoZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM. More...
 
double s02 () const
 The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections. More...
 
virtual bool setFlag (const std::string name, const bool value)
 A method to set a flag of StandardModel. More...
 
void setFlagCacheInStandardModel (bool FlagCacheInStandardModel)
 A set method to change the model flag CacheInStandardModel of StandardModel. More...
 
void setFlagNoApproximateGammaZ (bool FlagNoApproximateGammaZ)
 
virtual bool setFlagStr (const std::string name, const std::string value)
 A method to set a flag of StandardModel. More...
 
virtual double sigma0_had () const
 The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\). More...
 
virtual double sin2thetaEff (const Particle f) const
 The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale. More...
 
 StandardModel ()
 The default constructor. More...
 
double sW2 () const
 
virtual double sW2 (const double Mw_i) const
 The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\). More...
 
virtual bool Update (const std::map< std::string, double > &DPars)
 The update method for StandardModel. More...
 
virtual double v () const
 The Higgs vacuum expectation value. More...
 
virtual ~StandardModel ()
 The default destructor. More...
 
- Public Member Functions inherited from QCD
double AboveTh (const double mu) const
 The active flavour threshold above the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
void addParameters (std::vector< std::string > params_i)
 A method to add parameters that are specific to only one set of observables. More...
 
virtual double Als (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
double Als4 (const double mu) const
 The value of \(\alpha_s^{\mathrm{FULLNLO}}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\). More...
 
virtual double AlsByOrder (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
double AlsOLD (const double mu, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
double AlsWithInit (const double mu, const double alsi, const double mu_i, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) from \(\alpha_s(\mu_i)\) in the \(\overline{\mathrm{MS}}\) scheme, where it is forbidden to across a flavour threshold in the RG running from \(\mu_i\) to \(\mu\). More...
 
double AlsWithLambda (const double mu, const orders order) const
 Computes the running strong coupling \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with the use of \(\Lambda_{\rm QCD}\). More...
 
double BelowTh (const double mu) const
 The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
double Beta0 (const double nf) const
 The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
double Beta1 (const double nf) const
 The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
double Beta2 (const double nf) const
 The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
double Beta3 (const double nf) const
 The \(\beta_3(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
void CacheShift (double cache[][5], int n) const
 A member used to manage the caching for this class. More...
 
void CacheShift (int cache[][5], int n) const
 
orders FullOrder (orders order) const
 Return the FULLORDER enum corresponding to order. More...
 
double Gamma0 (const double nf) const
 The \(\gamma_0\) coefficient used to compute the running of a mass. More...
 
double Gamma1 (const double nf) const
 The \(\gamma_1\) coefficient used to compute the running of a mass. More...
 
double Gamma2 (const double nf) const
 The \(\gamma_2\) coefficient used to compute the running of a mass. More...
 
double getAlsM () const
 A get method to access the value of \(\alpha_s(M_{\alpha_s})\). More...
 
BParameter getBBd () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
BParameter getBBs () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
BParameter getBD () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta c = 2\) process in the \(D^0\) meson system. More...
 
BParameter getBK () const
 For getting the bag parameters corresponding to the operator basis \(O_1 -O_5\) in \(\Delta s = 2\) process in the \(K^0\) meson system. More...
 
BParameter getBKd1 () const
 
BParameter getBKd3 () const
 
double getCF () const
 A get method to access the Casimir factor of QCD. More...
 
double getMAls () const
 A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided. More...
 
Meson getMesons (const QCD::meson m) const
 A get method to access a meson as an object of the type Meson. More...
 
double getMtpole () const
 A get method to access the pole mass of the top quark. More...
 
double getMub () const
 A get method to access the threshold between five- and four-flavour theory in GeV. More...
 
double getMuc () const
 A get method to access the threshold between four- and three-flavour theory in GeV. More...
 
double getMut () const
 A get method to access the threshold between six- and five-flavour theory in GeV. More...
 
double getNc () const
 A get method to access the number of colours \(N_c\). More...
 
double getOptionalParameter (std::string name) const
 A method to get parameters that are specific to only one set of observables. More...
 
Particle getQuarks (const QCD::quark q) const
 A get method to access a quark as an object of the type Particle. More...
 
std::vector< std::string > getUnknownParameters ()
 A method to get the vector of the parameters that have been specified in the configuration file but not being used. More...
 
void initializeBParameter (std::string name_i) const
 A method to initialize B Parameter and the corresponding meson. More...
 
void initializeMeson (QCD::meson meson_i) const
 A method to initialize a meson. More...
 
double logLambda (const double nf, orders order) const
 Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV. More...
 
double Mbar2Mp (const double mbar, const orders order=FULLNNLO) const
 Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass. More...
 
double Mp2Mbar (const double mp, const orders order=FULLNNLO) const
 Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
double Mrun (const double mu, const double m, const orders order=FULLNNLO) const
 Computes a running quark mass \(m(\mu)\) from \(m(m)\). More...
 
double Mrun (const double mu_f, const double mu_i, const double m, const orders order=FULLNNLO) const
 Runs a quark mass from \(\mu_i\) to \(\mu_f\). More...
 
double Mrun4 (const double mu_f, const double mu_i, const double m) const
 The running of a mass with the number of flavours \(n_f = 4\). More...
 
double MS2DRqmass (const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
double MS2DRqmass (const double MSscale, const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
double Nf (const double mu) const
 The number of active flavour at scale \(\mu\). More...
 
double NfThresholdCorrections (double mu, double M, double als, int nf, orders order) const
 Threshold corrections in matching \(\alpha_s(n_f+1)\) with \(\alpha_s(n_f)\) from eq. (34) of hep-ph/0512060. More...
 
std::string orderToString (const orders order) const
 Converts an object of the enum type "orders" to the corresponding string. More...
 
 QCD ()
 Constructor. More...
 
void setNc (double Nc)
 A set method to change the number of colours \(N_c\). More...
 
void setOptionalParameter (std::string name, double value)
 A method to set the parameter value for the parameters that are specific to only one set of observables. More...
 
double Thresholds (const int i) const
 For accessing the active flavour threshold scales. More...
 
- Public Member Functions inherited from Model
void addMissingModelParameter (const std::string &missingParameterName)
 
std::vector< std::string > getmissingModelParameters ()
 
unsigned int getMissingModelParametersCount ()
 
std::string getModelName () const
 A method to fetch the name of the model. More...
 
const double & getModelParam (std::string name) const
 
bool isModelGeneralTHDM () const
 
bool isModelGeorgiMachacek () const
 
bool IsModelInitialized () const
 A method to check if the model is initialized. More...
 
bool isModelLinearized () const
 
bool isModelParam (std::string name) const
 
bool isModelSUSY () const
 
bool isModelTHDM () const
 
bool isModelTHDMW () const
 
bool IsUpdateError () const
 A method to check if there was any error in the model update process. More...
 
 Model ()
 The default constructor. More...
 
void raiseMissingModelParameterCount ()
 
void setModelGeneralTHDM ()
 
void setModelGeorgiMachacek ()
 
void setModelInitialized (bool ModelInitialized)
 A set method to fix the failure or success of the initialization of the model. More...
 
void setModelLinearized (bool linearized=true)
 
void setModelName (const std::string name)
 A method to set the name of the model. More...
 
void setModelSUSY ()
 
void setModelTHDM ()
 
void setModelTHDMW ()
 
void setSliced (bool Sliced)
 
void setUpdateError (bool UpdateError)
 A set method to fix the update status as success or failure. More...
 
virtual ~Model ()
 The default destructor. More...
 

Static Public Attributes

static const double GeVminus2_to_nb = 389379.338
 
static const double Mw_error = 0.00001
 The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV. More...
 
static const int NSMvars = 26
 The number of the model parameters in StandardModel. More...
 
static const int NumSMParamsForEWPO = 33
 The number of the SM parameters that are relevant to the EW precision observables. More...
 
static std::string SMvars [NSMvars]
 A string array containing the labels of the model parameters in StandardModel. More...
 
- Static Public Attributes inherited from QCD
static const int NQCDvars = 11
 The number of model parameters in QCD. More...
 
static std::string QCDvars [NQCDvars]
 An array containing the labels under which all QCD parameters are stored in a vector of ModelParameter via InputParser::ReadParameters(). More...
 

Protected Member Functions

bool checkEWPOscheme (const std::string scheme) const
 A method to check if a given scheme name in string form is valid. More...
 
virtual void computeCKM ()
 The method to compute the CKM matrix. More...
 
virtual void computeYukawas ()
 The method to compute the Yukawa matrices. More...
 
double Delta_EWQCD (const QCD::quark q) const
 The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\). More...
 
double m_q (const QCD::quark q, const double mu, const orders order=FULLNLO) const
 
double RAq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\). More...
 
double resumKappaZ (const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
 A method to compute the real part of the effetvive coupling \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double resumMw (const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
 A method to compute the \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double resumRhoZ (const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
 A method to compute the real part of the effective coupling \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\). More...
 
double RVh () const
 The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\). More...
 
double RVq (const QCD::quark q) const
 The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\). More...
 
double SchemeToDouble (const std::string scheme) const
 A method to convert a given scheme name in string form into a floating-point number with double precision. More...
 
virtual void setParameter (const std::string name, const double &value)
 A method to set the value of a parameter of StandardModel. More...
 
double taub () const
 Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\). More...
 
- Protected Member Functions inherited from QCD
double MassOfNf (int nf) const
 The Mbar mass of the heaviest quark in the theory with Nf active flavour. More...
 

Protected Attributes

double A
 The CKM parameter \(A\) in the Wolfenstein parameterization. More...
 
double ale
 The fine-structure constant \(\alpha\). More...
 
double alpha21
 
double alpha31
 
double AlsMz
 The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\). More...
 
double dAle5Mz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). More...
 
double delGammaZ
 The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV. More...
 
double delMw
 The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV. More...
 
double delR0b
 The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
double delR0c
 The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
double delR0l
 The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
double delsigma0H
 The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb. More...
 
double delSin2th_b
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\). More...
 
double delSin2th_l
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\). More...
 
double delSin2th_q
 The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\). More...
 
double delta
 
double etab
 The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization. More...
 
bool flag_order [orders_EW_size]
 An array of internal flags controlling the inclusions of higher-order corrections. More...
 
double gamma
 \(\gamma \) used as an input for FlagWolfenstein = FALSE More...
 
double GF
 The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\). More...
 
double lambda
 The CKM parameter \(\lambda\) in the Wolfenstein parameterization. More...
 
Particle leptons [6]
 An array of Particle objects for the leptons. More...
 
double mHl
 The Higgs mass \(m_h\) in GeV. More...
 
double muw
 A matching scale \(\mu_W\) around the weak scale in GeV. More...
 
CKM myCKM
 An object of type CKM. More...
 
PMNS myPMNS
 
double Mz
 The mass of the \(Z\) boson in GeV. More...
 
bool requireCKM
 An internal flag to control whether the CKM matrix has to be recomputed. More...
 
bool requireYe
 An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed. More...
 
bool requireYn
 An internal flag to control whether the neutrino Yukawa matrix has to be recomputed. More...
 
double rhob
 The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization. More...
 
double s12
 
double s13
 
double s23
 
Flavour SMFlavour
 An object of type Flavour. More...
 
Matching< StandardModelMatching, StandardModelSMM
 An object of type Matching. More...
 
double Vcb
 \(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vub
 \(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
double Vus
 \(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
gslpp::matrix< gslpp::complexYd
 The Yukawa matrix of the down-type quarks. More...
 
gslpp::matrix< gslpp::complexYe
 The Yukawa matrix of the charged leptons. More...
 
gslpp::matrix< gslpp::complexYn
 The Yukawa matrix of the neutrinos. More...
 
gslpp::matrix< gslpp::complexYu
 The Yukawa matrix of the up-type quarks. More...
 
- Protected Attributes inherited from QCD
double AlsM
 The strong coupling constant at the mass scale MAls, \(\alpha_s(M_{\alpha_s})\). More...
 
double CA
 
double CF
 
bool computemt
 Switch for computing the \(\overline{\mathrm{MS}}\) mass of the top quark. More...
 
double dAdA_NA
 
double dFdA_NA
 
double dFdF_NA
 
double MAls
 The mass scale in GeV at which the strong coupling measurement is provided. More...
 
double mtpole
 The pole mass of the top quark. More...
 
double mub
 The threshold between five- and four-flavour theory in GeV. More...
 
double muc
 The threshold between four- and three-flavour theory in GeV. More...
 
double mut
 The threshold between six- and five-flavour theory in GeV. More...
 
double NA
 
double Nc
 The number of colours. More...
 
Particle quarks [6]
 The vector of all SM quarks. More...
 
bool requireYd
 Switch for generating the Yukawa couplings to the down-type quarks. More...
 
bool requireYu
 Switch for generating the Yukawa couplings to the up-type quarks. More...
 
double TF
 
- Protected Attributes inherited from Model
bool isSliced
 A boolean set to true if the current istance is a slice of an extended object. More...
 
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
 
bool UpdateError
 A boolean set to false if update is successful. More...
 

Private Member Functions

double AleWithInit (double mu, double alsi, double mu_i, orders order) const
 
double AlsWithInit (double mu, double alsi, double mu_i, orders order, bool qed_flag) const
 

Private Attributes

double ale_cache [10][CacheSize]
 Cache for \(\alpha_e\). More...
 
double als_cache [11][CacheSize]
 Cache for \(\alpha_s\). More...
 
double DeltaAlpha_cache
 A cache of the value of \(\Delta\alpha(M_Z^2)\). More...
 
double DeltaAlphaLepton_cache
 A cache of the value of \(\Delta\alpha_{\mathrm{lept}}(M_Z^2)\). More...
 
bool FlagCacheInStandardModel
 A flag for caching (true by default). More...
 
std::string FlagKappaZ
 A string for the model flag KappaZ. More...
 
std::string FlagMw
 A string for the model flag Mw. More...
 
bool FlagNoApproximateGammaZ
 A boolean for the model flag NoApproximateGammaZ. More...
 
std::string FlagRhoZ
 A string for the model flag RhoZ. More...
 
bool FlagSMAux
 A boolean for the model flag SMAux. More...
 
bool FlagWithoutNonUniversalVC
 A boolean for the model flag WithoutNonUniversalVC. More...
 
bool FlagWolfenstein
 A boolean for the model flag Wolfenstein. More...
 
double GammaW_cache
 A cache of the value of \(\Gamma_W\). More...
 
int iterationNo
 
gslpp::complex kappaZ_f_cache [12]
 A cache of the value of \(\kappa_Z^l\). More...
 
double Mw_cache
 A cache of the value of \(M_W\). More...
 
EWSMApproximateFormulaemyApproximateFormulae
 A pointer to an object of type EWSMApproximateFormulae. More...
 
EWSMcachemyEWSMcache
 A pointer to an object of type EWSMcache. More...
 
LeptonFlavourmyLeptonFlavour
 A pointer to an object of the type LeptonFlavour. More...
 
EWSMOneLoopEWmyOneLoopEW
 A pointer to an object of type EWSMOneLoopEW. More...
 
EWSMThreeLoopEWmyThreeLoopEW
 A pointer to an object of type EWSMThreeLoopEW. More...
 
EWSMThreeLoopEW2QCDmyThreeLoopEW2QCD
 A pointer to an object of type EWSMThreeLoopEW2QCD. More...
 
EWSMThreeLoopQCDmyThreeLoopQCD
 A pointer to an object of type EWSMThreeLoopQCD. More...
 
EWSMTwoLoopEWmyTwoLoopEW
 A pointer to an object of type EWSMTwoLoopEW. More...
 
EWSMTwoLoopQCDmyTwoLoopQCD
 A pointer to an object of type EWSMTwoLoopQCD. More...
 
orders realorder
 
gslpp::complex rhoZ_f_cache [12]
 A cache of the value of \(\rho_Z^l\). More...
 
double SMparamsForEWPO_cache [NumSMParamsForEWPO]
 
bool useDeltaAlpha_cache
 
bool useDeltaAlphaLepton_cache
 
bool useGammaW_cache
 
bool useKappaZ_f_cache [12]
 
bool useMw_cache
 
bool useRhoZ_f_cache [12]
 

Static Private Attributes

static const int CacheSize = 5
 Defines the depth of the cache. More...
 

Member Enumeration Documentation

◆ LEP2RCs

Enumerator
Weak 
WeakBox 
ISR 
QEDFSR 
QCDFSR 
NUMofLEP2RCs 

Definition at line 479 of file StandardModel.h.

479  {
480  Weak = 0,
481  WeakBox,
482  ISR,
483  QEDFSR,
484  QCDFSR,
486  };

◆ orders_EW

An enumerated type representing perturbative orders of radiative corrections to EW precision observables.

Enumerator
EW1 

One-loop of \(\mathcal{O}(\alpha)\).

EW1QCD1 

Two-loop of \(\mathcal{O}(\alpha\alpha_s)\).

EW1QCD2 

Three-loop of \(\mathcal{O}(\alpha\alpha_s^2)\).

EW2 

Two-loop of \(\mathcal{O}(\alpha^2)\).

EW2QCD1 

Three-loop of \(\mathcal{O}(\alpha^2\alpha_s)\).

EW3 

Three-loop of \(\mathcal{O}(\alpha^3)\).

orders_EW_size 

The size of this enum.

Definition at line 492 of file StandardModel.h.

492  {
493  EW1 = 0,
494  EW1QCD1,
495  EW1QCD2,
496  EW2,
497  EW2QCD1,
498  EW3,
500  };

Constructor & Destructor Documentation

◆ StandardModel()

StandardModel::StandardModel ( )

The default constructor.

Definition at line 35 of file StandardModel.cpp.

36 : QCD(), Yu(3, 3, 0.), Yd(3, 3, 0.), Yn(3, 3, 0.),
37 Ye(3, 3, 0.), SMM(*this), SMFlavour(*this)
38 {
41  FlagMw = "APPROXIMATEFORMULA";
42  FlagRhoZ = "NORESUM";
43  FlagKappaZ = "APPROXIMATEFORMULA";
44  FlagWolfenstein = true;
45 
46  FlagSMAux = true;
47 
48  /* Internal flags for EWPO (for debugging) */
49  flag_order[EW1] = true;
50  flag_order[EW1QCD1] = true;
51  flag_order[EW1QCD2] = true;
52  flag_order[EW2] = true;
53  flag_order[EW2QCD1] = true;
54  flag_order[EW3] = true;
55 
56  // Caches for EWPO
57  FlagCacheInStandardModel = true; // use caches in the current class
59  useDeltaAlpha_cache = false;
60  useMw_cache = false;
61  useGammaW_cache = false;
63  DeltaAlpha_cache = 0.0;
64  Mw_cache = 0.0;
65  GammaW_cache = 0.0;
66  for (int i = 0; i < 12; ++i) {
67  useRhoZ_f_cache[i] = false;
68  useKappaZ_f_cache[i] = false;
69  rhoZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
70  kappaZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
71  }
72 
73  myEWSMcache = NULL;
74  myOneLoopEW = NULL;
75  myTwoLoopQCD = NULL;
76  myThreeLoopQCD = NULL;
77  myTwoLoopEW = NULL;
78  myThreeLoopEW2QCD = NULL;
79  myThreeLoopEW = NULL;
80  myApproximateFormulae = NULL;
81 
82  // Particle(std::string name, double mass, double mass_scale = 0., double width = 0., double charge = 0.,double isospin = 0.);
83  leptons[NEUTRINO_1] = Particle("NEUTRINO_1", 0., 0., 0., 0., .5);
84  leptons[NEUTRINO_2] = Particle("NEUTRINO_2", 0., 0., 0., 0., .5);
85  leptons[NEUTRINO_3] = Particle("NEUTRINO_3", 0., 0., 0., 0., .5);
86  leptons[ELECTRON] = Particle("ELECTRON", 0., 0., 0., -1., -.5);
87  leptons[MU] = Particle("MU", 0., 0., 0., -1., -.5);
88  leptons[TAU] = Particle("TAU", 0., 0., 0., -1., -.5);
89 
90  ModelParamMap.insert(std::make_pair("Mz", std::cref(Mz)));
91  ModelParamMap.insert(std::make_pair("AlsMz", std::cref(AlsMz)));
92  ModelParamMap.insert(std::make_pair("GF", std::cref(GF)));
93  ModelParamMap.insert(std::make_pair("ale", std::cref(ale)));
94  ModelParamMap.insert(std::make_pair("dAle5Mz", std::cref(dAle5Mz)));
95  ModelParamMap.insert(std::make_pair("mHl", std::cref(mHl)));
96  ModelParamMap.insert(std::make_pair("delMw", std::cref(delMw)));
97  ModelParamMap.insert(std::make_pair("delSin2th_l", std::cref(delSin2th_l)));
98  ModelParamMap.insert(std::make_pair("delSin2th_q", std::cref(delSin2th_q)));
99  ModelParamMap.insert(std::make_pair("delSin2th_b", std::cref(delSin2th_b)));
100  ModelParamMap.insert(std::make_pair("delGammaZ", std::cref(delGammaZ)));
101  ModelParamMap.insert(std::make_pair("delsigma0H", std::cref(delsigma0H)));
102  ModelParamMap.insert(std::make_pair("delR0l", std::cref(delR0l)));
103  ModelParamMap.insert(std::make_pair("delR0c", std::cref(delR0c)));
104  ModelParamMap.insert(std::make_pair("delR0b", std::cref(delR0b)));
105  ModelParamMap.insert(std::make_pair("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
106  ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
107  ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
108  ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
109  ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
110  ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
111  ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
112  ModelParamMap.insert(std::make_pair("A", std::cref(A)));
113  ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
114  ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
115  ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
116 
117  iterationNo = 0;
118  realorder = LO;
119 }

◆ ~StandardModel()

StandardModel::~StandardModel ( )
virtual

The default destructor.

Definition at line 121 of file StandardModel.cpp.

122 {
123  if (IsModelInitialized()) {
124  if (myEWSMcache != NULL) delete(myEWSMcache);
125  if (myOneLoopEW != NULL) delete(myOneLoopEW);
126  if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
127  if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
128  if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
129  if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
130  if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
131  if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
132  if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
133  }
134 }

Member Function Documentation

◆ A_f()

double StandardModel::A_f ( const Particle  f) const
virtual

The left-right asymmetry in \(e^+e^-\to Z\to \ell \bar{\ell}\) at the \(Z\)-pole, \(\mathcal{A}_\ell\).

The asymmetry \(\mathcal{A}_\ell\) is given by

\[ \mathcal{A}_\ell = \frac{2\, {\rm Re}\left(g_{V}^\ell/g_{A}^\ell\right)} {1+\left[{\rm Re}\left(g_{V}^\ell/g_{A}^\ell\right)\right]^2}\,, \]

where the ratio of the effective couplings \(g_{V}^\ell/g_{A}^\ell\) is computed via the two-loop approximate formula of \(\sin^2\theta_{\rm eff}^{\,\ell}\), EWSMApproximateFormulae::sin2thetaEff_l(), when checkNPZff_linearized() returns true and the model flag KappaZ of StandardModel is set to APPROXIMATEFORMULA.

Parameters
[in]fa lepton or quark
Returns
\(\mathcal{A}_\ell\)

Reimplemented in NPEpsilons, NPbase, and NPZbbbar.

Definition at line 1183 of file StandardModel.cpp.

1184 {
1185  double Re_kappa = kappaZ_f(f).real();
1186  double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1187  return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1188 }

◆ AFB()

double StandardModel::AFB ( const Particle  f) const
virtual
Parameters
[in]fa lepton or quark
Returns

Reimplemented in NPEpsilons, NPbase, and NPZbbbar.

Definition at line 1190 of file StandardModel.cpp.

1191 {
1192  return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1193 }

◆ Ale()

double StandardModel::Ale ( double  mu,
orders  order,
bool  Nf_thr = true 
) const

The running electromagnetic coupling \(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme.

See [141]

Parameters
[in]murenormalization scale \(\mu\) in GeV
[in]orderorder in the \(\alpha_e\) expansion as defined in the order enum in OrderScheme
[in]Nf_thrflag to activate flavour thresholds. Default: true
Returns
\(\alpha_e(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 706 of file StandardModel.cpp.

707 {
708  int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
709  double ale, aletmp, mutmp, aleMz = alphaMz();
710  orders fullord;
711 
712  for (i = 0; i < CacheSize; ++i)
713  if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
714  (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
715  (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
716  (muc == ale_cache[6][i])
717  && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
718  return ale_cache[9][i];
719 
720  switch (order)
721  {
722  case FULLNLO:
723  return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
724  case FULLNNLO:
725  return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
726  case FULLNNNLO:
727  return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
728  case LO:
729  if (nfAle == nfmu)
730  return(AleWithInit(mu, aleMz, Mz, order));
731  case NLO:
732  case NNLO:
733  case NNNLO:
734  if (nfAle == nfmu)
735  return(0.);
736  fullord = FullOrder(order);
737  if (nfAle > nfmu) {
738  mutmp = BelowTh(Mz);
739  aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
740 // aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
741  for (i = nfAle - 1; i > nfmu; i--) {
742  mutmp = BelowTh(mutmp - MEPS);
743  aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
744 // aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
745  }
746  ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
747  }
748 
749  if (nfAle < nfmu) {
750  mutmp = AboveTh(Mz) - MEPS;
751  aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
752 // alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
753  for (i = nfAle + 1; i < nfmu; i++) {
754  mutmp = AboveTh(mutmp) - MEPS;
755  aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
756 // alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
757  }
758  ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
759  }
760 
761  CacheShift(ale_cache, 10);
762  ale_cache[0][0] = mu;
763  ale_cache[1][0] = (double) order;
764  ale_cache[2][0] = AlsMz;
765  ale_cache[3][0] = Mz;
766  ale_cache[4][0] = mut;
767  ale_cache[5][0] = mub;
768  ale_cache[6][0] = muc;
769  ale_cache[7][0] = (double) Nf_thr;
770  ale_cache[8][0] = aleMz;
771  ale_cache[9][0] = ale;
772 
773  return ale;
774  default:
775  throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
776  }
777 }

◆ ale_OS()

double StandardModel::ale_OS ( const double  mu,
orders  order = FULLNLO 
) const

The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme.

See [28].

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderLO/FULLNLO
Returns
\(\alpha(\mu)\) in the on-shell scheme
Attention
This function is applicable to the scale where the three charged leptons and the five quarks, not the top quark, run in the loops.

Definition at line 507 of file StandardModel.cpp.

508 {
509  if (mu < 50.0)
510  throw std::runtime_error("out of range in StandardModel::ale_OS()");
511 
512  double N = 20.0 / 3.0;
513  double beta1 = N / 3.0;
514  double beta2 = N / 4.0;
515  double alpha_ini = alphaMz();
516  double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
517 
518  switch (order) {
519  case LO:
520  return ( alpha_ini / v);
521  case FULLNLO:
522  return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
523  default:
524  throw std::runtime_error("Error in StandardModel::ale_OS()");
525  }
526 }

◆ AleWithInit()

double StandardModel::AleWithInit ( double  mu,
double  alsi,
double  mu_i,
orders  order 
) const
private

Definition at line 779 of file StandardModel.cpp.

780 {
781  if (fabs(mu - mu_i) < MEPS) return(alei);
782 
783  double nf = Nf(mu), alsi = Als(mu_i, FULLNNNLO, true);
784  double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
785  double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
786  double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
787 
788  switch (order)
789  {
790  case LO:
791  return (alei / ve);
792  case NLO:
793  return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
794  // Higher order terms ? Need to understand eq. (35)
795  case FULLNLO:
796  return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
797  default:
798  throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
799  }
800 }

◆ alphaMz()

double StandardModel::alphaMz ( ) const

The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\).

The radiative corrections are included with Dyson resummation:

\[ \alpha(M_Z^2) = \frac{\alpha}{1 - \Delta\alpha(M_Z^2)}. \]

Returns
\(\alpha(M_Z^2)\)

Definition at line 867 of file StandardModel.cpp.

868 {
869  return (ale / (1.0 - DeltaAlpha()));
870 // return(1./127.918); // FOR HEFFDF1 TEST
871 }

◆ Als()

double StandardModel::Als ( double  mu,
orders  order = FULLNLO,
bool  qed_flag = false,
bool  Nf_thr = true 
) const

The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections.

See [141]

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
[in]qed_flaginclude \(\alpha_e\) corrections to the requested order in \(\alpha_s\). The \(\alpha_s\alpha_e\) term is included if NNNLO is requested. Default: false
[in]Nf_thrtrue (default): \(n_f\) = Nf(mu), false: \(n_f\) = Nf(AlsM)
Returns
\(\alpha(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 576 of file StandardModel.cpp.

577 {
578  switch (order)
579  {
580  case LO:
581  realorder = order;
582  return AlsByOrder(mu, LO, qed_flag, Nf_thr);
583  case FULLNLO:
584  realorder = order;
585  return (AlsByOrder(mu, LO, qed_flag, Nf_thr) + AlsByOrder(mu, NLO, qed_flag, Nf_thr));
586  case FULLNNLO:
587  realorder = order;
588  return (AlsByOrder(mu, LO, qed_flag, Nf_thr) + AlsByOrder(mu, NLO, qed_flag, Nf_thr) + AlsByOrder(mu, NNLO, qed_flag, Nf_thr));
589  case FULLNNNLO:
590  realorder = order;
591  return (AlsByOrder(mu, LO, qed_flag, Nf_thr) + AlsByOrder(mu, NLO, qed_flag, Nf_thr) + AlsByOrder(mu, NNLO, qed_flag, Nf_thr) + AlsByOrder(mu, NNNLO, qed_flag, Nf_thr));
592  default:
593  throw std::runtime_error("StandardModel::Als(): " + orderToString(order) + " is not implemented.");
594  }
595 }

◆ AlsByOrder()

double StandardModel::AlsByOrder ( double  mu,
orders  order = FULLNLO,
bool  qed_flag = false,
bool  Nf_thr = true 
) const

Definition at line 597 of file StandardModel.cpp.

598 {
599  int i, nfAls = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAls;
600  double als, alstmp, mutmp;
601  orders fullord;
602 
603  for (i = 0; i < CacheSize; ++i)
604  if ((mu == als_cache[0][i]) && ((double) order == als_cache[1][i]) &&
605  (AlsMz == als_cache[2][i]) && (Mz == als_cache[3][i]) &&
606  (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
607  (muc == als_cache[6][i]) && (double) qed_flag == als_cache[7][i]
608  && (double) Nf_thr == als_cache[8][i] && alphaMz() == als_cache[9][i])
609  return als_cache[10][i];
610 
611  switch (order)
612  {
613  case LO:
614  case NLO:
615  case NNLO:
616  case NNNLO:
617  if (nfAls == nfmu)
618  return(AlsWithInit(mu, AlsMz, Mz, order, qed_flag));
619  fullord = FullOrder(order);
620  if (nfAls > nfmu) {
621  mutmp = BelowTh(Mz);
622  alstmp = AlsWithInit(mutmp, AlsMz, Mz, realorder, qed_flag);
623  alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
624  for (i = nfAls - 1; i > nfmu; i--) {
625  mutmp = BelowTh(mutmp - MEPS);
626  alstmp = AlsWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, realorder, qed_flag);
627  alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
628  }
629  als = AlsWithInit(mu, alstmp, AboveTh(mu) - MEPS, order, qed_flag);
630  }
631 
632  if (nfAls < nfmu) {
633  mutmp = AboveTh(Mz) - MEPS;
634  alstmp = AlsWithInit(mutmp, AlsMz, Mz, realorder, qed_flag);
635  alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
636  for (i = nfAls + 1; i < nfmu; i++) {
637  mutmp = AboveTh(mutmp) - MEPS;
638  alstmp = AlsWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, realorder, qed_flag);
639  alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
640  }
641  als = AlsWithInit(mu, alstmp, BelowTh(mu) + MEPS, order, qed_flag);
642  }
643 
644  CacheShift(als_cache, 11);
645  als_cache[0][0] = mu;
646  als_cache[1][0] = (double) order;
647  als_cache[2][0] = AlsMz;
648  als_cache[3][0] = Mz;
649  als_cache[4][0] = mut;
650  als_cache[5][0] = mub;
651  als_cache[6][0] = muc;
652  als_cache[7][0] = (double) qed_flag;
653  als_cache[8][0] = (double) Nf_thr;
654  als_cache[9][0] = alphaMz();
655  als_cache[10][0] = als;
656 
657  return als;
658  default:
659  throw std::runtime_error("StandardModel::Als(): " + orderToString(order) + " is not implemented.");
660  }
661 }

◆ Alstilde5()

double StandardModel::Alstilde5 ( const double  mu) const

The value of \(\frac{\alpha_s^{\mathrm{FULLNLO}}}{4\pi}\) at any scale \(\mu\) with the number of flavours \(n_f = 4\) and full EW corrections.

Parameters
[in]muthe scale at which \(\alpha_s\) has to be computed
Returns
\(\alpha_s^{\mathrm{FULLNLO}}(\mu)\) with \(n_f = 4\5\)

Definition at line 873 of file StandardModel.cpp.

874 {
875  double mu_0 = Mz;
876  double alphatilde_e = alphaMz()/4./M_PI;
877  double alphatilde_s = AlsMz/4./M_PI;
878  unsigned int nf = 5;
879 
880  double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
881  B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
882 
883  double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
884 
885  double B10soB00s = B10S / B00S;
886  double B01soB00e = B01S/B00E;
887 
888  double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
889  double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
890  double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
891 
892  double logve = log(ve);
893  double logvs = log(vs);
894  double logeos = log(ve/vs);
895  double logsoe = log(vs/ve);
896  double asovs = alphatilde_s/vs;
897  double aeove = alphatilde_e/ve;
898 
899  double result = 0;
900 
901  result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
902  + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
903  + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
904  + ps * ve * logve) * B01S * B10S/(B00E * B00S))
905  + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
906  - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
907  + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
908  + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
909  + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
910  + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
911  return (result);
912 }

◆ AlsWithInit()

double StandardModel::AlsWithInit ( double  mu,
double  alsi,
double  mu_i,
orders  order,
bool  qed_flag 
) const
private

Definition at line 663 of file StandardModel.cpp.

664 {
665  double nf = Nf(mu), alei = Ale(mu_i, FULLNLO); // CHANGE ME!
666  double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
667  double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
668  double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
669  double logv = log(v), logve = log(ve);
670  double rho = 1. / (1. + b00e * alei / b00s / alsi);
671  double als = QCD::AlsWithInit(mu, alsi, mu_i, order);
672  double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
673 
674  if (qed_flag)
675  switch (order)
676  {
677  case LO:
678  break;
679  case NLO:
680  als += alsi * alsi / 4. / M_PI / v / v * b01s00e * logve;
681  break;
682  case NNLO:
683  als += alsi * alsi * alsi / 4. / 4. / M_PI / M_PI / v / v / v * (
684  b01s00e * b01s00e * logve * logve + b01s00e * Beta_s(10, nf) / b00s *
685  (-2. * logv * logve + rho * ve * logve));
686  break;
687  case NNNLO:
688  als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
689  (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
690  b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
691  b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
692  break;
693  case FULLNLO:
694  return (AlsWithInit(mu, alsi, mu_i, LO, true) + AlsWithInit(mu, alsi, mu_i, NLO, true));
695  case FULLNNLO:
696  return (AlsWithInit(mu, alsi, mu_i, LO, true) + AlsWithInit(mu, alsi, mu_i, NLO, true)+ AlsWithInit(mu, alsi, mu_i, NNLO, true));
697  case FULLNNNLO:
698  return (AlsWithInit(mu, alsi, mu_i, LO, true) + AlsWithInit(mu, alsi, mu_i, NLO, true)+ AlsWithInit(mu, alsi, mu_i, NNLO, true) + AlsWithInit(mu, alsi, mu_i, NNNLO, true));
699  default:
700  throw std::runtime_error("StandardModel::AlsWithInit(): " + orderToString(order) + " is not implemented.");
701  }
702 
703  return (als);
704 }

◆ Beta_e()

double StandardModel::Beta_e ( int  nm,
unsigned int  nf 
) const

QED beta function coefficients - eq. (36) hep-ph/0512066.

Parameters
nmpowers of alpha_s and alpha_e as an integer
nfnumber of active flavor
Returns
coefficient of the QED beta function

Definition at line 556 of file StandardModel.cpp.

557 {
558  unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
559  unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
560  double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
561  Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
562 
563  switch(nm)
564  {
565  case 00:
566  return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
567  case 10:
568  return(4. * (Qbar4 * Nc + 3.));
569  case 01:
570  return(4. * CF * Nc * Qbar2);
571  default:
572  throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
573  }
574 }

◆ Beta_s()

double StandardModel::Beta_s ( int  nm,
unsigned int  nf 
) const

QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.

Parameters
nmpowers of alpha_s and alpha_e as an integer
nfnumber of active flavor
Returns
coefficient of the QCD beta function

Definition at line 528 of file StandardModel.cpp.

529 {
530  unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
531  unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
532  double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
533  Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
534 
535  switch(nm)
536  {
537  case 00:
538  return(Beta0((double) nf));
539  case 10:
540  return(Beta1((double) nf));
541  case 20:
542  return(Beta2((double) nf));
543  case 30:
544  return(Beta3((double) nf));
545  case 01:
546  return(-4. * TF * Qbar2 );
547  case 11:
548  return((4. * CF - 8. * CA) * TF * Qbar2 );
549  case 02:
550  return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
551  default:
552  throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
553  }
554 }

◆ c02()

double StandardModel::c02 ( ) const

The square of the cosine of the weak mixing angle \(c_0^2\) defined without weak radiative corrections.

The quantity \(c_0^2\) is given by

\[ c_0^2 = 1 - s_0^2\,, \]

where \(s_0^2\) is defined in s02().

See [15] and [16].

Returns
\(s_0^2\)

Definition at line 939 of file StandardModel.cpp.

940 {
941  return ( 1.0 - s02());
942 }

◆ checkEWPOscheme()

bool StandardModel::checkEWPOscheme ( const std::string  scheme) const
inlineprotected

A method to check if a given scheme name in string form is valid.

Parameters
[in]schemescheme name for \(M_W\), \(\rho_Z^f\) or \(\kappa_Z^f\)
Returns
a boolean that is true if the scheme name is valid

Definition at line 2578 of file StandardModel.h.

2579  {
2580  if (scheme.compare("NORESUM") == 0
2581  || scheme.compare("OMSI") == 0
2582  || scheme.compare("INTERMEDIATE") == 0
2583  || scheme.compare("OMSII") == 0
2584  || scheme.compare("APPROXIMATEFORMULA") == 0)
2585  return true;
2586  else
2587  return false;
2588  }

◆ CheckFlags()

bool StandardModel::CheckFlags ( ) const
virtual

A method to check the sanity of the set of model flags.

Returns
a boolean that is true if the set of model flags is sane

Reimplemented from QCD.

Definition at line 449 of file StandardModel.cpp.

450 {
451  return (QCD::CheckFlags());
452 }

◆ CheckParameters()

bool StandardModel::CheckParameters ( const std::map< std::string, double > &  DPars)
virtual

A method to check if all the mandatory parameters for StandardModel have been provided in model initialization.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in NPSMEFTd6, HiggsKigen, GeneralTHDM, HiggsChiral, THDMW, HiggsKvgenKfgen, HiggsKvKfgen, THDM, GeorgiMachacek, NPZbbbarLinearized, NPZbbbar, RealWeakEFTLFV, FlavourWilsonCoefficient, NPEpsilons, FlavourWilsonCoefficient_DF2, HiggsKvKf, NPSTUZbbbarLR, NPEpsilons_pureNP, RealWeakEFTCC, NPSTU, CMFV, NPDF2, myModel, and myModel.

Examples
myModel.cpp.

Definition at line 313 of file StandardModel.cpp.

314 {
315  for (int i = 0; i < NSMvars; i++) {
316  if (DPars.find(SMvars[i]) == DPars.end()) {
317  std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
320  }
321  }
322  return (QCD::CheckParameters(DPars));
323 }

◆ checkSMparamsForEWPO()

bool StandardModel::checkSMparamsForEWPO ( )

A method to check whether the parameters relevant to the EWPO are updated.

This function is used for the cashing methods implemented in the current class: DeltaAlphaLepton(), DeltaAlpha(), Mw_SM(), rhoZ_l_SM(), rhoZ_q_SM(), kappaZ_l_SM(), kappaZ_q_SM() and GammaW_SM(). When the values of the StandardModel parameters are updated in the Monte Carlo run and differ from those stored in the cache SMparamsForEWPO_cache, this function updates the cache, and returns false.

Returns
a boolean that is true if the parameters are not updated.
See also
NumSMParamsForEWPO

Definition at line 458 of file StandardModel.cpp.

459 {
460  // 11 parameters in QCD:
461  // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
462  // mut, mub, muc
463  // 19 parameters in StandardModel
464  // GF, ale, dAle5Mz, mHl,
465  // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
466  // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b,
467  // 3 flags in StandardModel
468  // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
469 
470  // Note: When modifying the array below, the constant NumSMParams has to
471  // be modified accordingly.
472  double SMparams[NumSMParamsForEWPO] = {
473  AlsMz, Mz, GF, ale, dAle5Mz,
474  mHl, mtpole,
479  leptons[MU].getMass(),
480  leptons[TAU].getMass(),
481  quarks[UP].getMass(),
482  quarks[DOWN].getMass(),
483  quarks[CHARM].getMass(),
485  quarks[BOTTOM].getMass(),
486  mut, mub, muc,
491  };
492 
493  // check updated parameters
494  bool bNotUpdated = true;
495  for (int i = 0; i < NumSMParamsForEWPO; ++i) {
496  if (SMparamsForEWPO_cache[i] != SMparams[i]) {
497  SMparamsForEWPO_cache[i] = SMparams[i];
498  bNotUpdated &= false;
499  }
500  }
501 
502  return bNotUpdated;
503 }

◆ computeBrHtobb()

double StandardModel::computeBrHtobb ( ) const
inline

The Br \((H\to bb)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to bb)\) in the Standard Model

Definition at line 2299 of file StandardModel.h.

2300  {
2301  return 5.807e-1; // Mh=125.1 GeV
2302  //return 5.67e-1; // Mh=125.6 GeV
2303  }

◆ computeBrHtocc()

double StandardModel::computeBrHtocc ( ) const
inline

The Br \((H\to cc)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to cc)\) in the Standard Model

Definition at line 2276 of file StandardModel.h.

2277  {
2278  return 2.883e-2; // Mh=125.1 GeV
2279  //return 2.86e-2; // Mh=125.6 GeV
2280  }

◆ computeBrHtogaga()

double StandardModel::computeBrHtogaga ( ) const
inline

The Br \((H\to\gamma\gamma)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to\gamma\gamma)\) in the Standard Model

Definition at line 2242 of file StandardModel.h.

2243  {
2244  return 2.27e-3; // Mh=125.1 GeV
2245  }

◆ computeBrHtogg()

double StandardModel::computeBrHtogg ( ) const
inline

The Br \((H\to gg)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to gg)\)

Definition at line 2185 of file StandardModel.h.

2186  {
2187  return 8.179e-2; // Mh=125.1 GeV
2188  }

◆ computeBrHtomumu()

double StandardModel::computeBrHtomumu ( ) const
inline

The Br \((H\to \mu\mu)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to \mu\mu)\) in the Standard Model

Definition at line 2253 of file StandardModel.h.

2254  {
2255  return 2.17e-4; // Mh=125.1 GeV
2256  }

◆ computeBrHtoss()

double StandardModel::computeBrHtoss ( ) const
inline

The Br \((H\to ss)\) in the Standard Model.

From Table 7 in http://cdsweb.cern.ch/record/2629412/files/ATLAS-CONF-2018-031.pdf

Returns
Br \((H\to ss)\) in the Standard Model

Definition at line 2288 of file StandardModel.h.

2289  {
2290  return 4.0e-4;
2291  }

◆ computeBrHtotautau()

double StandardModel::computeBrHtotautau ( ) const
inline

The Br \((H\to \tau\tau)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to \tau\tau)\) in the Standard Model

Definition at line 2264 of file StandardModel.h.

2265  {
2266  return 6.256e-2; // Mh=125.1 GeV
2267  //return 6.22e-2; // Mh=125.6 GeV
2268  }

◆ computeBrHtoWW()

double StandardModel::computeBrHtoWW ( ) const
inline

The Br \((H\to WW)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to WW)\) in the Standard Model

Definition at line 2196 of file StandardModel.h.

2197  {
2198  //return 2.23e-1; // Mh=125.5 GeV
2199  return 2.154e-1; // Mh=125.1 GeV
2200  }

◆ computeBrHtoZga()

double StandardModel::computeBrHtoZga ( ) const
inline

The Br \((H\to Z\gamma)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to Z\gamma)\) in the Standard Model

Definition at line 2230 of file StandardModel.h.

2231  {
2232  return 1.541e-3; // Mh=125.1 GeV
2233  //return 1.59e-3; // Mh=125.6 GeV
2234  }

◆ computeBrHtoZZ()

double StandardModel::computeBrHtoZZ ( ) const
inline

The Br \((H\to ZZ)\) in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
Br \((H\to ZZ)\) in the Standard Model

Definition at line 2208 of file StandardModel.h.

2209  {
2210  return 2.643e-2; // Mh=125.1 GeV
2211  //return 2.79e-2; // Mh=125.6 GeV
2212  }

◆ computeBrHtoZZinv()

double StandardModel::computeBrHtoZZinv ( ) const
inline

The Br \((H\to ZZ \to inv)\) in the Standard Model.

Returns
Br \((H\to ZZ\to inv)\) in the Standard Model

Definition at line 2219 of file StandardModel.h.

2220  {
2221  return 1.06e-3;
2222  }

◆ computeCKM()

void StandardModel::computeCKM ( )
protectedvirtual

The method to compute the CKM matrix.

Definition at line 325 of file StandardModel.cpp.

326 {
327  if (requireCKM) {
328  if (FlagWolfenstein) {
330  Vus = myCKM.getV_us().abs();
331  Vcb = myCKM.getV_cb().abs();
332  Vub = myCKM.getV_ub().abs();
334  } else {
336  lambda = myCKM.getLambda();
337  A = myCKM.getA();
338  rhob = myCKM.getRhoBar();
339  etab = myCKM.getEtaBar();
340  }
341  }
342  myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
343 }

◆ ComputeDeltaR_rem()

void StandardModel::ComputeDeltaR_rem ( const double  Mw_i,
double  DeltaR_rem[orders_EW_size] 
) const

A method to collect \(\Delta r_{\mathrm{rem}}\) computed via subclasses.

This function collects \(\Delta r_{\mathrm{rem}}\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes.

Parameters
[in]Mw_ithe \(W\)-boson mass
[out]DeltaR_remArray of \(\Delta r_{\mathrm{rem}}\)

Definition at line 1053 of file StandardModel.cpp.

1055 {
1056  if (flag_order[EW1])
1057  DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1058  else
1059  DeltaR_rem[EW1] = 0.0;
1060  if (flag_order[EW1QCD1])
1061  DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1062  else
1063  DeltaR_rem[EW1QCD1] = 0.0;
1064  if (flag_order[EW1QCD2])
1065  DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1066  else
1067  DeltaR_rem[EW1QCD2] = 0.0;
1068  if (flag_order[EW2])
1069  DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1070  else
1071  DeltaR_rem[EW2] = 0.0;
1072  if (flag_order[EW2QCD1])
1073  DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1074  else
1075  DeltaR_rem[EW2QCD1] = 0.0;
1076  if (flag_order[EW3])
1077  DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1078  else
1079  DeltaR_rem[EW3] = 0.0;
1080 }

◆ ComputeDeltaRho()

void StandardModel::ComputeDeltaRho ( const double  Mw_i,
double  DeltaRho[orders_EW_size] 
) const

A method to collect \(\Delta\rho\) computed via subclasses.

This function collects \(\Delta\rho\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes.

Parameters
[in]Mw_ithe \(W\)-boson mass
[out]DeltaRhoArray of \(\Delta\rho\)

Definition at line 1024 of file StandardModel.cpp.

1026 {
1027  if (flag_order[EW1])
1028  DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1029  else
1030  DeltaRho[EW1] = 0.0;
1031  if (flag_order[EW1QCD1])
1032  DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1033  else
1034  DeltaRho[EW1QCD1] = 0.0;
1035  if (flag_order[EW1QCD2])
1036  DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1037  else
1038  DeltaRho[EW1QCD2] = 0.0;
1039  if (flag_order[EW2])
1040  DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1041  else
1042  DeltaRho[EW2] = 0.0;
1043  if (flag_order[EW2QCD1])
1044  DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1045  else
1046  DeltaRho[EW2QCD1] = 0.0;
1047  if (flag_order[EW3])
1048  DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1049  else
1050  DeltaRho[EW3] = 0.0;
1051 }

◆ computeGammaHgaga_tt()

double StandardModel::computeGammaHgaga_tt ( ) const
inline

The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [137]

Returns
Width of \(H\to\gamma\gamma\) (top loop contribution squared) in eV

Definition at line 2388 of file StandardModel.h.

2389  {
2390  return 662.84; // in eV for Mh=125 GeV
2391  //return 680.39; // in eV for Mh=126 GeV
2392  }

◆ computeGammaHgaga_tW()

double StandardModel::computeGammaHgaga_tW ( ) const
inline

The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [137]

Returns
Width of \(H\to\gamma\gamma\) (top W loop interference) in eV

Definition at line 2410 of file StandardModel.h.

2411  {
2412  return -6249.93; // in eV for Mh=125 GeV
2413  //return -6436.35; // in eV for Mh=126 GeV
2414  }

◆ computeGammaHgaga_WW()

double StandardModel::computeGammaHgaga_WW ( ) const
inline

The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model.

Currently it returns the value of tab 40 in ref. [137]

Returns
Width of \(H\to\gamma\gamma\) (W loop contribution squared) in eV

Definition at line 2399 of file StandardModel.h.

2400  {
2401  return 14731.86; // in eV for Mh=125 GeV
2402  //return 15221.98; // in eV for Mh=126 GeV
2403  }

◆ computeGammaHgg_bb()

double StandardModel::computeGammaHgg_bb ( ) const
inline

The bottom loop contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [137]

Returns
Width of \(H\to gg\) (bottom loop contribution squared) in keV

Definition at line 2333 of file StandardModel.h.

2334  {
2335  return 3.96; // in keV for Mh=125 GeV
2336  //return 3.95; // in keV for Mh=126 GeV
2337  }

◆ computeGammaHgg_tb()

double StandardModel::computeGammaHgg_tb ( ) const
inline

The top-bottom interference contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [137]

Returns
Width of \(H\to gg\) (top-bottom interference contribution) in keV

Definition at line 2344 of file StandardModel.h.

2345  {
2346  return -42.1; // in keV for Mh=125 GeV
2347  //return -42.7; // in keV for Mh=126 GeV
2348  }

◆ computeGammaHgg_tt()

double StandardModel::computeGammaHgg_tt ( ) const
inline

The top loop contribution to \(H\to gg\) in the Standard Model.

Currently it returns the value of tab 39 in ref. [137]

Returns
Width of \(H\to gg\) (top loop contribution squared) in keV

Definition at line 2322 of file StandardModel.h.

2323  {
2324  return 380.8; // in keV for Mh=125 GeV
2325  //return 389.6; // in keV for Mh=126 GeV
2326  }

◆ computeGammaHTotal()

double StandardModel::computeGammaHTotal ( ) const
inline

The Higgs total width in the Standard Model.

Currently it returns the value for Mh=125.1 GeV provided by the LHCXSSWG update in the CERN Report 4 from 2016 https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageBR

Returns
\(\Gamma_h\) in GeV in the Standard Model

Definition at line 2311 of file StandardModel.h.

2312  {
2313  return 4.101e-3; // Mh=125.1 GeV
2314  //return 4.15e-3; // Mh=125.6 GeV
2315  }

◆ computeGammaHZga_tt()

double StandardModel::computeGammaHZga_tt ( ) const
inline

The top loop contribution to \(H\to Z\gamma\) in the Standard Model.

Currently it returns the value of tab 41 in ref. [137]

Returns
Width of \(H\to Z\gamma\) (top loop contribution squared) in eV

Definition at line 2355 of file StandardModel.h.

2356  {
2357  return 21.74; // in eV for Mh=125 GeV
2358  //return 23.51; // in eV for Mh=126 GeV
2359  }

◆ computeGammaHZga_tW()

double StandardModel::computeGammaHZga_tW ( ) const
inline

The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model.

Currently it returns the value of tab 41 in ref. [137]

Returns
Width of \(H\to Z\gamma\) (top W loop interference) in eV

Definition at line 2377 of file StandardModel.h.

2378  {
2379  return -780.4; // in eV for Mh=125 GeV
2380  //return -848.1; // in eV for Mh=126 GeV
2381  }

◆ computeGammaHZga_WW()

double StandardModel::computeGammaHZga_WW ( ) const
inline

The \(W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. Currently it returns the value of tab 41 in ref. [137].

Returns
Width of \(H\to Z\gamma\) (W loop contribution squared) in eV

Definition at line 2366 of file StandardModel.h.

2367  {
2368  return 7005.6; // in eV for Mh=125 GeV
2369  //return 7648.4; // in eV for Mh=126 GeV
2370  }

◆ computeSigmaggH()

double StandardModel::computeSigmaggH ( const double  sqrt_s) const
inline

The ggH cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [137] and the updates in https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA for 7 and 8 TeV For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ggH cross section in pb

Definition at line 1883 of file StandardModel.h.

1884  {
1885  if (sqrt_s == 7.0) {
1886  return 16.83; // in pb for Mh=125.1 GeV
1887  } else if (sqrt_s == 8.0) {
1888  return 21.40; // in pb for Mh=125.1 GeV
1889  } else if (sqrt_s == 13.0) {
1890  return 48.61; // in pb for Mh=125.09 GeV
1891  } else if (sqrt_s == 14.0) {
1892  return 54.72; // in pb for Mh=125.09 GeV
1893  } else if (sqrt_s == 27.0) {
1894  return 146.65; // in pb for Mh=125.09 GeV
1895  } else if (sqrt_s == 100.0) {
1896  return 740.3; // in pb for Mh=125. GeV
1897  } else if (sqrt_s == 1.96) {
1898  return 0.9493; // in pb for Mh=125 GeV
1899  } else
1900  throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH()");
1901  }

◆ computeSigmaggH_bb()

double StandardModel::computeSigmaggH_bb ( const double  sqrt_s) const
inline

The square of the bottom-quark contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{bb}\) in pb

Definition at line 1935 of file StandardModel.h.

1936  {
1937  if (sqrt_s == 7.0) {
1938  return 0.04; // in pb for Mh=125.09 GeV
1939  } else if (sqrt_s == 8.0) {
1940  return 0.05; // in pb for Mh=125.09 GeV
1941  } else if (sqrt_s == 13.0) {
1942  return 0.10; // in pb for Mh=125.09 GeV
1943  } else if (sqrt_s == 14.0) {
1944  return 0.11; // in pb for Mh=125.09 GeV
1945  } else if (sqrt_s == 27.0) {
1946  return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
1947  } else if (sqrt_s == 100.0) {
1948  return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
1949  } else
1950  throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_bb()");
1951  }

◆ computeSigmaggH_tb()

double StandardModel::computeSigmaggH_tb ( const double  sqrt_s) const
inline

The top-bottom interference contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{tb}\) in pb

Definition at line 1960 of file StandardModel.h.

1961  {
1962  if (sqrt_s == 7.0) {
1963  return -0.66; // in pb for Mh=125.09 GeV
1964  } else if (sqrt_s == 8.0) {
1965  return -0.82; // in pb for Mh=125.09 GeV
1966  } else if (sqrt_s == 13.0) {
1967  return -1.73; // in pb for Mh=125.09 GeV
1968  } else if (sqrt_s == 14.0) {
1969  return -1.92; // in pb for Mh=125.09 GeV
1970  } else if (sqrt_s == 27.0) {
1971  return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
1972  } else if (sqrt_s == 100.0) {
1973  return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
1974  } else
1975  throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tb()");
1976  }

◆ computeSigmaggH_tt()

double StandardModel::computeSigmaggH_tt ( const double  sqrt_s) const
inline

The square of the top-quark contribution to the ggH cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
\(\sigma_{ggH}^{tt}\) in pb

Definition at line 1910 of file StandardModel.h.

1911  {
1912  if (sqrt_s == 7.0) {
1913  return 16.69; // in pb for Mh=125.09 GeV
1914  } else if (sqrt_s == 8.0) {
1915  return 21.20; // in pb for Mh=125.09 GeV
1916  } else if (sqrt_s == 13.0) {
1917  return 47.94; // in pb for Mh=125.09 GeV
1918  } else if (sqrt_s == 14.0) {
1919  return 53.93; // in pb for Mh=125.09 GeV
1920  } else if (sqrt_s == 27.0) {
1921  return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
1922  } else if (sqrt_s == 100.0) {
1923  return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
1924  } else
1925  throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tt()");
1926  }

◆ computeSigmattH()

double StandardModel::computeSigmattH ( const double  sqrt_s) const
inline

The ttH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [137] . For the 13 TeV values we use the official numbers a la CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt13TeV https://twiki.cern.ch/twiki/bin/view/LHCPhysics/CERNYellowReportPageAt14TeV For the 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ttH production cross section in pb

Definition at line 2157 of file StandardModel.h.

2158  {
2159  if (sqrt_s == 7.0) {
2160  return 0.0861; // in pb for Mh=125.1 GeV
2161  //return 0.0851; // in pb for Mh=125.6 GeV
2162  } else if (sqrt_s == 8.0) {
2163  return 0.129; // in pb for Mh=125.1 GeV
2164  //return 0.1274; // in pb for Mh=125.6 GeV
2165  } else if (sqrt_s == 13.0) {
2166  return 0.5060; // in pb for Mh=125.1 GeV
2167  } else if (sqrt_s == 14.0) {
2168  return 0.6128; // in pb for Mh=125.09 GeV
2169  } else if (sqrt_s == 27.0) {
2170  return 2.86; // in pb for Mh=125.09 GeV
2171  } else if (sqrt_s == 100.0) {
2172  return 37.9; // in pb for Mh=125. GeV
2173  } else if (sqrt_s == 1.96) {
2174  return 0.0043; // in pb for Mh=125 GeV
2175  } else
2176  throw std::runtime_error("Bad argument in StandardModel::computeSigmattH()");
2177  }

◆ computeSigmaVBF()

double StandardModel::computeSigmaVBF ( const double  sqrt_s) const
inline

The VBF cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [137] . For the 7, 8, 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
VBF cross section in pb

Definition at line 1989 of file StandardModel.h.

1990  {
1991  if (sqrt_s == 7.0) {
1992  return 1.241; // in pb for Mh=125.09 GeV
1993  } else if (sqrt_s == 8.0) {
1994  return 1.601; // in pb for Mh=125.09 GeV
1995  } else if (sqrt_s == 13.0) {
1996  return 3.766; // in pb for Mh=125.09 GeV
1997  } else if (sqrt_s == 14.0) {
1998  return 4.260; // in pb for Mh=125.09 GeV
1999  } else if (sqrt_s == 27.0) {
2000  return 11.838; // in pb for Mh=125.09 GeV
2001  } else if (sqrt_s == 100.0) {
2002  return 82.0; // in pb for Mh=125. GeV
2003  } else if (sqrt_s == 1.96) {
2004  return 0.0653; // in pb for Mh=125 GeV
2005  } else
2006  throw std::runtime_error("Bad argument in StandardModel::computeSigmaVBF()");
2007  }

◆ computeSigmaWF()

double StandardModel::computeSigmaWF ( const double  sqrt_s) const
inline

The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
W fusion contribution \(\sigma_{WF}\) to cross section in pb

Definition at line 2017 of file StandardModel.h.

2018  {
2019  if (sqrt_s == 7.0) {
2020  return 0.946; // in pb for Mh=125 GeV
2021  } else if (sqrt_s == 8.0) {
2022  return 1.220; // in pb for Mh=125 GeV
2023  } else if (sqrt_s == 13.0) {
2024  return 2.882; // in pb for Mh=125 GeV
2025  } else if (sqrt_s == 14.0) {
2026  return 3.260; // in pb for Mh=125 GeV
2027  } else if (sqrt_s == 27.0) {
2028  return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2029  } else if (sqrt_s == 100.0) {
2030  return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2031  } else if (sqrt_s == 1.96) {
2032  return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaWF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2033  } else
2034  throw std::runtime_error("Bad argument in StandardModel::computeSigmaWF()");
2035  }

◆ computeSigmaWH()

double StandardModel::computeSigmaWH ( const double  sqrt_s) const
inline

The WH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [137] . For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
WH production cross section in pb

Definition at line 2088 of file StandardModel.h.

2089  {
2090  if (sqrt_s == 7.0) {
2091  return 0.577; // in pb for Mh=125.1 GeV
2092  //return 0.5688; // in pb for Mh=125.6 GeV
2093  } else if (sqrt_s == 8.0) {
2094  return 0.7027; // in pb for Mh=125.1 GeV
2095  //return 0.6931; // in pb for Mh=125.6 GeV
2096  } else if (sqrt_s == 13.0) {
2097  return 1.358; // in pb for Mh=125.09 GeV
2098  } else if (sqrt_s == 14.0) {
2099  return 1.498; // in pb for Mh=125.09 GeV
2100  } else if (sqrt_s == 27.0) {
2101  return 3.397; // in pb for Mh=125.09 GeV
2102  } else if (sqrt_s == 100.0) {
2103  return 15.9; // in pb for Mh=125. GeV
2104  } else if (sqrt_s == 1.96) {
2105  return 0.1295; // in pb for Mh=125 GeV
2106  } else
2107  throw std::runtime_error("Bad argument in StandardModel::computeSigmaWH()");
2108  }

◆ computeSigmaZF()

double StandardModel::computeSigmaZF ( const double  sqrt_s) const
inline

The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model.

The values have been obtained from: https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG2KAPPA

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
W fusion contribution \(\sigma_{ZF}\) to cross section in pb

Definition at line 2045 of file StandardModel.h.

2046  {
2047  if (sqrt_s == 7.0) {
2048  return 0.333; // in pb for Mh=125 GeV
2049  } else if (sqrt_s == 8.0) {
2050  return 0.432; // in pb for Mh=125 GeV
2051  } else if (sqrt_s == 13.0) {
2052  return 1.049; // in pb for Mh=125 GeV
2053  } else if (sqrt_s == 14.0) {
2054  return 1.191; // in pb for Mh=125 GeV
2055  } else if (sqrt_s == 27.0) {
2056  return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2057  } else if (sqrt_s == 100.0) {
2058  return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2059  } else if (sqrt_s == 1.96) {
2060  return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaZF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2061  } else
2062  throw std::runtime_error("Bad argument in StandardModel::computeSigmaZF()");
2063  }

◆ computeSigmaZH()

double StandardModel::computeSigmaZH ( const double  sqrt_s) const
inline

The ZH production cross section in the Standard Model.

See Tables B.67 and B.74 in ref. [137] . For the 13, 14 and 27 TeV values we use the updated numbers wrt the CERN Report 4 2016 from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/LHCHXSWG1HELHCXsecs https://twiki.cern.ch/twiki/pub/LHCPhysics/LHCHXSWG1HELHCXsecs/hlhehiggs.pdf For the 100 TeV values we use the values from https://twiki.cern.ch/twiki/bin/view/LHCPhysics/HiggsEuropeanStrategy

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
ZH production cross section in pb

Definition at line 2121 of file StandardModel.h.

2122  {
2123  if (sqrt_s == 7.0) {
2124  return 0.3341; // in pb for Mh=125.1 GeV
2125  //return 0.3299; // in pb for Mh=125.6 GeV
2126  } else if (sqrt_s == 8.0) {
2127  return 0.4142; // in pb for Mh=125.1 GeV
2128  //return 0.4091; // in pb for Mh=125.6 GeV
2129  } else if (sqrt_s == 13.0) {
2130  return 0.880; // in pb for Mh=125.09 GeV
2131  } else if (sqrt_s == 14.0) {
2132  return 0.981; // in pb for Mh=125.09 GeV
2133  } else if (sqrt_s == 27.0) {
2134  return 2.463; // in pb for Mh=125.09 GeV
2135  } else if (sqrt_s == 100.0) {
2136  return 11.26; // in pb for Mh=125. GeV
2137  } else if (sqrt_s == 1.96) {
2138  return 0.0785; // in pb for Mh=125 GeV
2139  } else
2140  throw std::runtime_error("Bad argument in StandardModel::computeSigmaZH()");
2141  }

◆ computeSigmaZWF()

double StandardModel::computeSigmaZWF ( const double  sqrt_s) const
inline

The Z W interference fusion contribution \(\sigma_{ZWF}\) to higgs-production cross section in the Standard Model.

Negligible (0.1%) in the Standard model.

Parameters
[in]sqrt_sthe center-of-mass energy in TeV
Returns
Z W interference fusion contribution \(\sigma_{ZWF}\) to cross section in pb

Definition at line 2072 of file StandardModel.h.

2073  {
2074  return 0.;
2075  }

◆ computeYukawas()

void StandardModel::computeYukawas ( )
protectedvirtual

The method to compute the Yukawa matrices.

Attention
This function has not been correctly implemented yet.

Definition at line 345 of file StandardModel.cpp.

346 {
347  /* THE FOLLOWING CODES HAVE TO BE MODIFIED!!
348  * The Yukawa matrices have to be computed at a common scale
349  * for all the fermions!!! */
350  if (requireYu || requireCKM) {
352  for (int i = 0; i < 3; i++)
353  Yu.assign(i, i, this->quarks[UP + 2 * i].getMass() / v() * sqrt(2.));
354  Yu = myCKM.getCKM().transpose() * Yu;
355  }
356  if (requireYd) {
358  for (int i = 0; i < 3; i++)
359  Yd.assign(i, i, this->quarks[DOWN + 2 * i].getMass() / v() * sqrt(2.));
360  }
361  if (requireYe) {
363  for (int i = 0; i < 3; i++)
364  Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
365  }
366  if (requireYn) {
368  for (int i = 0; i < 3; i++)
369  Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
370  Yn = Yn * myPMNS.getPMNS().hconjugate();
371  }
372 }

◆ cW2() [1/2]

double StandardModel::cW2 ( ) const
virtual

Definition at line 994 of file StandardModel.cpp.

995 {
996  return ( cW2(Mw()));
997 // return (1.0 - 0.2312); // FOR HEFFDF1 TEST
998 }

◆ cW2() [2/2]

double StandardModel::cW2 ( const double  Mw_i) const
virtual

The square of the cosine of the weak mixing angle in the on-shell scheme, denoted as \(c_W^2\).

\[ c_W^2=\cos^2{\theta_W}=\frac{M_W^2}{M_Z^2}. \]

Returns
\(c_W^2\)

Definition at line 989 of file StandardModel.cpp.

990 {
991  return ( Mw_i * Mw_i / Mz / Mz);
992 }

◆ Delta_EWQCD()

double StandardModel::Delta_EWQCD ( const QCD::quark  q) const
protected

The non-factorizable EW-QCD corrections to the partial widths for \(Z\to q\bar{q}\), denoted as \(\Delta_{\mathrm{EW/QCD}}\).

See [106] and [136].

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(\Delta_{\mathrm{EW/QCD}}\) in GeV

Definition at line 2098 of file StandardModel.cpp.

2099 {
2100  switch (q) {
2101  case QCD::UP:
2102  case QCD::CHARM:
2103  return ( -0.000113);
2104  case QCD::TOP:
2105  return ( 0.0);
2106  case QCD::DOWN:
2107  case QCD::STRANGE:
2108  return ( -0.000160);
2109  case QCD::BOTTOM:
2110  return ( -0.000040);
2111  default:
2112  throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2113  }
2114 }

◆ DeltaAlpha()

double StandardModel::DeltaAlpha ( ) const

The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\).

\[ \Delta\alpha(M_Z^2) = \Delta\alpha_{\rm lept}(M_Z^2) + \Delta\alpha_{\rm had}^{(5)}(M_Z^2) + \Delta\alpha_{\rm top}(M_Z^2)\,. \]

Returns
\(\Delta\alpha(M_Z^2)\)

Definition at line 855 of file StandardModel.cpp.

856 {
859  return DeltaAlpha_cache;
860 
861  double Mz2 = Mz*Mz;
863  useDeltaAlpha_cache = true;
864  return DeltaAlpha_cache;
865 }

◆ DeltaAlphaL5q()

double StandardModel::DeltaAlphaL5q ( ) const

The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha^{\ell+5q}(M_Z^2)\).

\[ \Delta\alpha^{\ell+5q}(M_Z^2) = \Delta\alpha_{\rm lept}(M_Z^2) + \Delta\alpha_{\rm had}^{(5)}(M_Z^2)\,. \]

Returns
\(\Delta\alpha^{\ell+5q}(M_Z^2)\)

Definition at line 830 of file StandardModel.cpp.

831 {
832  double Mz2 = Mz*Mz;
833  return (DeltaAlphaLepton(Mz2) + dAle5Mz);
834 }

◆ DeltaAlphaLepton()

double StandardModel::DeltaAlphaLepton ( const double  s) const

Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\).

Parameters
[in]sinvariant mass squared
Returns
\(\Delta\alpha_{\mathrm{lept}}(s)\)

Definition at line 802 of file StandardModel.cpp.

803 {
804  if (s == Mz * Mz)
807  return DeltaAlphaLepton_cache;
808 
809  double DeltaAlphaL = 0.0;
810  if (flag_order[EW1])
811  DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
812  if (flag_order[EW1QCD1])
813  DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
814  if (flag_order[EW1QCD2])
815  DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
816  if (flag_order[EW2])
817  DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
818  if (flag_order[EW2QCD1])
819  DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
820  if (flag_order[EW3])
821  DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
822 
823  if (s == Mz * Mz) {
824  DeltaAlphaLepton_cache = DeltaAlphaL;
826  }
827  return DeltaAlphaL;
828 }

◆ DeltaAlphaTop()

double StandardModel::DeltaAlphaTop ( const double  s) const

Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\).

Parameters
[in]sinvariant mass squared
Returns
\(\Delta\alpha_{\mathrm{top}}(s)\)

Definition at line 836 of file StandardModel.cpp.

837 {
838  double DeltaAlpha = 0.0;
839  if (flag_order[EW1])
841  if (flag_order[EW1QCD1])
843  if (flag_order[EW1QCD2])
845  if (flag_order[EW2])
847  if (flag_order[EW2QCD1])
849  if (flag_order[EW3])
851 
852  return DeltaAlpha;
853 }

◆ deltaKappaZ_f()

gslpp::complex StandardModel::deltaKappaZ_f ( const Particle  f) const
virtual

Flavour non-universal vertex corrections to \(\kappa_Z^l\), denoted by \(\Delta\kappa_Z^l\).

The non-universal contribution \(\Delta\kappa_Z^l\) is given by

\[ \Delta \kappa_Z^l = \kappa_Z^l - \kappa_Z^e = \frac{\alpha}{4\pi s_W^2} \left( \frac{\delta_l^2-\delta_e^2}{4c_W^2}\,\mathcal{F}_Z(M_Z^2) -u_l+u_e\right), \]

where \(u_l\) and \(\delta_l\) are defined as

\[ u_l = \frac{3v_l^2+a_l^2}{4c_W^2}\mathcal{F}_Z(M_Z^2) + \mathcal{F}_W^l(M_Z^2)\,, \qquad \delta_l = v_l - a_l \]

with the tree-level vector and axial-vector couplings \(v_l = I_3^l - 2Q_l s_W^2\) and \(a_l = I_3^l\), and the form factors \(\mathcal{F}_Z\) and \(\mathcal{F}_W^l\).

See [66] and references therein.

Parameters
[in]fa lepton or quark
Returns
\(\Delta\kappa_Z^l\)

Definition at line 1729 of file StandardModel.cpp.

1730 {
1731  Particle p1 = f, pe = leptons[ELECTRON];
1732 
1733  if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1734 
1735  /* In the case of BOTTOM, the top contribution has to be subtracted.
1736  * The remaining contribution is the same as that for DOWN and STRANGE. */
1737  if (f.is("BOTTOM")) p1 = quarks[DOWN];
1738 
1739  double myMw = Mw();
1740  double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1741  gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1742  + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1743  + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1744  double deltal = myEWSMcache->delta_f(pe, myMw);
1745  gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1746  + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1747  + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1748  double deltaf = myEWSMcache->delta_f(p1, myMw);
1749 
1750  gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1751  - uf + ul;
1752  dKappa *= ale / 4.0 / M_PI / sW2;
1753  return dKappa;
1754 }

◆ DeltaR()

double StandardModel::DeltaR ( ) const
virtual

The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass.

If the model flag Mw of StandardModel is set to NORESUM or APPROXIMATEFORMULA, the quantity \(\Delta r\) is computed by using the following relation:

\[ s_W^2 M_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu}(1+\Delta r)\,. \]

Otherwise, the following relation is employed instead:

\[ s_W^2 M_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu(1-\Delta r)}\,, \]

where the resummation for \(\Delta r\) is considered.

Returns
\(\Delta r_{\mathrm{SM}}\)
See also
The corresponding quantity in the complex-pole/fixed-width scheme (instead of the experimental/running-widthr scheme) is defined in DeltaRbar_SM().

Definition at line 1010 of file StandardModel.cpp.

1011 {
1012  /* in the experimental/running-width scheme */
1013  double myMw = Mw();
1014  double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1015  double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1016  if (FlagMw.compare("NORESUM") == 0
1017  || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1018  return (tmp - 1.0);
1019  } else {
1020  return (1.0 - 1.0 / tmp);
1021  }
1022 }

◆ DeltaRbar()

double StandardModel::DeltaRbar ( ) const
virtual

The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass.

The quantity \(\Delta \overline{r}\) is computed by using the following relation:

\[ \overline{s}_W^2 \overline{M}_W^2 = \frac{\pi\,\alpha}{\sqrt{2}G_\mu}(1+\Delta \overline{r})\,, \]

where \(\overline{M}_W\) and \(\overline{s}_W\) are the \(W\)-boson mass and the sine of the weak mixing angle in the complex-pole/fixed-width scheme [37].

Returns
\(\Delta \overline{r}_{\mathrm{SM}}\)
See also
DeltaR_SM(), defining the corresponding quantity in the experimental/running-width scheme.

Definition at line 1120 of file StandardModel.cpp.

1121 {
1122  double Mwbar_SM = MwbarFromMw(Mw());
1123  double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1124  double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1125 
1126  return (tmp - 1.0);
1127 }

◆ deltaRhoZ_f()

gslpp::complex StandardModel::deltaRhoZ_f ( const Particle  f) const
virtual

Flavour non-universal vertex corrections to \(\rho_Z^l\), denoted by \(\Delta\rho_Z^l\).

The non-universal contribution \(\Delta\rho_Z^l\) is given by

\[ \Delta \rho_Z^l = \rho_Z^l - \rho_Z^e = \frac{\alpha}{2\pi s_W^2}\left(u_l - u_e\right), \]

where \(u_l\) is defined as

\[ u_l = \frac{3v_l^2+a_l^2}{4c_W^2}\mathcal{F}_Z(M_Z^2) + \mathcal{F}_W^l(M_Z^2) \]

with the tree-level vector and axial-vector couplings \(v_l = I_3^l - 2Q_l s_W^2\) and \(a_l = I_3^l\) and the form factors, \(\mathcal{F}_Z\) and \(\mathcal{F}_W^l\).

See [66] and references therein.

Parameters
[in]fa lepton or quark
Returns
\(\Delta\rho_Z^l\)

Definition at line 1704 of file StandardModel.cpp.

1705 {
1706  Particle p1 = f, pe = leptons[ELECTRON];
1707 
1708  if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1709 
1710  /* In the case of BOTTOM, the top contribution has to be subtracted.
1711  * The remaining contribution is the same as that for DOWN and STRANGE. */
1712  if (f.is("BOTTOM")) p1 = quarks[DOWN];
1713 
1714  double myMw = Mw();
1715  double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1716 
1717  gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1718  + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1719  + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1720  gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1721  + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1722  + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1723 
1724  gslpp::complex dRho = 2.0 * (uf - ul);
1725  dRho *= ale / 4.0 / M_PI / sW2;
1726  return dRho;
1727 }

◆ epsilon1()

double StandardModel::epsilon1 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_1\).

The parameters \(\varepsilon_1\) is defined as

\[ \varepsilon_1 = \Delta\rho'\,, \]

where \(\Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right)\).

See [15] and [16].

Returns
\(\varepsilon_{1,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPSTU, and NPEpsilons_pureNP.

Definition at line 1759 of file StandardModel.cpp.

1760 {
1761  double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1762  double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1763 
1764  return DeltaRhoPrime;
1765 }

◆ epsilon2()

double StandardModel::epsilon2 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_2\).

The parameters \(\varepsilon_2\) is computed via the formula:

\[ \varepsilon_2 = c_0^2 \Delta\rho' + \frac{s_0^2}{c_0^2 - s_0^2} \Delta r_W - 2 s_0^2 \Delta\kappa'\,, \]

where \(\Delta\rho'\), \(\Delta r_W\) and \(\Delta\kappa'\) are defined as

\begin{align} \Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right),\qquad \Delta r_W = 1 - \frac{\pi\,\alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2 s_W^2 c_W^2},\qquad \Delta\kappa' = \frac{\sin^2\theta_{\mathrm{eff}}^e}{s_0^2} - 1\,, \end{align}

and \(s_0^2\) and \(c_0^2\) are given in s02() and c02(), respectively.

See [15] and [16].

Returns
\(\varepsilon_{2,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPSTU, and NPEpsilons_pureNP.

Definition at line 1767 of file StandardModel.cpp.

1768 {
1769  double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1770  double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1771  double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1772  double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1773  double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1774 
1775  return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1776  - 2.0 * s02() * DeltaKappaPrime);
1777 }

◆ epsilon3()

double StandardModel::epsilon3 ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_3\).

The parameters \(\varepsilon_3\) is computed via the formula:

\[ \varepsilon_3 = c_0^2\Delta\rho' + (c_0^2-s_0^2)\Delta\kappa'\,, \]

where \(\Delta\rho'\) and \(\Delta\kappa'\) are defined as

\begin{align} \Delta\rho'=2\left(\sqrt{{\rm Re}(\rho_Z^e)}-1\right),\qquad \Delta\kappa' = \frac{\sin^2\theta_{\mathrm{eff}}^e}{s_0^2} - 1\,, \end{align}

and \(s_0^2\) and \(c_0^2\) are given in s02() and c02(), respectively.

See [15] and [16].

Returns
\(\varepsilon_{3,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPSTU, and NPEpsilons_pureNP.

Definition at line 1779 of file StandardModel.cpp.

1780 {
1781  double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1782  double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1783  double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1784  double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1785 
1786  return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1787 }

◆ epsilonb()

double StandardModel::epsilonb ( ) const
virtual

The SM contribution to the epsilon parameter \(\varepsilon_b\).

The parameters \(\varepsilon_b\) is computed via the formula:

\[ \epsilon_b = \frac{ {\rm Re}\left[ \kappa_Z^e + \Delta\kappa_Z^b \right]} {{\rm Re}(\kappa_Z^b)} - 1\,, \]

where \(\Delta\kappa_Z^b\), representing flavour non-universal vertex corrections to the \(Zb\bar{b}\) vertex, is neglected when the model flag WithoutNonUniversalVC of StandardModel is set to true.

See [15], [16] and [17] for the \(\varepsilon\) parameterization and [66] for the flavour non-universal vertex corrections.

Returns
\(\varepsilon_{b,\mathrm{SM}}\)

Reimplemented in NPEpsilons, NPSTU, and NPEpsilons_pureNP.

Definition at line 1789 of file StandardModel.cpp.

1790 {
1791  /* epsilon_b from g_A^b
1792  * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1793  //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1794  //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1795  //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1796  //double eps1 = DeltaRhoPrime;
1797  //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1798 
1799  /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1800  * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1802  gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1804  return ( kappaZe.real() / kappaZb.real() - 1.0);
1805  else
1806  return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1807  / kappaZb.real() - 1.0);
1808 
1809  /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1810  * 1031 (1998) by Altarelli et al.
1811  * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1812  */
1813  //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1814  //double delta_als = (als_Mz - 0.119)/M_PI;
1815  //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1816  //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1817  //double a = als_Mz/M_PI;
1818  //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1819  //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1820  //double mb = 4.7;
1821  //std::cout << "mb = " << mb << std::endl;
1822  //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1823  //double Nc = 3.0;
1824  //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1825  //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1826  // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1827  // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1828  //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1829  // + 0.54*epsilon3_SM() )/2.29 );
1830 }

◆ gA_f()

gslpp::complex StandardModel::gA_f ( const Particle  f) const
virtual

The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM.

\[ g_A^l = \sqrt{\rho_Z^l}\, I_3^l\,. \]

Parameters
[in]fa lepton or quark
Returns
\(g_{A,\,\mathrm{SM}}^l\)

Reimplemented in NPEpsilons, and NPbase.

Definition at line 1548 of file StandardModel.cpp.

1549 {
1550  return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1551 }

◆ Gamma_had()

double StandardModel::Gamma_had ( ) const
virtual

The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\).

The hadronic width is given by the sum,

\[ \Gamma_h = \Gamma_u + \Gamma_d + \Gamma_c + \Gamma_s + \Gamma_b\,. \]

Furthermore, the singlet vector corrections are added, following the prescription in [40] :

\[ \Gamma_h = \sum_q \Gamma_q + 4N_c\Gamma_0 R_V^h\,. \]

Returns
\(\Gamma_{h}\) in GeV

Reimplemented in NPbase.

Definition at line 1283 of file StandardModel.cpp.

1284 {
1285  double Gamma_had_tmp = 0.0;
1286 
1287  if (!IsFlagNoApproximateGammaZ()){
1288 
1289  if (FlagSMAux) {
1290 
1291 // New (Testing)
1292 
1293  /* SM contribution with the approximate formula */
1294  return myApproximateFormulae->X_full("Gamma_had");
1295 
1296  } else {
1297 
1298 // Original
1299 
1300  /* SM contribution with the approximate formula */
1301  return myApproximateFormulae->X_full_2_loop("Gamma_had");
1302 
1303  }
1304 
1305  } else {
1306 
1307  Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1309 
1310  /* Singlet vector contribution (not included in the approximate formula) */
1311  double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1312  Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1313 
1314  return Gamma_had_tmp;
1315  }
1316 }

◆ Gamma_inv()

double StandardModel::Gamma_inv ( ) const
virtual

The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\).

\[ \Gamma_{\mathrm{inv}} = 3\,\Gamma_\nu\,, \]

where \(\Gamma_{\nu}\) is the partial width for \(Z\to\nu\bar{\nu}\).

Returns
\(\Gamma_{\mathrm{inv}}\) in GeV

Definition at line 1277 of file StandardModel.cpp.

1278 {
1280  + GammaZ(leptons[NEUTRINO_3]));
1281 }

◆ Gamma_Z()

double StandardModel::Gamma_Z ( ) const
virtual

The total decay width of the \(Z\) boson, \(\Gamma_Z\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\Gamma_Z\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the total decay width is calculated with

\[ \Gamma_Z = \Gamma_{e} + \Gamma_{\mu} + \Gamma_{\tau} + \Gamma_{\mathrm{inv}} + \Gamma_h\,. \]

Returns
\(\Gamma_Z\) in GeV

Reimplemented in NPbase, NPEpsilons, and NPZbbbar.

Definition at line 1318 of file StandardModel.cpp.

1319 {
1320  if (!IsFlagNoApproximateGammaZ()){
1321 
1322  if (FlagSMAux) {
1323 
1324 // New (Testing)
1325 
1326  /* SM contribution with the approximate formula */
1327  return myApproximateFormulae->X_full("GammaZ");
1328 
1329  } else {
1330 
1331 // Original
1332 
1333  /* SM contribution with the approximate formula */
1334  return myApproximateFormulae->X_full_2_loop("GammaZ");
1335 
1336  }
1337 
1338  } else {
1339  return ( GammaZ(leptons[ELECTRON]) + GammaZ(leptons[MU]) + GammaZ(leptons[TAU])
1340  + Gamma_inv() + Gamma_had());
1341  }
1342 }

◆ GammaW() [1/2]

double StandardModel::GammaW ( ) const
virtual

The total width of the \(W\) boson, \(\Gamma_W\).

Returns
\(\Gamma_W\) in GeV

Reimplemented in NPSMEFTd6, NPbase, NPEpsilons, NPZbbbar, and NPEpsilons_pureNP.

Definition at line 1164 of file StandardModel.cpp.

1165 {
1167  if (useGammaW_cache)
1168  return GammaW_cache;
1169 
1170  double GammaWtmp = 0.;
1171 
1172  for (int i = 0; i < 6; i += 2)
1173  GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1174 
1175  GammaW_cache = GammaWtmp;
1176  useGammaW_cache = true;
1177  return GammaWtmp;
1178 }

◆ GammaW() [2/2]

double StandardModel::GammaW ( const Particle  fi,
const Particle  fj 
) const
virtual

A partial decay width of the \(W\) boson decay into a SM fermion pair.

\[ \Gamma^W_{ij} = |U_{ij}|^2\,\frac{G_\mu M_W^3}{6\sqrt{2}\,\pi}\,\rho^W_{ij} \]

where \(U\) denotes the MNS matrix, and \(\rho^W_{ij}\) represents EW radiative corrections.

\[ \Gamma^W_{ij} = 3 |V_{ij}|^2\,\frac{G_\mu M_W^3}{6\sqrt{2}\,\pi}\,\rho^W_{ij} \left( 1 + \frac{\alpha_s(M_W^2)}{\pi} \right). \]

where \(V\) denotes the CKM matrix, and \(\rho^W_{ij}\) represents EW radiative corrections.

Parameters
[in]fia lepton or quark
[in]fja lepton or quark
Returns
\(\Gamma^W_{ij}\)
See also
rho_GammaW_l_SM()
Attention
Fermion masses are neglected.

Reimplemented in NPSMEFTd6, and NPbase.

Definition at line 1140 of file StandardModel.cpp.

1141 {
1142  if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1143  throw std::runtime_error("Error in StandardModel::GammaW()");
1144 
1145  double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1146  gslpp::complex V(0.0, 0.0, false);
1147 
1148  if (fi.is("TOP"))
1149  return (0.0);
1150 
1151  if (fj.getIndex() - fi.getIndex() == 1)
1152  V = gslpp::complex(1.0, 0.0, false);
1153  else
1154  V = gslpp::complex(0.0, 0.0, false);
1155 
1156  if (fi.is("LEPTON"))
1157  return ( V.abs2() * G0 * rho_GammaW(fi, fj));
1158  else {
1159  double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, FULLNLO, false);
1160  return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj)*(1.0 + AlsMw / M_PI));
1161  }
1162 }

◆ GammaZ()

double StandardModel::GammaZ ( const Particle  f) const
virtual

The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\Gamma_\ell\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the partial width is calculated with \(\rho_Z^\ell\) and \(g_{V}^\ell/g_{A}^\ell\) [33] :

\[ \Gamma_\ell = \Gamma_0 \big|\rho_Z^f\big| \sqrt{1-\frac{4m_\ell^2}{M_Z^2}} \left[ \left(1+\frac{2m_\ell^2}{M_Z^2}\right) \left(\left|\frac{g_{V}^\ell}{g_{A}^\ell}\right|^2 + 1 \right) - \frac{6m_\ell^2}{M_Z^2} \right] \left( 1 + \frac{3}{4}\frac{\alpha(M_Z^2)}{\pi}\, Q_\ell^2 \right) \]

with \(\Gamma_0=G_\mu M_Z^3/(24\sqrt{2}\pi)\).

Parameters
[in]fa lepton or quark
Returns
\(\Gamma_\ell\) in GeV
Attention
\(\ell\) stands for both a neutrino and a charged lepton.

Definition at line 1201 of file StandardModel.cpp.

1202 {
1203  if (f.is("TOP"))
1204  return 0.0;
1205  double Gamma;
1206  if (!IsFlagNoApproximateGammaZ()) {
1207 
1208  if (FlagSMAux) {
1209 
1210 // New (Testing)
1211 
1212  /* SM contribution with the approximate formula */
1213  if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1214  Gamma = myApproximateFormulae->X_full("Gamma_nu");
1215  else if (f.is("ELECTRON") || f.is("MU"))
1216  Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1217  else if (f.is("TAU"))
1218  Gamma = myApproximateFormulae->X_full("Gamma_tau");
1219  else if (f.is("UP"))
1220  Gamma = myApproximateFormulae->X_full("Gamma_u");
1221  else if (f.is("CHARM"))
1222  Gamma = myApproximateFormulae->X_full("Gamma_c");
1223  else if (f.is("DOWN") || f.is("STRANGE"))
1224  Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1225  else if (f.is("BOTTOM"))
1226  Gamma = myApproximateFormulae->X_full("Gamma_b");
1227  else
1228  throw std::runtime_error("Error in StandardModel::GammaZ()");
1229 
1230  } else {
1231 
1232 // Original
1233 
1234  /* SM contribution with the approximate formula */
1235  if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1236  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_nu");
1237  else if (f.is("ELECTRON") || f.is("MU"))
1238  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_e_mu");
1239  else if (f.is("TAU"))
1240  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_tau");
1241  else if (f.is("UP"))
1242  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_u");
1243  else if (f.is("CHARM"))
1244  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_c");
1245  else if (f.is("DOWN") || f.is("STRANGE"))
1246  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_d_s");
1247  else if (f.is("BOTTOM"))
1248  Gamma = myApproximateFormulae->X_full_2_loop("Gamma_b");
1249  else
1250  throw std::runtime_error("Error in StandardModel::GammaZ()");
1251 
1252  }
1253 
1254  } else {
1255  gslpp::complex myrhoZ_f = rhoZ_f(f);
1256  gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1257  double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1258  if (f.is("LEPTON")) {
1259  double myalphaMz = alphaMz();
1260  double Q = f.getCharge();
1261  double xl = pow(f.getMass() / Mz, 2.0);
1262  Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1263  * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1264  * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1265  } else if (f.is("QUARK")) {
1266  Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1267 
1268  /* Nonfactorizable EW-QCD corrections */
1269  Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1270  } else
1271  throw std::runtime_error("Error in StandardModel::GammaZ()");
1272  }
1273 
1274  return Gamma;
1275 }

◆ getAle()

double StandardModel::getAle ( ) const
inline

A get method to retrieve the fine-structure constant \(\alpha\).

Returns
\(\alpha\)

Definition at line 745 of file StandardModel.h.

746  {
747  return ale;
748  }

◆ getAlsMz()

double StandardModel::getAlsMz ( ) const
inline

A get method to access the value of \(\alpha_s(M_Z)\).

Returns
the strong coupling constant at \(M_Z\), \(\alpha_s(M_Z)\)

Definition at line 727 of file StandardModel.h.

728  {
729  return AlsMz;
730  }

◆ getCBd()

virtual double StandardModel::getCBd ( ) const
inlinevirtual

The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value.

Returns
\(\vert (M_{12}^{bd})_\mathrm{full}/(M_{12}^{bd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 2420 of file StandardModel.h.

2421  {
2422  return 1.;
2423  }

◆ getCBs()

virtual double StandardModel::getCBs ( ) const
inlinevirtual

The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value.

Returns
\(\vert (M_{12}^{bs})_\mathrm{full}/(M_{12}^{bs})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 2429 of file StandardModel.h.

2430  {
2431  return 1.;
2432  }

◆ getCCC1()

virtual double StandardModel::getCCC1 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1144 of file StandardModel.h.

1144 { return 0.; };

◆ getCCC2()

virtual double StandardModel::getCCC2 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1149 of file StandardModel.h.

1149 { return 0.; };

◆ getCCC3()

virtual double StandardModel::getCCC3 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1154 of file StandardModel.h.

1154 { return 0.; };

◆ getCCC4()

virtual double StandardModel::getCCC4 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1159 of file StandardModel.h.

1159 { return 0.; };

◆ getCCC5()

virtual double StandardModel::getCCC5 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1164 of file StandardModel.h.

1164 { return 0.; };

◆ getCDMK()

virtual double StandardModel::getCDMK ( ) const
inlinevirtual

The ratio of the real part of the $K$ mixing amplitude over the Standard Model value.

Returns
\((\mathrm{Re} M_{12}^{sd})_\mathrm{full}/(\mathrm{Re} M_{12}^{sd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 2438 of file StandardModel.h.

2439  {
2440  return 1.;
2441  }

◆ getCepsK()

virtual double StandardModel::getCepsK ( ) const
inlinevirtual

The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value.

Returns
\((\mathrm{Im} M_{12}^{sd})_\mathrm{full}/(\mathrm{Im} M_{12}^{sd})_\mathrm{SM}\vert\)

Reimplemented in NPDF2.

Definition at line 2447 of file StandardModel.h.

2448  {
2449  return 1.;
2450  }

◆ getCKM()

CKM StandardModel::getCKM ( ) const
inline

A get method to retrieve the member object of type CKM.

Returns
the object of type CKM

Definition at line 876 of file StandardModel.h.

877  {
878  return myCKM;
879  }

◆ getDAle5Mz()

double StandardModel::getDAle5Mz ( ) const
inline

A get method to retrieve the five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\).

Returns
\(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\)

Definition at line 756 of file StandardModel.h.

757  {
758  return dAle5Mz;
759  }

◆ getDelGammaZ()

double StandardModel::getDelGammaZ ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\).

Returns
\(\delta\,\Gamma_Z\) in GeV

Definition at line 818 of file StandardModel.h.

819  {
820  return delGammaZ;
821  }

◆ getDelMw()

double StandardModel::getDelMw ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\).

Returns
\(\delta\,M_W\) in GeV

Definition at line 775 of file StandardModel.h.

776  {
777  return delMw;
778  }

◆ getDelR0b()

double StandardModel::getDelR0b ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\).

Returns
\(\delta\,R_b^0\)

Definition at line 858 of file StandardModel.h.

859  {
860  return delR0b;
861  }

◆ getDelR0c()

double StandardModel::getDelR0c ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\).

Returns
\(\delta\,R_c^0\)

Definition at line 848 of file StandardModel.h.

849  {
850  return delR0c;
851  }

◆ getDelR0l()

double StandardModel::getDelR0l ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\).

Returns
\(\delta\,R_l^0\)

Definition at line 838 of file StandardModel.h.

839  {
840  return delR0l;
841  }

◆ getDelSigma0H()

double StandardModel::getDelSigma0H ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\).

Returns
\(\delta\,\sigma_{Hadron}^0\) in nb

Definition at line 828 of file StandardModel.h.

829  {
830  return delsigma0H;
831  }

◆ getDelSin2th_b()

double StandardModel::getDelSin2th_b ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{b}\)

Definition at line 808 of file StandardModel.h.

809  {
810  return delSin2th_b;
811  }

◆ getDelSin2th_l()

double StandardModel::getDelSin2th_l ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{\rm lept}\)

Definition at line 786 of file StandardModel.h.

787  {
788  return delSin2th_l;
789  }

◆ getDelSin2th_q()

double StandardModel::getDelSin2th_q ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\).

Returns
\(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\)

Definition at line 797 of file StandardModel.h.

798  {
799  return delSin2th_q;
800  }

◆ getFlagKappaZ()

std::string StandardModel::getFlagKappaZ ( ) const
inline

A method to retrieve the model flag KappaZ.

See StandardModelFlags for detail.

Returns

Definition at line 679 of file StandardModel.h.

680  {
681  return FlagKappaZ;
682  }

◆ getFlagMw()

std::string StandardModel::getFlagMw ( ) const
inline

A method to retrieve the model flag Mw.

See StandardModelFlags for detail.

Returns

Definition at line 659 of file StandardModel.h.

660  {
661  return FlagMw;
662  }

◆ getFlagRhoZ()

std::string StandardModel::getFlagRhoZ ( ) const
inline

A method to retrieve the model flag RhoZ.

See StandardModelFlags for detail.

Returns

Definition at line 669 of file StandardModel.h.

670  {
671  return FlagRhoZ;
672  }

◆ getFlavour()

const Flavour& StandardModel::getFlavour ( ) const
inline

Definition at line 1006 of file StandardModel.h.

1007  {
1008  return SMFlavour;
1009  }

◆ getGF()

double StandardModel::getGF ( ) const
inline

A get method to retrieve the Fermi constant \(G_\mu\).

Returns
\(G_\mu\) in \({\rm GeV}^{-2}\)

Definition at line 736 of file StandardModel.h.

737  {
738  return GF;
739  }

◆ getIterationNo()

int StandardModel::getIterationNo ( ) const
inline

Definition at line 582 of file StandardModel.h.

583  {
584  return iterationNo;
585  }

◆ getLeptons()

Particle StandardModel::getLeptons ( const QCD::lepton  p) const
inline

A get method to retrieve the member object of a lepton.

Parameters
[in]pname of a lepton
Returns
an object of the lepton specified by name

Definition at line 709 of file StandardModel.h.

710  {
711  return leptons[p];
712  }

◆ getMatching()

virtual StandardModelMatching& StandardModel::getMatching ( ) const
inlinevirtual

A get method to access the member reference of type StandardModelMatching.

Returns
a reference to a StandardModelMatching object

Reimplemented in NPSMEFTd6, GeneralTHDM, THDMW, THDM, GeorgiMachacek, RealWeakEFTLFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, and CMFV.

Definition at line 949 of file StandardModel.h.

950  {
951  return SMM.getObj();
952  }

◆ getMHl()

virtual double StandardModel::getMHl ( ) const
inlinevirtual

A get method to retrieve the Higgs mass \(m_h\).

Returns
\(m_h\) in GeV

Definition at line 765 of file StandardModel.h.

766  {
767  return mHl;
768  }

◆ getmq()

virtual double StandardModel::getmq ( const QCD::quark  q,
const double  mu 
) const
inlinevirtual

Definition at line 2470 of file StandardModel.h.

2471  {
2472  return m_q(q, mu, FULLNLO);
2473  }

◆ getMuw()

double StandardModel::getMuw ( ) const
inline

A get method to retrieve the matching scale \(\mu_W\) around the weak scale.

Returns
\(\mu_W\) in GeV

Definition at line 935 of file StandardModel.h.

936  {
937  return muw;
938  }

◆ getMyApproximateFormulae()

EWSMApproximateFormulae* StandardModel::getMyApproximateFormulae ( ) const
inline

A get method to retrieve the member pointer of type EWSMApproximateFormulae.

Returns
the pointer myApproximateFormulae

Definition at line 976 of file StandardModel.h.

977  {
978  return myApproximateFormulae;
979  }

◆ getMyEWSMcache()

EWSMcache* StandardModel::getMyEWSMcache ( ) const
inline

A get method to retrieve the member pointer of type EWSMcache.

Returns
the pointer myEWSMcache

Definition at line 958 of file StandardModel.h.

959  {
960  return myEWSMcache;
961  }

◆ getMyLeptonFlavour()

LeptonFlavour* StandardModel::getMyLeptonFlavour ( ) const
inline

Definition at line 1011 of file StandardModel.h.

1012  {
1013  return myLeptonFlavour;
1014  }

◆ getMyOneLoopEW()

EWSMOneLoopEW* StandardModel::getMyOneLoopEW ( ) const
inline

A get method to retrieve the member pointer of type EWSMOneLoopEW,.

Returns
the pointer myOneLoopEW

Definition at line 967 of file StandardModel.h.

968  {
969  return myOneLoopEW;
970  }

◆ getMyThreeLoopEW()

EWSMThreeLoopEW* StandardModel::getMyThreeLoopEW ( ) const
inline

Definition at line 981 of file StandardModel.h.

982  {
983  return myThreeLoopEW;
984  }

◆ getMyThreeLoopEW2QCD()

EWSMThreeLoopEW2QCD* StandardModel::getMyThreeLoopEW2QCD ( ) const
inline

Definition at line 986 of file StandardModel.h.

987  {
988  return myThreeLoopEW2QCD;
989  }

◆ getMyThreeLoopQCD()

EWSMThreeLoopQCD* StandardModel::getMyThreeLoopQCD ( ) const
inline

Definition at line 991 of file StandardModel.h.

992  {
993  return myThreeLoopQCD;
994  }

◆ getMyTwoLoopEW()

EWSMTwoLoopEW* StandardModel::getMyTwoLoopEW ( ) const
inline

Definition at line 996 of file StandardModel.h.

997  {
998  return myTwoLoopEW;
999  }

◆ getMyTwoLoopQCD()

EWSMTwoLoopQCD* StandardModel::getMyTwoLoopQCD ( ) const
inline

Definition at line 1001 of file StandardModel.h.

1002  {
1003  return myTwoLoopQCD;
1004  }

◆ getMz()

double StandardModel::getMz ( ) const
inline

A get method to access the mass of the \(Z\) boson \(M_Z\).

Returns
the \(Z\)-boson mass \(M_Z\)

Definition at line 718 of file StandardModel.h.

719  {
720  return Mz;
721  }

◆ getPhiBd()

virtual double StandardModel::getPhiBd ( ) const
inlinevirtual

Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one.

Returns
\(1/2 (\mathrm{arg}((M_{12}^{bd})_\mathrm{full})-\mathrm{arg}((M_{12}^{bd})_\mathrm{SM}))\vert\)

Reimplemented in NPDF2.

Definition at line 2465 of file StandardModel.h.

2466  {
2467  return 0.;
2468  }

◆ getPhiBs()

virtual double StandardModel::getPhiBs ( ) const
inlinevirtual

Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one.

Returns
\( 1/2 (\mathrm{arg}((M_{12}^{bs})_\mathrm{full})-\mathrm{arg}((M_{12}^{bs})_\mathrm{SM}))\vert\)

Reimplemented in NPDF2.

Definition at line 2456 of file StandardModel.h.

2457  {
2458  return 0.;
2459  }

◆ getTrueSM()

virtual StandardModel StandardModel::getTrueSM ( ) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 940 of file StandardModel.h.

941  {
942  throw std::runtime_error("StandardModel::getTrueSM() must be overridden by the NP extension.");
943  }

◆ getUPMNS()

gslpp::matrix<gslpp::complex> StandardModel::getUPMNS ( ) const
inline

A get method to retrieve the object of the PMNS matrix.

Returns
the PMNS matrix

Definition at line 885 of file StandardModel.h.

886  {
887  return myPMNS.getPMNS();
888  }

◆ getVCKM()

gslpp::matrix<gslpp::complex> StandardModel::getVCKM ( ) const
inline

A get method to retrieve the CKM matrix.

Returns
the CKM matrix

Definition at line 867 of file StandardModel.h.

868  {
869  return myCKM.getCKM();
870  }

◆ getYd()

gslpp::matrix<gslpp::complex> StandardModel::getYd ( ) const
inline

A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\).

Returns
\(Y_d\)

Definition at line 905 of file StandardModel.h.

906  {
907  return Yd;
908  }

◆ getYe()

gslpp::matrix<gslpp::complex> StandardModel::getYe ( ) const
inline

A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\).

Returns
\(Y_e\)

Definition at line 925 of file StandardModel.h.

926  {
927  return Ye;
928  }

◆ getYn()

gslpp::matrix<gslpp::complex> StandardModel::getYn ( ) const
inline

A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\).

Returns
\(Y_\nu\)

Definition at line 915 of file StandardModel.h.

916  {
917  return Yn;
918  }

◆ getYu()

gslpp::matrix<gslpp::complex> StandardModel::getYu ( ) const
inline

A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\).

Returns
\(Y_u\)

Definition at line 895 of file StandardModel.h.

896  {
897  return Yu;
898  }

◆ gV_f()

gslpp::complex StandardModel::gV_f ( const Particle  f) const
virtual

The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM.

\[ g_V^l = g_A^l (1 - 4|Q_l|\kappa_Z^l s_W^2)\,. \]

Parameters
[in]fa lepton or quark
Returns
\(g_{V,\,\mathrm{SM}}^l\)

Reimplemented in NPEpsilons, and NPbase.

Definition at line 1542 of file StandardModel.cpp.

1543 {
1544  return ( gA_f(f)
1545  *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1546 }

◆ Init()

bool StandardModel::Init ( const std::map< std::string, double > &  DPars)
virtual

A method to initialize the model parameters.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in GeneralTHDM, THDMW, THDM, GeorgiMachacek, RealWeakEFTLFV, FlavourWilsonCoefficient, RealWeakEFTCC, myModel, and myModel.

Examples
myModel.cpp.

Definition at line 159 of file StandardModel.cpp.

160 {
161  for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
162  if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
163  throw std::runtime_error("ERROR: inappropriate parameter " + it->first
164  + " in model initialization");
165 
166  std::map<std::string, double> myDPars(DPars);
167  myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
168  myDPars["MAls"] = myDPars.at("Mz");
169  return (QCD::Init(myDPars));
170 }

◆ InitializeModel()

bool StandardModel::InitializeModel ( )
virtual

A method to initialize the model.

This method, called via InputParser::ReadParameters(), allocates memory to the pointers defined in the current class.

Returns
a boolean that is true if model initialization is successful

< A pointer to an object of type EWSMcache.

< A pointer to an object of type EWSMOneLoopEW.

< A pointer to an object of type EWSMTwoLoopQCD.

< A pointer to an object of type EWSMThreeLoopQCD.

< A pointer to an object of type EWSMTwoLoopEW.

< A pointer to an object of type EWSMThreeLoopEW2QCD.

< A pointer to an object of type EWSMThreeLoopEW.

< A pointer to an object of type EWSMApproximateFormulae.

Reimplemented in GeneralTHDM, THDMW, THDM, GeorgiMachacek, RealWeakEFTLFV, FlavourWilsonCoefficient_DF2, FlavourWilsonCoefficient, RealWeakEFTCC, myModel, and myModel.

Examples
myModel.cpp.

Definition at line 140 of file StandardModel.cpp.

◆ IsFlagNoApproximateGammaZ()

bool StandardModel::IsFlagNoApproximateGammaZ ( ) const
inline

A method to retrieve the model flag NoApproximateGammaZ.

See StandardModelFlags for detail.

Returns
a boolean that is true if the two-loop approximate formulae of the partial and total decay widths of the \(Z\) boson defined with the function EWSMApproximateFormulae::X_full_2_loop() is NOT employed

Definition at line 644 of file StandardModel.h.

645  {
647  }

◆ IsFlagWithoutNonUniversalVC()

bool StandardModel::IsFlagWithoutNonUniversalVC ( ) const
inline

A method to retrieve the model flag WithoutNonUniversalVC.

See StandardModelFlags for detail.

Returns
a boolean that is true if flavour non-universal vertex corrections are NOT added to the epsilon parameters describing new physics contribution
Attention
The flag FlagWithoutNonUniversalVC is applicable only for the models StandardModel and NPEpsilons.

Definition at line 631 of file StandardModel.h.

632  {
634  }

◆ kappaZ_f()

gslpp::complex StandardModel::kappaZ_f ( const Particle  f) const
virtual

The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM.

This function collects the radiative corrections to \(\kappa_Z^l\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes. The real part is computed with the function resumKappaZ(), while only the one-loop contribution is kept in the imaginary part.

As a part of the two-loop EW contribution, a correction associated with the product of the imaginary part of \(\Delta\alpha\) and that of \(\Pi_{Z\gamma}\) is included [33], [39] :

\begin{eqnarray} \Delta \kappa_Z^l = - \frac{1}{s_W^2}\left( \frac{\alpha(M_Z^2)}{4\pi} \right)^2 {\rm Im}\,\overline{\Pi}_{\gamma\gamma}^{\rm fer}(M_Z^2)\,\, {\rm Im}\,\overline{\Pi}_{Z\gamma}^{\rm fer}(M_Z^2) = \frac{35\alpha^2(M_Z^2)}{18 s_W^2}\, \left( 1 - \frac{8}{3}\, {\rm Re}(\kappa_Z^l) s_W^2 \right). \end{eqnarray}

Parameters
[in]fa lepton or quark
Returns
\(\kappa_{Z,\,\mathrm{SM}}^l\)
See also
resumKappaZ()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPEpsilons, and NPbase.

Definition at line 1618 of file StandardModel.cpp.

1619 {
1620  if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1621 
1623  if (useKappaZ_f_cache[f.getIndex()])
1624  return kappaZ_f_cache[f.getIndex()];
1625 
1626  double myMw = Mw();
1627 
1628  double ReKappaZf = 0.0, ImKappaZf = 0.0;
1629  if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1630 
1631 // Choose the correct formulae for the effective angle
1632  if (FlagSMAux && (f.is("BOTTOM")) ){
1633  ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1634  } else if (FlagSMAux && (f.is("ELECTRON") || f.is("MUON") || f.is("TAU") ) ) {
1635  ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1636  } else {
1637  ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1638  }
1639 
1640  ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1641 #ifdef WITHIMTWOLOOPQCD
1642  ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1643 
1644  /* TEST */
1645  //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1646 #endif
1647  } else {
1648  /* compute Delta rho */
1649  double DeltaRho[orders_EW_size];
1650  ComputeDeltaRho(myMw, DeltaRho);
1651 
1652  /* compute delta kappa_rem^f */
1653  gslpp::complex deltaKappa_remf[orders_EW_size];
1654  deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1655  deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1656  deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1657  deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1658  deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1659  deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1660  if (flag_order[EW1])
1661  deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1662  if (flag_order[EW1QCD1])
1663 #ifdef WITHIMTWOLOOPQCD
1664  deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1665  myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1666 #else
1667  deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1668 #endif
1669  if (flag_order[EW1QCD2])
1670  deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1671  if (flag_order[EW2])
1672  deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1673  if (flag_order[EW2QCD1])
1674  deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1675  if (flag_order[EW3])
1676  deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1677 
1678  /* compute Delta rbar_rem */
1679  double DeltaRbar_rem = 0.0;
1680  if (flag_order[EW1])
1681  DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1682 
1683  /* Re[kappa_Z^f] with or without resummation */
1684  double deltaKappa_rem_f_real[orders_EW_size];
1685  for (int j = 0; j < orders_EW_size; ++j)
1686  deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1687 
1688  ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1689 
1690  /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1691  ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1692  *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1693 
1694  /* Im[kappa_Z^f] without resummation */
1695  for (int j = 0; j < orders_EW_size; ++j)
1696  ImKappaZf += deltaKappa_remf[j].imag();
1697  }
1698 
1699  kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1700  useKappaZ_f_cache[f.getIndex()] = true;
1701  return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1702 }

◆ m_q()

double StandardModel::m_q ( const QCD::quark  q,
const double  mu,
const orders  order = FULLNLO 
) const
inlineprotected

Definition at line 2591 of file StandardModel.h.

2592  {
2593  switch(q) {
2594  case QCD::UP:
2595  case QCD::DOWN:
2596  case QCD::STRANGE:
2597  return Mrun(mu, getQuarks(q).getMass_scale(),
2598  getQuarks(q).getMass(), order);
2599  case QCD::CHARM:
2600  case QCD::BOTTOM:
2601  return Mrun(mu, getQuarks(q).getMass(), order);
2602  case QCD::TOP:
2603  return getMtpole(); // the pole mass
2604  default:
2605  throw std::runtime_error("Error in StandardModel::m_q()");
2606  }
2607  }

◆ Mw()

double StandardModel::Mw ( ) const
virtual

The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\).

When the model flag Mw of StandardModel is set to APPROXIMATEFORMULA, the current function uses the two-loop approximate formula in EWSMApproximateFormulae::Mw(), which includes the full two-loop EW contribution of \({\cal O}(\alpha^2)\) as well as the leading \({\cal O}(G_\mu^2\alpha_s m_t^4)\) and \({\cal O}(G_\mu^3m_t^6)\) contributions.

When the model flag Mw is not set to APPROXIMATEFORMULA, the \(W\)-boson mass is computed from \(\Delta r(M_W)\) with an iterative procedure. The target accuracy of the iterative calculation is specified with the constant Mw_error. This function calls resumMw(), in which \(M_W\) is computed with a given \(\Delta r\), equivalently with \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\)

Returns
\(M_{W,\mathrm{SM}}\) in GeV
See also
resumMw()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPSMEFTd6, GeneralTHDM, THDMW, GeorgiMachacek, NPEpsilons, NPZbbbar, NPbase, and NPEpsilons_pureNP.

Definition at line 944 of file StandardModel.cpp.

945 {
946  /* Debug */
947  //std::cout << std::boolalpha
948  // << checkScheme(schemeMw_cache,schemeMw,false)
949  // << " [cache:" << schemeMw_cache
950  // << " current:" << schemeMw << "]" << std::endl;
951 
953  if (useMw_cache)
954  return Mw_cache;
955 
956  double Mw;
957  if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
959  else {
960  //std::cout << std::setprecision(12)
961  // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
962 
963  double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
964  ComputeDeltaRho(Mw_tree(), DeltaRho);
965  ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
966  Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
967 
968  /* Mw from iterations */
969  double Mw_org = Mw_tree();
970  while (fabs(Mw - Mw_org) > Mw_error) {
971  Mw_org = Mw;
972  ComputeDeltaRho(Mw, DeltaRho);
973  ComputeDeltaR_rem(Mw, DeltaR_rem);
974  Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
975  /* TEST */
976  //int prec_def = std::cout.precision();
977  //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
978  // << " Mw_new = " << Mw << std::endl;
979  //std::cout.precision(prec_def);
980  }
981  }
982 
983 // Mw = 80.426; // FOR HEFFDF1 TEST
984  Mw_cache = Mw;
985  useMw_cache = true;
986  return Mw;
987 }

◆ Mw_tree()

double StandardModel::Mw_tree ( ) const
virtual

The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\).

Returns
\(M_W^{\mathrm{tree}}\) in GeV.

Definition at line 925 of file StandardModel.cpp.

926 {
927  return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
928 }

◆ MwbarFromMw()

double StandardModel::MwbarFromMw ( const double  Mw) const

A method to convert the \(W\)-boson mass in the experimental/running-width scheme to that in the complex-pole/fixed-width scheme.

The mass parameter \(\overline{M}_W\) in the complex-pole/fixed-width scheme [37] is given by

\[ \overline{M}_{W} = M_{W} - \frac{\Gamma_{W}^2}{2M_{W}}\,, \]

where \(M_W\) and \(\Gamma_{W}\) are the mass and width of the \(W\) boson in the experimental/running-width scheme:

\[ \Gamma_W = \frac{3G_\mu M_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(M_W^2)}{3\pi} \right)\,. \]

Parameters
[in]Mwthe \(W\)-boson mass in the experimental/running-width scheme
Returns
\(\overline{M}_W\) in GeV

Definition at line 1102 of file StandardModel.cpp.

1103 {
1104  double AlsMw = Als(Mw, FULLNLO);
1105  double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1106  * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1107 
1108  return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1109 }

◆ MwFromMwbar()

double StandardModel::MwFromMwbar ( const double  Mwbar) const

A method to convert the \(W\)-boson mass in the complex-pole/fixed-width scheme to that in the experimental/running-width scheme.

The experimental mass \(M_W\) is derived

\[ M_W = \overline{M}_W + \frac{\Gamma_{W}^2}{2\overline{M}_{W}}\,, \]

where \(\overline{M}_W\) is the mass parameter in the complex-pole/fixed-width scheme [37], and \(\Gamma_{W}\) is the \(W\)-boson width in the experimental/running-width scheme:

\[ \Gamma_W = \frac{3G_\mu M_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(M_W^2)}{3\pi} \right) \approx \frac{3G_\mu \overline{M}_W^3}{2\sqrt{2}\pi} \left( 1 + \frac{2\alpha_s(\overline{M}_W^2)}{3\pi} \right)\,. \]

Parameters
[in]Mwbarthe \(W\)-boson mass in the complex-pole/fixed-width scheme
Returns
\(M_W\) in GeV

Definition at line 1111 of file StandardModel.cpp.

1112 {
1113  double AlsMw = Als(Mwbar, FULLNNLO);
1114  double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1115  * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1116 
1117  return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1118 }

◆ Mzbar()

double StandardModel::Mzbar ( ) const

The \(Z\)-boson mass \(\overline{M}_Z\) in the complex-pole/fixed-width scheme.

The mass parameter \(\overline{M}_Z\) in the complex-pole/fixed-width scheme [37] is given by

\[ \overline{M}_{Z} = M_{Z} - \frac{\Gamma_{Z}^2}{2M_{Z}}\,, \]

where \(M_Z\) and \(\Gamma_{Z}\) are the mass and width of the \(Z\) boson in the experimental/running-width scheme:

\begin{align} \Gamma(Z\to f\bar{f}) = \frac{G_\mu M_Z^3}{24\sqrt{2}\pi} \left[ \left( \frac{v_f}{a_f} \right)^2 + 1 \right] \times \left\{ \begin{array}{ll} 1 & \mathrm{for}\quad f=\ell\,, \\[2mm] \displaystyle N_c \left( 1 + \frac{\alpha_s(M_Z^2)}{\pi} \right) & \mathrm{for}\quad f=q \end{array} \right. \end{align}

with \(v_f/a_f=1-4|Q_f|s_{W,\mathrm{tree}}^2\).

Returns
\(\overline{M}_Z\) in GeV

Definition at line 1085 of file StandardModel.cpp.

1086 {
1087  double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1088  double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1089  double Gz = 6.0 * G0; // neutrinos
1090  Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1091  Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1092  * (1.0 + AlsMz / M_PI); // u and c
1093  Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1094  * (1.0 + AlsMz / M_PI); // d, s and b
1095 
1096  //Gz = 2.4952; // experimental data
1097  //std::cout << "Gz=" << Gz << std::endl; // for test
1098 
1099  return ( Mz - Gz * Gz / 2.0 / Mz);
1100 }

◆ N_nu()

double StandardModel::N_nu ( ) const
virtual

The number of neutrinos obtained indirectly from the measurements at the Z pole, \(N_{\nu}\).

\(N_{\nu}\) is calculated with

\[ N_{\nu} = \frac{\Gamma_\ell}{\Gamma_{\nu}}\left(\sqrt{\frac{12\pi R_\ell}{M_Z^2 \sigma_\mathrm{had}^0}}-R_\ell - 3\right)\,. \]

Returns
\(N_{\nu} \)

Reimplemented in NPbase.

Definition at line 1521 of file StandardModel.cpp.

1522 {
1523  double Nnu = 0.0;
1524  double Gl = 0.0;
1525  double Rl = 0.0;
1526 
1527  // Don't assume lepton universality: average over lepton flavours
1529  Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1530 
1531  Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1532 
1533  Nnu = (Gl/Gamma_inv()) * Nnu;
1534 
1535  return Nnu;
1536 
1537 }

◆ PostUpdate()

bool StandardModel::PostUpdate ( )
virtual

The post-update method for StandardModel.

This method runs all the procedures that are need to be executed after the model is successfully updated. This includes

  • computing the updated CKM and PMNS matrices
  • computing the Yukawa matrices
  • updating the Standard Model parameters in the StandardModelMatching class.
    Returns
    a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in NPSMEFTd6, GeneralTHDM, THDMW, HiggsKigen, THDM, GeorgiMachacek, NPZbbbarLinearized, NPZbbbar, RealWeakEFTLFV, FlavourWilsonCoefficient, NPEpsilons, FlavourWilsonCoefficient_DF2, HiggsChiral, RealWeakEFTCC, NPbase, myModel, and myModel.

Examples
myModel.cpp.

Definition at line 199 of file StandardModel.cpp.

200 {
201  if (!QCD::PostUpdate()) return (false);
202 
203  /* Set the CKM and PMNS matrices */
204  computeCKM();
205 
206  /* Set the Yukawa matrices */
207  if (!isModelSUSY()) {
208  computeYukawas();
209  }
210 
211  /* Check whether the parameters for the EWPO are updated or not */
212  if (!checkSMparamsForEWPO()) {
214  useDeltaAlpha_cache = false;
215  useMw_cache = false;
216  useGammaW_cache = false;
217  for (int i = 0; i < 12; ++i) {
218  useRhoZ_f_cache[i] = false;
219  useKappaZ_f_cache[i] = false;
220  }
221  }
223  /* Necessary for updating StandardModel parameters in StandardModelMatching */
225 
226  iterationNo++;
227 
228  return (true);
229 }

◆ PreUpdate()

bool StandardModel::PreUpdate ( )
virtual

The pre-update method for StandardModel.

This method initializes the internal flags requireCKM, requireYe and requireYn, and calls QCD::PreUpdate(), before updating the model parameters with the method Update().

Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in GeneralTHDM, THDMW, THDM, GeorgiMachacek, RealWeakEFTLFV, FlavourWilsonCoefficient, RealWeakEFTCC, myModel, and myModel.

Examples
myModel.cpp.

Definition at line 172 of file StandardModel.cpp.

173 {
174  requireCKM = false;
175  requireYe = false;
176  requireYn = false;
177 
178  if (!QCD::PreUpdate()) return (false);
179 
180  return (true);
181 }

◆ R0_f()

double StandardModel::R0_f ( const Particle  f) const
virtual

The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(R_\ell^0\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, \(R_\ell^0\) is calculated with

\[ R_\ell^0 = \frac{\Gamma_h}{\Gamma_\ell}\,. \]

, where \(\ell\) denotes a charged lepton.

Parameters
[in]fa lepton or quark
Returns
\(R_\ell^0 \)

Reimplemented in NPEpsilons, NPbase, and NPZbbbar.

Definition at line 1369 of file StandardModel.cpp.

1370 {
1371 
1372  if (FlagSMAux) {
1373 
1374 // New (Testing)
1375 
1376  if (f.is("ELECTRON")) {
1378  /* SM contribution with the approximate formula */
1379  return (myApproximateFormulae->X_full("R0_electron"));
1380  else
1381  return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1382  } else if (f.is("MU")) {
1384  /* SM contribution with the approximate formula */
1385  return (myApproximateFormulae->X_full("R0_muon"));
1386  else
1387  return (Gamma_had() / GammaZ(leptons[MU]));
1388  } else if (f.is("TAU")) {
1390  /* SM contribution with the approximate formula */
1391  return (myApproximateFormulae->X_full("R0_tau"));
1392  else
1393  return (Gamma_had() / GammaZ(leptons[TAU]));
1394  } else if (f.is("NEUTRINO_1")) {
1396  /* SM contribution with the approximate formula */
1397  return (myApproximateFormulae->X_full("R0_neutrino"));
1398  else
1399  return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1400  } else if (f.is("NEUTRINO_2")) {
1402  /* SM contribution with the approximate formula */
1403  return (myApproximateFormulae->X_full("R0_neutrino"));
1404  else
1405  return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1406  } else if (f.is("NEUTRINO_3")) {
1408  /* SM contribution with the approximate formula */
1409  return (myApproximateFormulae->X_full("R0_neutrino"));
1410  else
1411  return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1412  } else if (f.is("UP")) {
1414  /* SM contribution with the approximate formula */
1415  return (myApproximateFormulae->X_full("R0_up"));
1416  else
1417  return (GammaZ(quarks[UP]) / Gamma_had());
1418 
1419  } else if (f.is("STRANGE")) {
1421  /* SM contribution with the approximate formula */
1422  return (myApproximateFormulae->X_full("R0_strange"));
1423  else
1424  return (GammaZ(quarks[STRANGE]) / Gamma_had());
1425 
1426  } else if (f.is("CHARM")) {
1428  /* SM contribution with the approximate formula */
1429  return (myApproximateFormulae->X_full("R0_charm"));
1430  else
1431  return (GammaZ(quarks[CHARM]) / Gamma_had());
1432 
1433  } else if (f.is("BOTTOM")) {
1435  /* SM contribution with the approximate formula */
1436  return (myApproximateFormulae->X_full("R0_bottom"));
1437  else
1438  return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1439 
1440  } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1441 
1442  } else {
1443 
1444 // Original
1445 
1446  if (f.is("ELECTRON")) {
1448  /* SM contribution with the approximate formula */
1449  return (myApproximateFormulae->X_full_2_loop("R0_electron"));
1450  else
1451  return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1452  } else if (f.is("MU")) {
1454  /* SM contribution with the approximate formula */
1455  return (myApproximateFormulae->X_full_2_loop("R0_muon"));
1456  else
1457  return (Gamma_had() / GammaZ(leptons[MU]));
1458  } else if (f.is("TAU")) {
1460  /* SM contribution with the approximate formula */
1461  return (myApproximateFormulae->X_full_2_loop("R0_tau"));
1462  else
1463  return (Gamma_had() / GammaZ(leptons[TAU]));
1464  } else if (f.is("NEUTRINO_1")) {
1466  /* SM contribution with the approximate formula */
1467  return (myApproximateFormulae->X_full_2_loop("R0_neutrino"));
1468  else
1469  return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1470  } else if (f.is("NEUTRINO_2")) {
1472  /* SM contribution with the approximate formula */
1473  return (myApproximateFormulae->X_full_2_loop("R0_neutrino"));
1474  else
1475  return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1476  } else if (f.is("NEUTRINO_3")) {
1478  /* SM contribution with the approximate formula */
1479  return (myApproximateFormulae->X_full_2_loop("R0_neutrino"));
1480  else
1481  return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1482  } else if (f.is("UP")) {
1484  /* SM contribution with the approximate formula */
1485  return (myApproximateFormulae->X_full_2_loop("R0_up"));
1486  else
1487  return (GammaZ(quarks[UP]) / Gamma_had());
1488 
1489  } else if (f.is("STRANGE")) {
1491  /* SM contribution with the approximate formula */
1492  return (myApproximateFormulae->X_full_2_loop("R0_strange"));
1493  else
1494  return (GammaZ(quarks[STRANGE]) / Gamma_had());
1495 
1496  } else if (f.is("CHARM")) {
1498  /* SM contribution with the approximate formula */
1499  return (myApproximateFormulae->X_full_2_loop("R0_charm"));
1500  else
1501  return (GammaZ(quarks[CHARM]) / Gamma_had());
1502 
1503  } else if (f.is("BOTTOM")) {
1505  /* SM contribution with the approximate formula */
1506  return (myApproximateFormulae->X_full_2_loop("R0_bottom"));
1507  else
1508  return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1509 
1510  } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1511 
1512  }
1513 }

◆ R_inv()

double StandardModel::R_inv ( ) const
virtual

The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\).

\(R_{inv}\) is calculated with

\[ R_{inv} = \frac{\Gamma_{inv}}{\Gamma_e}\,. \]

,

Returns
\(R_{inv} \)

Reimplemented in NPbase.

Definition at line 1515 of file StandardModel.cpp.

1516 {
1517  return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1518 
1519 }

◆ RAq()

double StandardModel::RAq ( const QCD::quark  q) const
protected

The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-current interactions, \(R_A^q(M_Z^2)\).

See [58], [33], [39], [29] and references therein.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(R_A^q(M_Z^2)\)

Definition at line 2236 of file StandardModel.cpp.

2237 {
2238  if (q == QCD::TOP) return 0.0;
2239 
2240  double mcMz, mbMz;
2241  mcMz = myEWSMcache->mf(getQuarks(CHARM), Mz, FULLNNLO);
2242  mbMz = myEWSMcache->mf(getQuarks(BOTTOM), Mz, FULLNNLO);
2243  //mcMz = 0.56381685; /* for debug */
2244  //mbMz = 2.8194352; /* for debug */
2245 
2246  double MtPole = mtpole;
2247 
2248  /* z-component of isospin */
2249  double I3q = quarks[q].getIsospin();
2250  /* electric charge squared */
2251  double Qf2 = pow(quarks[q].getCharge(), 2.0);
2252 
2253  /* s = Mz^2 */
2254  double s = Mz * Mz;
2255 
2256  /* products of the charm and bottom masses at Mz */
2257  double mcMz2 = mcMz*mcMz;
2258  double mbMz2 = mbMz*mbMz;
2259  double mqMz2, mqdash4;
2260  switch (q) {
2261  case QCD::CHARM:
2262  mqMz2 = mcMz*mcMz;
2263  mqdash4 = mbMz2*mbMz2;
2264  break;
2265  case QCD::BOTTOM:
2266  mqMz2 = mbMz*mbMz;
2267  mqdash4 = mcMz2*mcMz2;
2268  break;
2269  default:
2270  mqMz2 = 0.0;
2271  mqdash4 = 0.0;
2272  break;
2273  }
2274 
2275  /* Logarithms */
2276  //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2277  double log_t = log(MtPole * MtPole / s); // the pole mass
2278  double log_c = log(mcMz2 / s);
2279  double log_b = log(mbMz2 / s);
2280  double log_q;
2281  switch (q) {
2282  case QCD::CHARM:
2283  case QCD::BOTTOM:
2284  log_q = log(mqMz2 / s);
2285  break;
2286  default:
2287  log_q = 0.0;
2288  break;
2289  }
2290 
2291  /* the active number of flavour */
2292  double nf = 5.0;
2293 
2294  /* zeta functions */
2295  double zeta2 = getMyEWSMcache()->getZeta2();
2296  double zeta3 = getMyEWSMcache()->getZeta3();
2297  double zeta4 = getMyEWSMcache()->getZeta4();
2298  double zeta5 = getMyEWSMcache()->getZeta5();
2299 
2300  /* massless non-singlet corrections */
2301  double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2302  double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2303  + 275.0 / 6.0 * zeta5
2304  + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2305  - 25.0 / 9.0 * zeta5) * nf
2306  + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2307  double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2308  //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2309  //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2310  //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2311 
2312  /* quadratic massive corrections */
2313  double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2314  double C20A = -6.0;
2315  double C21A = -22.0;
2316  double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2317  + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2318  double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2319  - 127.0 * zeta5
2320  + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2321  + 5.0 * zeta4 + 55.0 * zeta5) * nf
2322  + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2323 
2324  /* quartic massive corrections */
2325  double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2326  double C40A = 6.0;
2327  double C41A = 10.0;
2328  double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2329  + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2330  double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2331 
2332  /* power suppressed top-mass correction */
2333  //double xt = s/pow(quarks[TOP].getMass(),2.0);
2334  double xt = s / MtPole / MtPole; // the pole mass
2335  double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2336 
2337  /* singlet axial-vector corrections */
2338  double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2339  double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2340  + 23.0 / 12.0 * log_t*log_t;
2341  double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2342  + 3.6736 * (-log_t * log_t * log_t);
2343 
2344  /* rescaled strong coupling constant */
2345  double AlsMzPi = AlsMz / M_PI;
2346  double AlsMzPi2 = AlsMzPi*AlsMzPi;
2347  double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2348  double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2349 
2350  /* electromagnetic coupling at Mz */
2351  double alpMz = alphaMz();
2352 
2353  /* radiator function to the axial-vector current */
2354  double RAf;
2355  RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2356  + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2357  + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2358  + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2359  + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2360  + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2361  + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2362  //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2363  - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2364  * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2365  + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2366  + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2367  + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2368  + (C42A + C42AL * log_q) * AlsMzPi2)
2369  - 12.0 * mqdash4 / s / s*AlsMzPi2;
2370  return RAf;
2371 }

◆ resumKappaZ()

double StandardModel::resumKappaZ ( const double  DeltaRho[orders_EW_size],
const double  deltaKappa_rem[orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb 
) const
protected

A method to compute the real part of the effetvive coupling \(\kappa_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\).

This function computes \(\kappa_Z^f\) without or with resummation of \(\Delta\rho\), depending on the model flag KappaZ of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [39] (see also [110], [109], [107], [33]), and used for making comparisons to the outputs of ZFITTER. In all the cases, the two-loop EW corrections are calculated in the large- \(m_t\) expansion.

Parameters
[in]DeltaRhoArray of \(\Delta\rho\)
[in]deltaKappa_remArray of \(\delta\kappa_{\rm rem}^{f}\)
[in]DeltaRbar_remArray of \(\Delta \bar{r}_{\rm rem}\)
[in]bool_Zbbtrue for \(Zb\bar{b}\)
Returns
\(\mathrm{Re}(\kappa_Z^f)\)

Definition at line 2001 of file StandardModel.cpp.

2004 {
2005  if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2006  || (deltaKappa_rem[EW2QCD1] != 0.0)
2007  || (deltaKappa_rem[EW3] != 0.0))
2008  throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2009 
2010  if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2011  throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2012 
2013  double Mw_TMP = Mw();
2014  double cW2_TMP = cW2();
2015  double sW2_TMP = sW2();
2016 
2017  double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2018  double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2019  // conversion: alpha(0) --> G_F
2020  f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2021  * sW2_TMP * cW2_TMP / M_PI / ale;
2022  DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2023  + f_AlphaToGF * DeltaRho[EW1QCD1]
2024  + f_AlphaToGF * DeltaRho[EW1QCD2]
2025  + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2026  + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2027  + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2028  DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2029  DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2030  deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2031  + deltaKappa_rem[EW1QCD1]
2032  + deltaKappa_rem[EW1QCD2]);
2033  deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2034 
2035  /* Real parts */
2036  double kappaZ;
2037  if (!bool_Zbb) {
2038  if (FlagKappaZ.compare("OMSI") == 0) {
2039  kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2040  *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2041  } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2042  kappaZ = (1.0 + deltaKappa_rem_G)
2043  *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2044  + deltaKappa_rem_G2;
2045  } else if (FlagKappaZ.compare("NORESUM") == 0
2046  || FlagKappaZ.compare("OMSII") == 0) {
2047  kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2048  - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2049  + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2050  + deltaKappa_rem_G2;
2051  } else
2052  throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2053  } else {
2054  /* Z to bb */
2055  double OnePlusTaub = 1.0 + taub();
2056  double kappaZbL;
2057  deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2058  * pow(mtpole / Mw_TMP, 2.0);
2059  if (FlagKappaZ.compare("NORESUM") == 0) {
2060  kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2061  - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2062  + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2063  + deltaKappa_rem_G2) / OnePlusTaub;
2064  } else if (FlagKappaZ.compare("OMSI") == 0) {
2065  kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2066  kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2067  } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2068  || FlagKappaZ.compare("OMSII") == 0) {
2069  kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2070  kappaZ = kappaZbL + deltaKappa_rem_G;
2071  } else
2072  throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2073  }
2074 
2075  return kappaZ;
2076 }

◆ resumMw()

double StandardModel::resumMw ( const double  Mw_i,
const double  DeltaRho[orders_EW_size],
const double  DeltaR_rem[orders_EW_size] 
) const
protected

A method to compute the \(W\)-boson mass from \(\Delta\rho\) and \(\Delta r_{\mathrm{rem}}\).

This function computes the \(W\)-boson mass without or with resummation of \(\Delta r\), depending on the model flag Mw of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [39] (see also [110], [109], [107], [33]), and used for making comparisons to the outputs of ZFITTER. The full two-loop EW contribution is included in the case of "NORESUM", while the large- \(m_t\) expansion for the two-loop contribution is adopted in the other cases.

In the case of "NORESUM", the two-loop EW contribution to \(\Delta r\) is calculated via the function EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem(), given in the complex-pole/fixed-width scheme. The \(W\)-boson mass in the complex-pole/fixed-width scheme, obtained from \(\Delta r\), is converted into the one in the experimental/running-width scheme with the function MwFromMwbar().

Parameters
[in]Mw_ithe \(W\)-boson mass
[in]DeltaRhoArray of \(\Delta\rho\)
[in]DeltaR_remArray of \(\Delta r_{\mathrm{rem}}\)
Returns
\(M_W\)

Definition at line 1835 of file StandardModel.cpp.

1837 {
1838  if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1839  || (DeltaR_rem[EW2QCD1] != 0.0)
1840  || (DeltaR_rem[EW3] != 0.0))
1841  throw std::runtime_error("Error in StandardModel::resumMw()");
1842 
1843  if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1844  throw std::runtime_error("Error in StandardModel::resumMw()");
1845 
1846  double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1847  double sW2_TMP = 1.0 - cW2_TMP;
1848 
1849  double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1850  if (FlagMw.compare("NORESUM") == 0) {
1851  for (int j = 0; j < orders_EW_size; ++j) {
1852  DeltaRho_sum += DeltaRho[(orders_EW) j];
1853  }
1854  } else {
1855  // conversion: alpha(0) --> G_F
1856  f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1857  DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1858  + f_AlphaToGF * DeltaRho[EW1QCD1]
1859  + f_AlphaToGF * DeltaRho[EW1QCD2]
1860  + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1861  + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1862  + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1863  DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1864  }
1865 
1866  double R;
1867  double DeltaR_rem_sum = 0.0;
1868  double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1869  if (FlagMw.compare("NORESUM") == 0) {
1870  for (int j = 0; j < orders_EW_size; ++j)
1871  DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1872 
1873  // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1874  DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1875 
1876  // Full EW two-loop contribution without reducible corrections
1877  DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1878 
1879  // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1880  DeltaRho_sum -= DeltaRho[EW2];
1881  DeltaR_rem_sum -= DeltaR_rem[EW2];
1882 
1883  // R = 1 + Delta r, including the full EW two-loop contribution
1884  R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1885  + DeltaR_rem_sum;
1886  R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1887  + DeltaR_EW2_rem;
1888  } else if (FlagMw.compare("OMSI") == 0) {
1889  // R = 1/(1 - Delta r)
1890  R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1891  / (1.0 - DeltaAlphaL5q()
1892  - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1893  } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1894  // R = 1/(1 - Delta r)
1895  R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1896  *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1897  - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1898  } else if (FlagMw.compare("OMSII") == 0) {
1899  // R = 1/(1 - Delta r)
1900  R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1901  - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1902  - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1903  } else
1904  throw std::runtime_error("Error in StandardModel::resumMw()");
1905 
1906  if (FlagMw.compare("NORESUM") == 0) {
1907  /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1908 
1909  double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1910  if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1911  double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1912 
1913  return MwFromMwbar(Mwbar);
1914  } else {
1915  double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1916  if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1917 
1918  return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1919  }
1920 }

◆ resumRhoZ()

double StandardModel::resumRhoZ ( const double  DeltaRho[orders_EW_size],
const double  deltaRho_rem[orders_EW_size],
const double  DeltaRbar_rem,
const bool  bool_Zbb 
) const
protected

A method to compute the real part of the effective coupling \(\rho_Z^f\) from \(\Delta\rho\), \(\delta\rho_{\rm rem}^{f}\) and \(\Delta r_{\mathrm{rem}}\).

This function computes \(\rho_Z^f\) without or with resummation of \(\Delta\rho\), depending on the model flag RhoZ of StandardModel:

  • NORESUM (recommended):   no resummation is considered;
  • OMSI:   the so-called OMS-I scheme is adopted;
  • INTERMEDIATE:   an intermediate scheme between OMS-I and OMS-II is adopted;
  • OMSII:   the so-called OMS-II scheme is adopted;
  • APPROXIMATEFORMULA:   this is not applicable to the current function.

where the OMS-I, INTERMEDIATE and OMS-II schemes are adopted in ZFITTER [39] (see also [110], [109], [107], [33]), and used for making comparisons to the outputs of ZFITTER. In all the cases, the two-loop EW corrections are calculated in the large- \(m_t\) expansion.

Parameters
[in]DeltaRhoArray of \(\Delta\rho\)
[in]deltaRho_remArray of \(\delta\rho_{\rm rem}^{f}\)
[in]DeltaRbar_remArray of \(\Delta \bar{r}_{\rm rem}\)
[in]bool_Zbbtrue for \(Zb\bar{b}\)
Returns
\(\mathrm{Re}(\rho_Z^f)\)

Definition at line 1922 of file StandardModel.cpp.

1925 {
1926  if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1927  || (deltaRho_rem[EW1QCD2] != 0.0)
1928  || (deltaRho_rem[EW2QCD1] != 0.0)
1929  || (deltaRho_rem[EW3] != 0.0))
1930  throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1931 
1932  if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1933  throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1934 
1935  double Mw_TMP = Mw();
1936  double cW2_TMP = cW2();
1937  double sW2_TMP = sW2();
1938 
1939  double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1940  double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1941  // conversion: alpha(0) --> G_F
1942  f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1943  * sW2_TMP * cW2_TMP / M_PI / ale;
1944  DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1945  + f_AlphaToGF * DeltaRho[EW1QCD1]
1946  + f_AlphaToGF * DeltaRho[EW1QCD2]
1947  + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1948  + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1949  + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1950  DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1951  DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1952  deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1953  + deltaRho_rem[EW1QCD1]);
1954  deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1955 
1956  /* Real parts */
1957  double rhoZ;
1958  if (!bool_Zbb) {
1959  if (FlagRhoZ.compare("OMSI") == 0) {
1960  rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
1961  / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
1962  } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
1963  rhoZ = (1.0 + deltaRho_rem_G)
1964  / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
1965  + deltaRho_rem_G2;
1966  } else if (FlagRhoZ.compare("NORESUM") == 0
1967  || FlagRhoZ.compare("OMSII") == 0) {
1968  rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
1969  + DeltaRho_G * DeltaRho_G
1970  + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
1971  } else
1972  throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1973  } else {
1974  /* Z to bb */
1975  double OnePlusTaub = 1.0 + taub();
1976  double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
1977  double rhoZbL;
1978  deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
1979  * pow(mtpole / Mw_TMP, 2.0);
1980  if (FlagRhoZ.compare("NORESUM") == 0) {
1981  rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
1982  + DeltaRho_G * DeltaRho_G
1983  + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
1984  * OnePlusTaub2;
1985  } else if (FlagRhoZ.compare("OMSI") == 0) {
1986  rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
1987  rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
1988  } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
1989  rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
1990  rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
1991  } else if (FlagRhoZ.compare("OMSII") == 0) {
1992  rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
1993  rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
1994  } else
1995  throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1996  }
1997 
1998  return rhoZ;
1999 }

◆ rho_GammaW()

double StandardModel::rho_GammaW ( const Particle  fi,
const Particle  fj 
) const
virtual

EW radiative corrections to the width of \(W \to f_i \bar{f}_j\), denoted as \(\rho^W_{ij}\).

Parameters
[in]fia lepton or quark
[in]fja lepton or quark
Returns
\(\rho^W_{ij}\)
See also
EWSMOneLoopEW::rho_GammaW()

Definition at line 1132 of file StandardModel.cpp.

1133 {
1134  double rhoW = 0.0;
1135  if (flag_order[EW1])
1136  rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1137  return rhoW;
1138 }

◆ rhoZ_f()

gslpp::complex StandardModel::rhoZ_f ( const Particle  f) const
virtual

The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM.

This function collects the radiative corrections to \(\rho_Z^l\) computed via EWSMOneLoopEW, EWSMTwoLoopQCD, EWSMTwoLoopEW, EWSMThreeLoopQCD, EWSMThreeLoopEW2QCD and EWSMThreeLoopEW classes. The real part is computed with the function resumRhoZ(), while only the one-loop contribution is kept in the imaginary part.

Parameters
[in]fa lepton or quark
Returns
\(\rho_{Z,\,\mathrm{SM}}^l\)
See also
resumRhoZ()
Attention
If the model flag CacheInStandardModel of StandardModel is set to true, the caching method implemented in the current class is employed.

Reimplemented in NPEpsilons, and NPbase.

Definition at line 1553 of file StandardModel.cpp.

1554 {
1555  if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1556  if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1557  throw std::runtime_error("No approximate formula is available for rhoZ^f");
1558  else {
1559 
1561  if (useRhoZ_f_cache[f.getIndex()])
1562  return rhoZ_f_cache[f.getIndex()];
1563 
1564  double myMw = Mw();
1565 
1566  /* compute Delta rho */
1567  double DeltaRho[orders_EW_size];
1568  ComputeDeltaRho(myMw, DeltaRho);
1569 
1570  /* compute delta rho_rem^f */
1571  gslpp::complex deltaRho_remf[orders_EW_size];
1572  deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1573  deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1574  deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1575  deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1576  deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1577  deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1578  if (flag_order[EW1])
1579  deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1580  if (flag_order[EW1QCD1])
1581 #ifdef WITHIMTWOLOOPQCD
1582  deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1583  myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1584 #else
1585  deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1586 #endif
1587  if (flag_order[EW1QCD2])
1588  deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1589  if (flag_order[EW2])
1590  deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1591  if (flag_order[EW2QCD1])
1592  deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1593  if (flag_order[EW3])
1594  deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1595 
1596  /* compute Delta rbar_rem */
1597  double DeltaRbar_rem = 0.0;
1598  if (flag_order[EW1])
1599  DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1600 
1601  /* Re[rho_Z^f] with or without resummation */
1602  double deltaRho_rem_f_real[orders_EW_size];
1603  for (int j = 0; j < orders_EW_size; ++j)
1604  deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1605  double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1606 
1607  /* Im[rho_Z^f] without resummation */
1608  double ImRhoZf = 0.0;
1609  for (int j = 0; j < orders_EW_size; ++j)
1610  ImRhoZf += deltaRho_remf[j].imag();
1611 
1612  rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1613  useRhoZ_f_cache[f.getIndex()] = true;
1614  return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1615  }
1616 }

◆ RVh()

double StandardModel::RVh ( ) const
protected

The singlet vector corrections to the hadronic \(Z\)-boson width, denoted as \(R_V^h\).

In addition to the final-state corrections represented by the radiator factors \(R_V^q(M_Z^2)\) and \(R_A^q(M_Z^2)\), there exist singlet vector corrections to the total hadronic width [58], [29], which is much smaller than the other corrections.

The assignment of the singlet vector corrections to the partial widths is ambiguous [40]. See Gamma_had() for our prescription.

Returns
\(R_V^h\)

Definition at line 2373 of file StandardModel.cpp.

2374 {
2375  /* rescaled strong coupling constant */
2376  double AlsMzPi = AlsMz / M_PI;
2377  double AlsMzPi2 = AlsMzPi*AlsMzPi;
2378  double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2379  double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2380 
2381  gslpp::complex gV_sum(0.0, 0.0);
2382  gslpp::complex gV_q;
2383  for (int q = 0; q < 6; q++) {
2384  gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2385  if (q == (int) (QCD::TOP))
2386  gV_q = 0.0;
2387  gV_sum += gV_q;
2388  }
2389 
2390  // singlet vector corrections
2391  return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2392 }

◆ RVq()

double StandardModel::RVq ( const QCD::quark  q) const
protected

The radiator factor associated with the final-state QED and QCD corrections to the the vector-current interactions, \(R_V^q(M_Z^2)\).

See [58], [33], [39] and references therein.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
\(R_V^q(M_Z^2)\)

Definition at line 2116 of file StandardModel.cpp.

2117 {
2118  if (q == QCD::TOP) return 0.0;
2119 
2120  double mcMz, mbMz;
2121  mcMz = myEWSMcache->mf(getQuarks(CHARM), Mz, FULLNNLO);
2122  mbMz = myEWSMcache->mf(getQuarks(BOTTOM), Mz, FULLNNLO);
2123  //mcMz = 0.56381685; /* for debug */
2124  //mbMz = 2.8194352; /* for debug */
2125 
2126  double MtPole = mtpole;
2127 
2128  /* electric charge squared */
2129  double Qf2 = pow(quarks[q].getCharge(), 2.0);
2130 
2131  /* s = Mz^2 */
2132  double s = Mz * Mz;
2133 
2134  /* products of the charm and bottom masses at Mz */
2135  double mcMz2 = mcMz*mcMz;
2136  double mbMz2 = mbMz*mbMz;
2137  double mqMz2, mqdash4;
2138  switch (q) {
2139  case QCD::CHARM:
2140  mqMz2 = mcMz*mcMz;
2141  mqdash4 = mbMz2*mbMz2;
2142  break;
2143  case QCD::BOTTOM:
2144  mqMz2 = mbMz*mbMz;
2145  mqdash4 = mcMz2*mcMz2;
2146  break;
2147  default:
2148  mqMz2 = 0.0;
2149  mqdash4 = 0.0;
2150  break;
2151  }
2152 
2153  /* Logarithms */
2154  //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2155  double log_t = log(MtPole * MtPole / s); // the pole mass
2156  double log_c = log(mcMz2 / s);
2157  double log_b = log(mbMz2 / s);
2158  double log_q;
2159  switch (q) {
2160  case QCD::CHARM:
2161  case QCD::BOTTOM:
2162  log_q = log(mqMz2 / s);
2163  break;
2164  default:
2165  log_q = 0.0;
2166  break;
2167  }
2168 
2169  /* the active number of flavour */
2170  double nf = 5.0;
2171 
2172  /* zeta functions */
2173  double zeta2 = getMyEWSMcache()->getZeta2();
2174  double zeta3 = getMyEWSMcache()->getZeta3();
2175  //double zeta4 = getMyCache()->GetZeta4();
2176  double zeta5 = getMyEWSMcache()->getZeta5();
2177 
2178  /* massless non-singlet corrections */
2179  double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2180  double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2181  + 275.0 / 6.0 * zeta5
2182  + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2183  - 25.0 / 9.0 * zeta5) * nf
2184  + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2185  double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2186  //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2187  //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2188  //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2189 
2190  /* quadratic massive corrections */
2191  double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2192  double C21V = 12.0;
2193  double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2194  double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2195  + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2196  + 1045.0 / 27.0 * zeta5) * nf
2197  + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2198 
2199  /* quartic massive corrections */
2200  double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2201  double C40V = -6.0;
2202  double C41V = -22.0;
2203  double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2204  + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2205  double C42VL = -11.0 / 2.0 + nf / 3.0;
2206 
2207  /* power suppressed top-mass correction */
2208  //double xt = s/pow(quarks[TOP].getMass(),2.0);
2209  double xt = s / MtPole / MtPole; // the pole mass
2210  double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2211 
2212  /* rescaled strong coupling constant */
2213  double AlsMzPi = AlsMz / M_PI;
2214  double AlsMzPi2 = AlsMzPi*AlsMzPi;
2215  double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2216  double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2217 
2218  /* electromagnetic coupling at Mz */
2219  double alpMz = alphaMz();
2220 
2221  /* radiator function to the vector current */
2222  double RVf;
2223  RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2224  + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2225  + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2226  + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2227  + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2228  + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2229  + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2230  + 12.0 * mqdash4 / s / s * AlsMzPi2
2231  - mqMz2 * mqMz2 * mqMz2 / s / s / s
2232  * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2233  return RVf;
2234 }

◆ s02()

double StandardModel::s02 ( ) const

The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections.

The quantity \(s_0^2\) is defined through

\[ s_0^2 c_0^2 = \frac{\pi\,\alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2} \ \ \rightarrow\ \ s_0^2 = \frac{1}{2} \left(1 - \sqrt{1 - \frac{4\pi \alpha(M_Z^2)}{\sqrt{2}\,G_\mu M_Z^2}}\ \right)\,. \]

See [15] and [16].

Returns
\(s_0^2\)

Definition at line 930 of file StandardModel.cpp.

931 {
932  double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
933  if (tmp < 0.0)
934  throw std::runtime_error("Error in s02()");
935 
936  return ( (1.0 - sqrt(tmp)) / 2.0);
937 }

◆ SchemeToDouble()

double StandardModel::SchemeToDouble ( const std::string  scheme) const
inlineprotected

A method to convert a given scheme name in string form into a floating-point number with double precision.

This method is used in EWSM::checkSMparams() for caching the schemes used in computing \(M_W\), \(\rho_Z^f\) and \(\kappa_Z^f\).

Parameters
[in]schemescheme name that is used in computing \(M_W\), \(\rho_Z^f\) or \(\kappa_Z^f\)
Returns
a floating-point number with double precision corresponding to the given scheme name

Definition at line 2557 of file StandardModel.h.

2558  {
2559  if (scheme.compare("NORESUM") == 0)
2560  return 0.0;
2561  else if (scheme.compare("OMSI") == 0)
2562  return 1.0;
2563  else if (scheme.compare("INTERMEDIATE") == 0)
2564  return 2.0;
2565  else if (scheme.compare("OMSII") == 0)
2566  return 3.0;
2567  else if (scheme.compare("APPROXIMATEFORMULA") == 0)
2568  return 4.0;
2569  else
2570  throw std::runtime_error("EWSM::SchemeToDouble: bad scheme");
2571  }

◆ setFlag()

bool StandardModel::setFlag ( const std::string  name,
const bool  value 
)
virtual

A method to set a flag of StandardModel.

Parameters
[in]namename of a model flag
[in]valuethe boolean to be assigned to the flag specified by name
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in GeneralTHDM, GeorgiMachacek, NPSMEFT6dtopquark, NPSMEFTd6, HiggsKigen, THDM, RealWeakEFTLFV, FlavourWilsonCoefficient, NPEpsilons, HiggsChiral, RealWeakEFTCC, myModel, and myModel.

Examples
myModel.cpp.

Definition at line 378 of file StandardModel.cpp.

379 {
380  bool res = false;
381  if (name.compare("CacheInStandardModel") == 0) {
383  res = true;
384  } else if (name.compare("CacheInEWSMcache") == 0) {
386  res = true;
387  } else if (name.compare("Wolfenstein") == 0) {
388  FlagWolfenstein = value;
389  if(!FlagWolfenstein) {
390  SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
391  SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
392  SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
393  SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
394 
395  ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
396  ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
397  ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
398  ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
399  }
400  res = true;
401  } else if (name.compare("WithoutNonUniversalVC") == 0) {
403  res = true;
404  } else if (name.compare("NoApproximateGammaZ") == 0) {
405  FlagNoApproximateGammaZ = value;
406  res = true;
407  } else if (name.compare("SMAux") == 0) {
408  FlagSMAux = value;
409  res = true;
410  } else
411  res = QCD::setFlag(name, value);
412 
413  if (!res) res = SMFlavour.setFlag(name, value);
414 
415  return (res);
416 }

◆ setFlagCacheInStandardModel()

void StandardModel::setFlagCacheInStandardModel ( bool  FlagCacheInStandardModel)
inline

A set method to change the model flag CacheInStandardModel of StandardModel.

Setting CacheInStandardModel to false, the caching methods defined in the current class are not employed in numerical computations. The flag is set to true in the constructor EWSM() by default.

Parameters
[in]FlagCacheInStandardModeltrue (false) if the caching methods are turned on (off);
See also
the description of the StandardModel flags

Definition at line 695 of file StandardModel.h.

696  {
698  }

◆ setFlagNoApproximateGammaZ()

void StandardModel::setFlagNoApproximateGammaZ ( bool  FlagNoApproximateGammaZ)
inline

Definition at line 649 of file StandardModel.h.

650  {
652  }

◆ setFlagStr()

bool StandardModel::setFlagStr ( const std::string  name,
const std::string  value 
)
virtual

A method to set a flag of StandardModel.

Parameters
[in]namename of a model flag
[in]valuethe string to be assigned to the flag specified by name
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in GeneralTHDM, THDMW, and THDM.

Definition at line 418 of file StandardModel.cpp.

419 {
420  bool res = false;
421  if (name.compare("Mw") == 0) {
422  if (checkEWPOscheme(value)) {
423  FlagMw = value;
424  res = true;
425  } else
426  throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
427  + name + "=" + value);
428 
429  } else if (name.compare("RhoZ") == 0) {
430  if (checkEWPOscheme(value)) {
431  FlagRhoZ = value;
432  res = true;
433  } else
434  throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
435  + name + "=" + value);
436  } else if (name.compare("KappaZ") == 0) {
437  if (checkEWPOscheme(value)) {
438  FlagKappaZ = value;
439  res = true;
440  } else
441  throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
442  + name + "=" + value);
443  } else
444  res = QCD::setFlagStr(name, value);
445 
446  return (res);
447 }

◆ setParameter()

void StandardModel::setParameter ( const std::string  name,
const double &  value 
)
protectedvirtual

A method to set the value of a parameter of StandardModel.

Parameters
[in]namename of a model parameter
[in]valuethe value to be assigned to the parameter specified by name

Reimplemented from QCD.

Reimplemented in GeneralTHDM, THDMW, GeorgiMachacek, FlavourWilsonCoefficient_DF2, FlavourWilsonCoefficient, myModel, myModel, CMFV, NPSMEFTd6, HiggsKigen, HiggsChiral, THDM, NPEpsilons, HiggsKvgenKfgen, HiggsKvKfgen, HiggsKvKf, NPZbbbar, NPEpsilons_pureNP, NPZbbbarLinearized, NPSTU, NPSTUZbbbarLR, NPSMEFT6dtopquark, and NPDF2.

Examples
myModel.cpp.

Definition at line 231 of file StandardModel.cpp.

232 {
233  if (name.compare("Mz") == 0) {
234  Mz = value;
235  QCD::setParameter("MAls", value);
236  } else if (name.compare("AlsMz") == 0) {
237  AlsMz = value;
238  QCD::setParameter("AlsM", value);
239  } else if (name.compare("GF") == 0)
240  GF = value;
241  else if (name.compare("ale") == 0)
242  ale = value;
243  else if (name.compare("dAle5Mz") == 0)
244  dAle5Mz = value;
245  else if (name.compare("mHl") == 0)
246  mHl = value;
247  else if (name.compare("delMw") == 0)
248  delMw = value;
249  else if (name.compare("delSin2th_l") == 0)
250  delSin2th_l = value;
251  else if (name.compare("delSin2th_q") == 0)
252  delSin2th_q = value;
253  else if (name.compare("delSin2th_b") == 0)
254  delSin2th_b = value;
255  else if (name.compare("delGammaZ") == 0)
256  delGammaZ = value;
257  else if (name.compare("delsigma0H") == 0)
258  delsigma0H = value;
259  else if (name.compare("delR0l") == 0)
260  delR0l = value;
261  else if (name.compare("delR0c") == 0)
262  delR0c = value;
263  else if (name.compare("delR0b") == 0)
264  delR0b = value;
265  else if (name.compare("mneutrino_1") == 0) {
266  leptons[NEUTRINO_1].setMass(value);
267  requireYn = true;
268  } else if (name.compare("mneutrino_2") == 0) {
269  leptons[NEUTRINO_2].setMass(value);
270  requireYn = true;
271  } else if (name.compare("mneutrino_3") == 0) {
272  leptons[NEUTRINO_3].setMass(value);
273  requireYn = true;
274  } else if (name.compare("melectron") == 0) {
275  leptons[ELECTRON].setMass(value);
276  requireYe = true;
277  } else if (name.compare("mmu") == 0) {
278  leptons[MU].setMass(value);
279  requireYe = true;
280  } else if (name.compare("mtau") == 0) {
281  leptons[TAU].setMass(value);
282  requireYe = true;
283  } else if (name.compare("lambda") == 0 && FlagWolfenstein) {
284  lambda = value;
285  requireCKM = true;
286  } else if (name.compare("A") == 0 && FlagWolfenstein) {
287  A = value;
288  requireCKM = true;
289  } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
290  rhob = value;
291  requireCKM = true;
292  } else if (name.compare("etab") == 0 && FlagWolfenstein) {
293  etab = value;
294  requireCKM = true;
295  } else if (name.compare("V_us") == 0 && !FlagWolfenstein) {
296  Vus = value;
297  requireCKM = true;
298  } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
299  Vcb = value;
300  requireCKM = true;
301  } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
302  Vub = value;
303  requireCKM = true;
304  } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
305  gamma = value;
306  requireCKM = true;
307  } else if (name.compare("muw") == 0)
308  muw = value;
309  else
310  QCD::setParameter(name, value);
311 }

◆ sigma0_had()

double StandardModel::sigma0_had ( ) const
virtual

The hadronic cross section for \(e^+e^- \to Z \to \mathrm{hadrons}\) at the \(Z\)-pole, \(\sigma_h^0\).

When checkNPZff_linearized() returns true and the model flag NoApproximateGammaZ of StandardModel is set to false, this function uses the two-loop approximate formula of \(\sigma_h^0\) via EWSMApproximateFormulae::X_full_2_loop(). Otherwise, the hadronic cross section is calculated with

\[ \sigma_h^0 = \frac{12\pi}{M_Z^2}\frac{\Gamma_e\Gamma_h}{\Gamma_Z^2}\,. \]

Returns
\(\sigma_h^0\) in GeV \(^{-2}\)

Reimplemented in NPbase, NPEpsilons, and NPZbbbar.

Definition at line 1344 of file StandardModel.cpp.

1345 {
1346  if (!IsFlagNoApproximateGammaZ()){
1347 
1348  if (FlagSMAux) {
1349 
1350 // New (Testing)
1351 
1352  /* SM contribution with the approximate formula */
1353  return (myApproximateFormulae->X_full("sigmaHadron")
1354  / GeVminus2_to_nb);
1355  } else {
1356 
1357 // Original
1358 
1359  /* SM contribution with the approximate formula */
1360  return (myApproximateFormulae->X_full_2_loop("sigmaHadron")
1361  / GeVminus2_to_nb);
1362  }
1363  } else {
1364  return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1365  / Mz / Mz / Gamma_Z() / Gamma_Z());
1366  }
1367 }

◆ sin2thetaEff()

double StandardModel::sin2thetaEff ( const Particle  f) const
virtual

The effective weak mixing angle \(\sin^2\theta_{\rm eff}^{\,\ell}\) for \(Z\ell\bar{\ell}\) at the the \(Z\)-mass scale.

When checkNPZff_linearized() returns true and the model flag KappaZ of StandardModel is set to APPROXIMATEFORMULA, this function uses the two-loop approximate formula of \(\sin^2\theta_{\rm eff}^{\,\ell}\) via EWSMApproximateFormulae::sin2thetaEff(). Otherwise, the effective weak mixing angle is calculated from the coupling \(\kappa_Z^\ell\):

\[ \sin^2\theta_{\rm eff}^{\,\ell} = {\rm Re}(\kappa_Z^\ell)\,s_W^2\,. \]

Parameters
[in]fa lepton or quark
Returns
\(\sin^2\theta_{\rm eff}^{\,\ell}\)
Attention
\(\ell\) stands for both a neutrino and a charged lepton.

Reimplemented in NPEpsilons, NPbase, and NPZbbbar.

Definition at line 1195 of file StandardModel.cpp.

1196 {
1197  double Re_kappa = kappaZ_f(f).real();
1198  return ( Re_kappa * sW2());
1199 }

◆ sW2() [1/2]

double StandardModel::sW2 ( ) const

Definition at line 1005 of file StandardModel.cpp.

1006 {
1007  return ( 1.0 - cW2());
1008 }

◆ sW2() [2/2]

double StandardModel::sW2 ( const double  Mw_i) const
virtual

The square of the sine of the weak mixing angle in the on-shell scheme, denoted as \(s_W^2\).

\[ s_W^2=\sin^2{\theta_W}=1-\frac{M_W^2}{M_Z^2}. \]

Returns
\(s_W^2\)
Examples
myObservables.cpp.

Definition at line 1000 of file StandardModel.cpp.

1001 {
1002  return ( 1.0 - cW2(Mw_i));
1003 }

◆ taub()

double StandardModel::taub ( ) const
protected

Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\).

The large top-quark mass gives important corrections to the EW observables through the gauge-boson self-energies, i.e., \(\Delta\rho\), and through the \(Zb\bar{b}\) vertex. The latter contribution is parameterised by the quantity \(\tau_b\):

\[ \tau_{b} = -2\, X_t^{G_\mu} \left[ 1 - \frac{\pi}{3}\alpha_s(M^2_t) + X_t^{G_\mu} \tau^{(2)} \left( \frac{M_t^2}{m_h^2} \right) \right], \]

where the \(O(G_\mu\alpha_s m_t^2)\) term was calculated in [119], [48], [111], [55], and the \(O(G_\mu^2 m_t^4)\) term can be found in [32], [31], [120], [121].

Returns
\(\tau_b\)

Definition at line 2078 of file StandardModel.cpp.

2079 {
2080  double taub_tmp = 0.0;
2081  double Xt = myEWSMcache->Xt_GF();
2082  if (flag_order[EW1])
2083  taub_tmp += -2.0 * Xt;
2084  if (flag_order[EW1QCD1])
2085  taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2086  if (flag_order[EW1QCD2])
2087  taub_tmp += 0.0;
2088  if (flag_order[EW2])
2089  taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2090  if (flag_order[EW2QCD1])
2091  taub_tmp += 0.0;
2092  if (flag_order[EW3])
2093  taub_tmp += 0.0;
2094 
2095  return taub_tmp;
2096 }

◆ Update()

bool StandardModel::Update ( const std::map< std::string, double > &  DPars)
virtual

The update method for StandardModel.

This method updates all the model parameters with given DPars.

Parameters
[in]DParsa map of the parameters that are being updated in the Monte Carlo run (including parameters that are varied and those that are held constant)
Returns
a boolean that is true if the execution is successful

Reimplemented from QCD.

Reimplemented in GeneralTHDM, THDMW, THDM, GeorgiMachacek, RealWeakEFTLFV, FlavourWilsonCoefficient, RealWeakEFTCC, NPbase, myModel, and myModel.

Definition at line 183 of file StandardModel.cpp.

184 {
185  if (!PreUpdate()) return (false);
186 
187  UpdateError = false;
188 
189  for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
190  setParameter(it->first, it->second);
191 
192  if (UpdateError) return (false);
193 
194  if (!PostUpdate()) return (false);
195 
196  return (true);
197 }

◆ v()

double StandardModel::v ( ) const
virtual

The Higgs vacuum expectation value.

\[ v = \left(\frac{1}{\sqrt{2} G_\mu}\right)^{1/2}, \]

where \(G_\mu\) is the Fermi constant, measured through muon decays.

Returns
\(v\) in GeV

Definition at line 917 of file StandardModel.cpp.

918 {
919  return ( 1. / sqrt(sqrt(2.) * GF));
920 }

Member Data Documentation

◆ A

double StandardModel::A
protected

The CKM parameter \(A\) in the Wolfenstein parameterization.

Definition at line 2525 of file StandardModel.h.

◆ ale

double StandardModel::ale
protected

The fine-structure constant \(\alpha\).

Definition at line 2512 of file StandardModel.h.

◆ ale_cache

double StandardModel::ale_cache[10][CacheSize]
mutableprivate

Cache for \(\alpha_e\).

Definition at line 2825 of file StandardModel.h.

◆ alpha21

double StandardModel::alpha21
protected

Definition at line 2533 of file StandardModel.h.

◆ alpha31

double StandardModel::alpha31
protected

Definition at line 2533 of file StandardModel.h.

◆ als_cache

double StandardModel::als_cache[11][CacheSize]
mutableprivate

Cache for \(\alpha_s\).

Definition at line 2824 of file StandardModel.h.

◆ AlsMz

double StandardModel::AlsMz
protected

The strong coupling constant at the Z-boson mass, \(\alpha_s(M_Z)\).

Definition at line 2509 of file StandardModel.h.

◆ CacheSize

const int StandardModel::CacheSize = 5
staticprivate

Defines the depth of the cache.

Definition at line 2823 of file StandardModel.h.

◆ dAle5Mz

double StandardModel::dAle5Mz
protected

The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\).

Definition at line 2513 of file StandardModel.h.

◆ delGammaZ

double StandardModel::delGammaZ
protected

The theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\), in GeV.

Definition at line 2519 of file StandardModel.h.

◆ delMw

double StandardModel::delMw
protected

The theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\), in GeV.

Definition at line 2515 of file StandardModel.h.

◆ delR0b

double StandardModel::delR0b
protected

The theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\).

Definition at line 2523 of file StandardModel.h.

◆ delR0c

double StandardModel::delR0c
protected

The theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\).

Definition at line 2522 of file StandardModel.h.

◆ delR0l

double StandardModel::delR0l
protected

The theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\).

Definition at line 2521 of file StandardModel.h.

◆ delsigma0H

double StandardModel::delsigma0H
protected

The theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\) in nb.

Definition at line 2520 of file StandardModel.h.

◆ delSin2th_b

double StandardModel::delSin2th_b
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{b}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{b}\).

Definition at line 2518 of file StandardModel.h.

◆ delSin2th_l

double StandardModel::delSin2th_l
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{\rm lept}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{\rm lept}\).

Definition at line 2516 of file StandardModel.h.

◆ delSin2th_q

double StandardModel::delSin2th_q
protected

The theoretical uncertainty in \(\sin^2\theta_{\rm eff}^{q\not = b,t}\), denoted as \(\delta\sin^2\theta_{\rm eff}^{q\not = b,t}\).

Definition at line 2517 of file StandardModel.h.

◆ delta

double StandardModel::delta
protected

Definition at line 2533 of file StandardModel.h.

◆ DeltaAlpha_cache

double StandardModel::DeltaAlpha_cache
mutableprivate

A cache of the value of \(\Delta\alpha(M_Z^2)\).

Definition at line 2807 of file StandardModel.h.

◆ DeltaAlphaLepton_cache

double StandardModel::DeltaAlphaLepton_cache
mutableprivate

A cache of the value of \(\Delta\alpha_{\mathrm{lept}}(M_Z^2)\).

Definition at line 2806 of file StandardModel.h.

◆ etab

double StandardModel::etab
protected

The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.

Definition at line 2527 of file StandardModel.h.

◆ flag_order

bool StandardModel::flag_order[orders_EW_size]
protected

An array of internal flags controlling the inclusions of higher-order corrections.

These flags are prepared for debugging. The flags are initialized in the constructor EWSM().

Definition at line 2545 of file StandardModel.h.

◆ FlagCacheInStandardModel

bool StandardModel::FlagCacheInStandardModel
private

A flag for caching (true by default).

Definition at line 2804 of file StandardModel.h.

◆ FlagKappaZ

std::string StandardModel::FlagKappaZ
private

A string for the model flag KappaZ.

Definition at line 2796 of file StandardModel.h.

◆ FlagMw

std::string StandardModel::FlagMw
private

A string for the model flag Mw.

Definition at line 2794 of file StandardModel.h.

◆ FlagNoApproximateGammaZ

bool StandardModel::FlagNoApproximateGammaZ
private

A boolean for the model flag NoApproximateGammaZ.

Definition at line 2793 of file StandardModel.h.

◆ FlagRhoZ

std::string StandardModel::FlagRhoZ
private

A string for the model flag RhoZ.

Definition at line 2795 of file StandardModel.h.

◆ FlagSMAux

bool StandardModel::FlagSMAux
private

A boolean for the model flag SMAux.

Definition at line 2799 of file StandardModel.h.

◆ FlagWithoutNonUniversalVC

bool StandardModel::FlagWithoutNonUniversalVC
private

A boolean for the model flag WithoutNonUniversalVC.

Definition at line 2792 of file StandardModel.h.

◆ FlagWolfenstein

bool StandardModel::FlagWolfenstein
private

A boolean for the model flag Wolfenstein.

Definition at line 2797 of file StandardModel.h.

◆ gamma

double StandardModel::gamma
protected

\(\gamma \) used as an input for FlagWolfenstein = FALSE

Definition at line 2531 of file StandardModel.h.

◆ GammaW_cache

double StandardModel::GammaW_cache
mutableprivate

A cache of the value of \(\Gamma_W\).

Definition at line 2809 of file StandardModel.h.

◆ GeVminus2_to_nb

const double StandardModel::GeVminus2_to_nb = 389379.338
static

Definition at line 511 of file StandardModel.h.

◆ GF

double StandardModel::GF
protected

The Fermi constant \(G_\mu\) in \({\rm GeV}^{-2}\).

Definition at line 2511 of file StandardModel.h.

◆ iterationNo

int StandardModel::iterationNo
private

Definition at line 2819 of file StandardModel.h.

◆ kappaZ_f_cache

gslpp::complex StandardModel::kappaZ_f_cache[12]
mutableprivate

A cache of the value of \(\kappa_Z^l\).

Definition at line 2811 of file StandardModel.h.

◆ lambda

double StandardModel::lambda
protected

The CKM parameter \(\lambda\) in the Wolfenstein parameterization.

Definition at line 2524 of file StandardModel.h.

◆ leptons

Particle StandardModel::leptons[6]
protected

An array of Particle objects for the leptons.

Definition at line 2496 of file StandardModel.h.

◆ mHl

double StandardModel::mHl
protected

The Higgs mass \(m_h\) in GeV.

Definition at line 2514 of file StandardModel.h.

◆ muw

double StandardModel::muw
protected

A matching scale \(\mu_W\) around the weak scale in GeV.

Definition at line 2532 of file StandardModel.h.

◆ Mw_cache

double StandardModel::Mw_cache
mutableprivate

A cache of the value of \(M_W\).

Definition at line 2808 of file StandardModel.h.

◆ Mw_error

const double StandardModel::Mw_error = 0.00001
static

The target accuracy of the iterative calculation of the \(W\)-boson mass in units of GeV.

Definition at line 517 of file StandardModel.h.

◆ myApproximateFormulae

EWSMApproximateFormulae* StandardModel::myApproximateFormulae
private

A pointer to an object of type EWSMApproximateFormulae.

Definition at line 2789 of file StandardModel.h.

◆ myCKM

CKM StandardModel::myCKM
protected

An object of type CKM.

Definition at line 2497 of file StandardModel.h.

◆ myEWSMcache

EWSMcache* StandardModel::myEWSMcache
private

A pointer to an object of type EWSMcache.

Definition at line 2782 of file StandardModel.h.

◆ myLeptonFlavour

LeptonFlavour* StandardModel::myLeptonFlavour
private

A pointer to an object of the type LeptonFlavour.

Definition at line 2790 of file StandardModel.h.

◆ myOneLoopEW

EWSMOneLoopEW* StandardModel::myOneLoopEW
private

A pointer to an object of type EWSMOneLoopEW.

Definition at line 2783 of file StandardModel.h.

◆ myPMNS

PMNS StandardModel::myPMNS
protected

Definition at line 2498 of file StandardModel.h.

◆ myThreeLoopEW

EWSMThreeLoopEW* StandardModel::myThreeLoopEW
private

A pointer to an object of type EWSMThreeLoopEW.

Definition at line 2788 of file StandardModel.h.

◆ myThreeLoopEW2QCD

EWSMThreeLoopEW2QCD* StandardModel::myThreeLoopEW2QCD
private

A pointer to an object of type EWSMThreeLoopEW2QCD.

Definition at line 2787 of file StandardModel.h.

◆ myThreeLoopQCD

EWSMThreeLoopQCD* StandardModel::myThreeLoopQCD
private

A pointer to an object of type EWSMThreeLoopQCD.

Definition at line 2785 of file StandardModel.h.

◆ myTwoLoopEW

EWSMTwoLoopEW* StandardModel::myTwoLoopEW
private

A pointer to an object of type EWSMTwoLoopEW.

Definition at line 2786 of file StandardModel.h.

◆ myTwoLoopQCD

EWSMTwoLoopQCD* StandardModel::myTwoLoopQCD
private

A pointer to an object of type EWSMTwoLoopQCD.

Definition at line 2784 of file StandardModel.h.

◆ Mz

double StandardModel::Mz
protected

The mass of the \(Z\) boson in GeV.

Definition at line 2510 of file StandardModel.h.

◆ NSMvars

const int StandardModel::NSMvars = 26
static

The number of the model parameters in StandardModel.

Definition at line 505 of file StandardModel.h.

◆ NumSMParamsForEWPO

const int StandardModel::NumSMParamsForEWPO = 33
static

The number of the SM parameters that are relevant to the EW precision observables.

This constant is used for the cashing method.

See also
checkSMparamsForEWPO()

Definition at line 1849 of file StandardModel.h.

◆ realorder

orders StandardModel::realorder
mutableprivate

Definition at line 2826 of file StandardModel.h.

◆ requireCKM

bool StandardModel::requireCKM
protected

An internal flag to control whether the CKM matrix has to be recomputed.

Definition at line 2775 of file StandardModel.h.

◆ requireYe

bool StandardModel::requireYe
protected

An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.

Definition at line 2776 of file StandardModel.h.

◆ requireYn

bool StandardModel::requireYn
protected

An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.

Definition at line 2777 of file StandardModel.h.

◆ rhob

double StandardModel::rhob
protected

The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.

Definition at line 2526 of file StandardModel.h.

◆ rhoZ_f_cache

gslpp::complex StandardModel::rhoZ_f_cache[12]
mutableprivate

A cache of the value of \(\rho_Z^l\).

Definition at line 2810 of file StandardModel.h.

◆ s12

double StandardModel::s12
protected

Definition at line 2533 of file StandardModel.h.

◆ s13

double StandardModel::s13
protected

Definition at line 2533 of file StandardModel.h.

◆ s23

double StandardModel::s23
protected

Definition at line 2533 of file StandardModel.h.

◆ SMFlavour

Flavour StandardModel::SMFlavour
protected

An object of type Flavour.

Definition at line 2779 of file StandardModel.h.

◆ SMM

Matching<StandardModelMatching,StandardModel> StandardModel::SMM
mutableprotected

An object of type Matching.

Definition at line 2506 of file StandardModel.h.

◆ SMparamsForEWPO_cache

double StandardModel::SMparamsForEWPO_cache[NumSMParamsForEWPO]
mutableprivate

Definition at line 2805 of file StandardModel.h.

◆ SMvars

std::string StandardModel::SMvars
static
Initial value:
= {
"lambda", "A", "rhob", "etab", "Mz", "AlsMz", "GF", "ale", "dAle5Mz", "mHl",
"delMw", "delSin2th_l", "delSin2th_q", "delSin2th_b", "delGammaZ", "delsigma0H", "delR0l", "delR0c", "delR0b",
"mneutrino_1", "mneutrino_2", "mneutrino_3", "melectron", "mmu", "mtau", "muw"
}

A string array containing the labels of the model parameters in StandardModel.

Definition at line 509 of file StandardModel.h.

◆ useDeltaAlpha_cache

bool StandardModel::useDeltaAlpha_cache
mutableprivate

Definition at line 2813 of file StandardModel.h.

◆ useDeltaAlphaLepton_cache

bool StandardModel::useDeltaAlphaLepton_cache
mutableprivate

Definition at line 2812 of file StandardModel.h.

◆ useGammaW_cache

bool StandardModel::useGammaW_cache
mutableprivate

Definition at line 2815 of file StandardModel.h.

◆ useKappaZ_f_cache

bool StandardModel::useKappaZ_f_cache[12]
mutableprivate

Definition at line 2817 of file StandardModel.h.

◆ useMw_cache

bool StandardModel::useMw_cache
mutableprivate

Definition at line 2814 of file StandardModel.h.

◆ useRhoZ_f_cache

bool StandardModel::useRhoZ_f_cache[12]
mutableprivate

Definition at line 2816 of file StandardModel.h.

◆ Vcb

double StandardModel::Vcb
protected

\(\vert V_{cb} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 2529 of file StandardModel.h.

◆ Vub

double StandardModel::Vub
protected

\(\vert V_{ub} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 2530 of file StandardModel.h.

◆ Vus

double StandardModel::Vus
protected

\(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE

Definition at line 2528 of file StandardModel.h.

◆ Yd

gslpp::matrix<gslpp::complex> StandardModel::Yd
protected

The Yukawa matrix of the down-type quarks.

Definition at line 2502 of file StandardModel.h.

◆ Ye

gslpp::matrix<gslpp::complex> StandardModel::Ye
protected

The Yukawa matrix of the charged leptons.

Definition at line 2504 of file StandardModel.h.

◆ Yn

gslpp::matrix<gslpp::complex> StandardModel::Yn
protected

The Yukawa matrix of the neutrinos.

Definition at line 2503 of file StandardModel.h.

◆ Yu

gslpp::matrix<gslpp::complex> StandardModel::Yu
protected

The Yukawa matrix of the up-type quarks.

Definition at line 2501 of file StandardModel.h.


The documentation for this class was generated from the following files:
QCD::TAU
Definition: QCD.h:316
StandardModel::delR0c
double delR0c
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:2522
StandardModel::m_q
double m_q(const QCD::quark q, const double mu, const orders order=FULLNLO) const
Definition: StandardModel.h:2591
EWSMThreeLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopEW.cpp:109
EWSMThreeLoopEW::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW.cpp:19
StandardModel::Mw_cache
double Mw_cache
A cache of the value of .
Definition: StandardModel.h:2808
StandardModel::FlagWithoutNonUniversalVC
bool FlagWithoutNonUniversalVC
A boolean for the model flag WithoutNonUniversalVC.
Definition: StandardModel.h:2792
QCD::NEUTRINO_3
Definition: QCD.h:315
StandardModel::Gamma_inv
virtual double Gamma_inv() const
The invisible partial decay width of the boson, .
Definition: StandardModel.cpp:1277
StandardModel::EW2
Two-loop of .
Definition: StandardModel.h:496
StandardModel::rhoZ_f
virtual gslpp::complex rhoZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.
Definition: StandardModel.cpp:1553
StandardModel::taub
double taub() const
Top-mass corrections to the vertex, denoted by .
Definition: StandardModel.cpp:2078
StandardModel::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.
Definition: StandardModel.cpp:231
EWSMApproximateFormulae::X_full
double X_full(const std::string observable) const
, , , , , , , , , , , or .
Definition: EWSMApproximateFormulae.cpp:1165
StandardModel::v
virtual double v() const
The Higgs vacuum expectation value.
Definition: StandardModel.cpp:917
StandardModel::NSMvars
static const int NSMvars
The number of the model parameters in StandardModel.
Definition: StandardModel.h:505
StandardModel::delSin2th_q
double delSin2th_q
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:2517
StandardModel::useRhoZ_f_cache
bool useRhoZ_f_cache[12]
Definition: StandardModel.h:2816
QCD::BOTTOM
Definition: QCD.h:329
EWSMTwoLoopQCD
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopQCD.h:55
StandardModel::A
double A
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:2525
QCD::mub
double mub
The threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:929
Particle::is
bool is(std::string name_i) const
Definition: Particle.cpp:23
Particle
A class for particles.
Definition: Particle.h:26
StandardModel::ISR
Definition: StandardModel.h:482
StandardModel::rhob
double rhob
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:2526
EWSMTwoLoopEW::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopEW.cpp:115
StandardModel::gamma
double gamma
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:2531
EWSMOneLoopEW::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMOneLoopEW.cpp:19
StandardModel::realorder
orders realorder
Definition: StandardModel.h:2826
StandardModel::Ye
gslpp::matrix< gslpp::complex > Ye
The Yukawa matrix of the charged leptons.
Definition: StandardModel.h:2504
EWSMcache::setFlagCacheInEWSMcache
void setFlagCacheInEWSMcache(bool FlagCacheInEWSMcache)
A set method to change the model flag CacheInEWSMcache in StandardModel.
Definition: EWSMcache.h:83
QCD::Beta1
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:471
StandardModel::rho_GammaW
virtual double rho_GammaW(const Particle fi, const Particle fj) const
EW radiative corrections to the width of , denoted as .
Definition: StandardModel.cpp:1132
EWSMThreeLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
Definition: EWSMThreeLoopEW.cpp:70
EWSMOneLoopEW::DeltaRbar_rem
double DeltaRbar_rem(const double Mw_i) const
.
Definition: EWSMOneLoopEW.cpp:73
EWSMThreeLoopQCD::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopQCD.cpp:72
EWSMOneLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading one-loop contribution of to , denoted as .
Definition: EWSMOneLoopEW.cpp:43
EWSMThreeLoopEW2QCD
A class for three-loop corrections to the EW precision observables.
Definition: EWSMThreeLoopEW2QCD.h:34
StandardModel::Yu
gslpp::matrix< gslpp::complex > Yu
The Yukawa matrix of the up-type quarks.
Definition: StandardModel.h:2501
StandardModel::NumSMParamsForEWPO
static const int NumSMParamsForEWPO
The number of the SM parameters that are relevant to the EW precision observables.
Definition: StandardModel.h:1849
StandardModel::ale_cache
double ale_cache[10][CacheSize]
Cache for .
Definition: StandardModel.h:2825
StandardModel::QCDFSR
Definition: StandardModel.h:484
StandardModel::EW1
One-loop of .
Definition: StandardModel.h:493
StandardModel::getMyEWSMcache
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.
Definition: StandardModel.h:958
QCD::CheckFlags
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: QCD.cpp:399
PMNS::computePMNS
void computePMNS(double s12_v, double s13_v, double s23_v, double delta_v, double alpha21_v, double alpha31_v)
A set method to calculate the PMNS matrix from PMNS parameters.
Definition: PMNS.cpp:13
StandardModel::MwbarFromMw
double MwbarFromMw(const double Mw) const
A method to convert the -boson mass in the experimental/running-width scheme to that in the complex-p...
Definition: StandardModel.cpp:1102
QCD::Nf
double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:438
StandardModel::delR0l
double delR0l
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:2521
EWSMThreeLoopQCD::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopQCD.cpp:18
EWSMThreeLoopQCD
A class for three-loop corrections to the EW precision observables.
Definition: EWSMThreeLoopQCD.h:33
StandardModel::Delta_EWQCD
double Delta_EWQCD(const QCD::quark q) const
The non-factorizable EW-QCD corrections to the partial widths for , denoted as .
Definition: StandardModel.cpp:2098
CKM::computeCKMwithWolfenstein
void computeCKMwithWolfenstein(double Lambda_v, double A_v, double Rho_v, double Eta_v)
A set method to calculate the CKM matrix from Wolfenstein parameters.
Definition: CKM.cpp:13
FULLNNNLO
Definition: OrderScheme.h:39
NNNLO
Definition: OrderScheme.h:36
Matching::getObj
T & getObj()
Definition: Matching.h:14
StandardModel::computeSigmaWF
double computeSigmaWF(const double sqrt_s) const
The W fusion contribution to higgs-production cross section in the Standard Model.
Definition: StandardModel.h:2017
StandardModel::FlagSMAux
bool FlagSMAux
A boolean for the model flag SMAux.
Definition: StandardModel.h:2799
EWSMcache::getZeta3
double getZeta3() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:146
LO
Definition: OrderScheme.h:33
QCD::UP
Definition: QCD.h:324
StandardModel::GF
double GF
The Fermi constant in .
Definition: StandardModel.h:2511
StandardModel::A_f
virtual double A_f(const Particle f) const
The left-right asymmetry in at the -pole, .
Definition: StandardModel.cpp:1183
StandardModel::sigma0_had
virtual double sigma0_had() const
The hadronic cross section for at the -pole, .
Definition: StandardModel.cpp:1344
StandardModel::delMw
double delMw
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:2515
EWSMThreeLoopEW::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW.cpp:65
Model::addMissingModelParameter
void addMissingModelParameter(const std::string &missingParameterName)
Definition: Model.h:232
StandardModel::SchemeToDouble
double SchemeToDouble(const std::string scheme) const
A method to convert a given scheme name in string form into a floating-point number with double preci...
Definition: StandardModel.h:2557
StandardModel::Beta_e
double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.
Definition: StandardModel.cpp:556
StandardModel::alphaMz
double alphaMz() const
The electromagnetic coupling at the -mass scale, .
Definition: StandardModel.cpp:867
QCD::CHARM
Definition: QCD.h:326
StandardModel::DeltaAlphaL5q
double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...
Definition: StandardModel.cpp:830
QCD::TF
double TF
Definition: QCD.h:933
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
StandardModel::ComputeDeltaR_rem
void ComputeDeltaR_rem(const double Mw_i, double DeltaR_rem[orders_EW_size]) const
A method to collect computed via subclasses.
Definition: StandardModel.cpp:1053
StandardModel::mHl
double mHl
The Higgs mass in GeV.
Definition: StandardModel.h:2514
CKM::getV_cb
gslpp::complex getV_cb() const
A member for returning the value of the CKM element .
Definition: CKM.h:237
QCD::NEUTRINO_2
Definition: QCD.h:313
StandardModel::s23
double s23
Definition: StandardModel.h:2533
QCD::setParameter
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of QCD.
Definition: QCD.cpp:273
EWSMcache::getZeta5
double getZeta5() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:164
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
StandardModel::GammaW
virtual double GammaW() const
The total width of the boson, .
Definition: StandardModel.cpp:1164
gslpp::matrix
A base class for defining operations on matrices, both real and complex.
Definition: gslpp_matrix_base.h:21
StandardModel::flag_order
bool flag_order[orders_EW_size]
An array of internal flags controlling the inclusions of higher-order corrections.
Definition: StandardModel.h:2545
EWSMOneLoopEW::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMOneLoopEW.cpp:143
QCD::ELECTRON
Definition: QCD.h:312
QCD::orderToString
std::string orderToString(const orders order) const
Converts an object of the enum type "orders" to the corresponding string.
Definition: QCD.cpp:83
Particle::getIsospin
double getIsospin() const
A get method to access the particle isospin.
Definition: Particle.h:115
StandardModel::GammaW_cache
double GammaW_cache
A cache of the value of .
Definition: StandardModel.h:2809
gslpp::complex::abs2
double abs2() const
Definition: gslpp_complex.cpp:86
EWSMcache::getZeta4
double getZeta4() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:155
StandardModel::DeltaAlphaLepton_cache
double DeltaAlphaLepton_cache
A cache of the value of .
Definition: StandardModel.h:2806
EWSMOneLoopEW
A class for one-loop corrections to the EW precision observables.
Definition: EWSMOneLoopEW.h:105
StandardModel::DeltaAlpha_cache
double DeltaAlpha_cache
A cache of the value of .
Definition: StandardModel.h:2807
Model::UpdateError
bool UpdateError
A boolean set to false if update is successful.
Definition: Model.h:254
EWSMTwoLoopEW::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopEW.cpp:23
StandardModel::FlagRhoZ
std::string FlagRhoZ
A string for the model flag RhoZ.
Definition: StandardModel.h:2795
StandardModel::DeltaAlpha
double DeltaAlpha() const
The total corrections to the electromagnetic coupling at the -mass scale, denoted as .
Definition: StandardModel.cpp:855
StandardModel::SMM
Matching< StandardModelMatching, StandardModel > SMM
An object of type Matching.
Definition: StandardModel.h:2506
EWSMOneLoopEW::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMOneLoopEW.cpp:113
EWSMThreeLoopEW2QCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:29
QCD::MassOfNf
double MassOfNf(int nf) const
The Mbar mass of the heaviest quark in the theory with Nf active flavour.
Definition: QCD.cpp:620
StandardModel::cW2
virtual double cW2() const
Definition: StandardModel.cpp:994
StandardModel::myThreeLoopQCD
EWSMThreeLoopQCD * myThreeLoopQCD
A pointer to an object of type EWSMThreeLoopQCD.
Definition: StandardModel.h:2785
EWSMTwoLoopEW::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopEW.cpp:96
StandardModel::ale
double ale
The fine-structure constant .
Definition: StandardModel.h:2512
QCD::mtpole
double mtpole
The pole mass of the top quark.
Definition: QCD.h:927
EWSMTwoLoopQCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMTwoLoopQCD.cpp:44
Model::ModelParamMap
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
Definition: Model.h:262
StandardModel::myTwoLoopEW
EWSMTwoLoopEW * myTwoLoopEW
A pointer to an object of type EWSMTwoLoopEW.
Definition: StandardModel.h:2786
StandardModel::DeltaAlphaTop
double DeltaAlphaTop(const double s) const
Top-quark contribution to the electromagnetic coupling , denoted as .
Definition: StandardModel.cpp:836
EWSMTwoLoopEW::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopEW.cpp:49
StandardModel::AlsByOrder
double AlsByOrder(double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
Definition: StandardModel.cpp:597
QCD::CheckParameters
virtual bool CheckParameters(const std::map< std::string, double > &DPars)
A method to check if all the mandatory parameters for QCD have been provided in model initialization.
Definition: QCD.cpp:335
StandardModel::useDeltaAlphaLepton_cache
bool useDeltaAlphaLepton_cache
Definition: StandardModel.h:2812
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:466
QCD::Beta2
double Beta2(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:476
StandardModel::DeltaAlphaLepton
double DeltaAlphaLepton(const double s) const
Leptonic contribution to the electromagnetic coupling , denoted as .
Definition: StandardModel.cpp:802
StandardModel::IsFlagWithoutNonUniversalVC
bool IsFlagWithoutNonUniversalVC() const
A method to retrieve the model flag WithoutNonUniversalVC.
Definition: StandardModel.h:631
CKM::getLambda
double getLambda() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:78
StandardModel::RVh
double RVh() const
The singlet vector corrections to the hadronic -boson width, denoted as .
Definition: StandardModel.cpp:2373
LeptonFlavour
The parent class in LeptonFlavour for calculating all the Wilson coefficients for various Lepton Flav...
Definition: LeptonFlavour.h:26
QCD::PostUpdate
virtual bool PostUpdate()
The post-update method for QCD.
Definition: QCD.cpp:143
StandardModel::computeSigmaZF
double computeSigmaZF(const double sqrt_s) const
The Z fusion contribution to higgs-production cross section in the Standard Model.
Definition: StandardModel.h:2045
QCD::Init
virtual bool Init(const std::map< std::string, double > &DPars)
Initializes the QCD parameters found in the argument.
Definition: QCD.cpp:107
QCD::muc
double muc
The threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:930
StandardModel::delGammaZ
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
Definition: StandardModel.h:2519
StandardModel::rhoZ_f_cache
gslpp::complex rhoZ_f_cache[12]
A cache of the value of .
Definition: StandardModel.h:2810
StandardModel::c02
double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
Definition: StandardModel.cpp:939
CKM::computeCKM
void computeCKM(double Vus_v, double Vcb_v, double Vub_v, double gamma_v)
A set method to calculate the CKM matrix from CKM elements and .
Definition: CKM.cpp:55
gslpp::complex::imag
const double & imag() const
Definition: gslpp_complex.cpp:59
StandardModel::dAle5Mz
double dAle5Mz
The five-flavour hadronic contribution to the electromagnetic coupling, .
Definition: StandardModel.h:2513
StandardModel::Vub
double Vub
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:2530
Particle::getMass
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
StandardModel::useMw_cache
bool useMw_cache
Definition: StandardModel.h:2814
EWSMThreeLoopEW2QCD::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:19
StandardModel::AlsMz
double AlsMz
The strong coupling constant at the Z-boson mass, .
Definition: StandardModel.h:2509
StandardModel::sW2
double sW2() const
Definition: StandardModel.cpp:1005
CKM::computeGamma
double computeGamma() const
The CKM angle .
Definition: CKM.cpp:87
CKM::getCKM
gslpp::matrix< gslpp::complex > getCKM() const
A member for returning the CKM matrix.
Definition: CKM.h:49
EWSMApproximateFormulae::Mw
double Mw() const
The -boson mass with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:23
gslpp::complex::abs
double abs() const
Definition: gslpp_complex.cpp:81
StandardModel::EW1QCD1
Two-loop of .
Definition: StandardModel.h:494
StandardModel::PreUpdate
virtual bool PreUpdate()
The pre-update method for StandardModel.
Definition: StandardModel.cpp:172
StandardModel::Gamma_had
virtual double Gamma_had() const
The hadronic decay width of the boson, .
Definition: StandardModel.cpp:1283
StandardModel::resumRhoZ
double resumRhoZ(const double DeltaRho[orders_EW_size], const double deltaRho_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effective coupling from , and .
Definition: StandardModel.cpp:1922
StandardModel::computeSigmaggH_bb
double computeSigmaggH_bb(const double sqrt_s) const
The square of the bottom-quark contribution to the ggH cross section in the Standard Model.
Definition: StandardModel.h:1935
EWSMApproximateFormulae::sin2thetaEff_b_full
double sin2thetaEff_b_full() const
with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:1477
QCD::TOP
Definition: QCD.h:328
EWSMOneLoopEW::FZ
gslpp::complex FZ(const double s, const double Mw_i) const
The unified form factor .
Definition: EWSMOneLoopEW.cpp:1065
EWSMcache::mf
double mf(const Particle f, const double mu=0.0, const orders order=FULLNNLO) const
The mass of an SM fermion.
Definition: EWSMcache.cpp:49
QCD::zeta3
double zeta3
computed with the GSL.
Definition: QCD.h:940
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
StandardModel::RAq
double RAq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the axial-vector-c...
Definition: StandardModel.cpp:2236
Model::raiseMissingModelParameterCount
void raiseMissingModelParameterCount()
Definition: Model.h:242
EWSMApproximateFormulae::X_full_2_loop
double X_full_2_loop(const std::string observable) const
, , , , , , , , , , , or .
Definition: EWSMApproximateFormulae.cpp:974
StandardModel::SMvars
static std::string SMvars[NSMvars]
A string array containing the labels of the model parameters in StandardModel.
Definition: StandardModel.h:509
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
EWSMThreeLoopQCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading three-loop QCD contribution of to , denoted as .
Definition: EWSMThreeLoopQCD.cpp:42
EWSMOneLoopEW::rho_GammaW
double rho_GammaW(const Particle fi, const Particle fj, const double Mw_i) const
EW radiative corrections to the width of , denoted as .
Definition: EWSMOneLoopEW.cpp:190
StandardModel::myLeptonFlavour
LeptonFlavour * myLeptonFlavour
A pointer to an object of the type LeptonFlavour.
Definition: StandardModel.h:2790
sin2thetaEff
An observable class for the leptonic effective weak mixing angle at the pole. To be used for the el...
Definition: sin2thetaEff.h:29
EWSMTwoLoopQCD::DeltaAlpha_l
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopQCD.cpp:20
QCD::Beta3
double Beta3(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:484
StandardModel::EW3
Three-loop of .
Definition: StandardModel.h:498
EWSMcache
A class for cache variables used in computing radiative corrections to the EW precision observables.
Definition: EWSMcache.h:40
StandardModel::FlagMw
std::string FlagMw
A string for the model flag Mw.
Definition: StandardModel.h:2794
QCD::getMtpole
double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:588
StandardModel::lambda
double lambda
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:2524
StandardModel::MwFromMwbar
double MwFromMwbar(const double Mwbar) const
A method to convert the -boson mass in the complex-pole/fixed-width scheme to that in the experimenta...
Definition: StandardModel.cpp:1111
Particle::getCharge
double getCharge() const
A get method to access the particle charge.
Definition: Particle.h:97
QCD::zeta2
double zeta2
computed with the GSL.
Definition: QCD.h:939
EWSMTwoLoopEW
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopEW.h:57
EWSMApproximateFormulae
A class for approximate formulae of the EW precision observables.
Definition: EWSMApproximateFormulae.h:33
EWSMTwoLoopQCD::DeltaRho
double DeltaRho(const double Mw_i) const
Leading two-loop QCD contribution of to , denoted as .
Definition: EWSMTwoLoopQCD.cpp:38
StandardModel::useDeltaAlpha_cache
bool useDeltaAlpha_cache
Definition: StandardModel.h:2813
StandardModel::computeSigmaggH
double computeSigmaggH(const double sqrt_s) const
The ggH cross section in the Standard Model.
Definition: StandardModel.h:1883
StandardModel::PostUpdate
virtual bool PostUpdate()
The post-update method for StandardModel.
Definition: StandardModel.cpp:199
StandardModel::IsFlagNoApproximateGammaZ
bool IsFlagNoApproximateGammaZ() const
A method to retrieve the model flag NoApproximateGammaZ.
Definition: StandardModel.h:644
StandardModel::myOneLoopEW
EWSMOneLoopEW * myOneLoopEW
A pointer to an object of type EWSMOneLoopEW.
Definition: StandardModel.h:2783
StandardModel::Mw_error
static const double Mw_error
The target accuracy of the iterative calculation of the -boson mass in units of GeV.
Definition: StandardModel.h:517
EWSMThreeLoopEW2QCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:63
EWSMThreeLoopQCD::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopQCD.cpp:23
EWSMcache::a_f
double a_f(const Particle f) const
The tree-level axial-vector coupling for , denoted as .
Definition: EWSMcache.h:301
Model::IsModelInitialized
bool IsModelInitialized() const
A method to check if the model is initialized.
Definition: Model.h:136
NNLO
Definition: OrderScheme.h:35
StandardModel::Ale
double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
Definition: StandardModel.cpp:706
EWSMTwoLoopEW::tau_2
double tau_2() const
The function .
Definition: EWSMTwoLoopEW.cpp:151
StandardModel::s13
double s13
Definition: StandardModel.h:2533
StandardModel::Als
double Als(double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
The running QCD coupling in the scheme including QED corrections.
Definition: StandardModel.cpp:576
QCD::CacheShift
void CacheShift(double cache[][5], int n) const
A member used to manage the caching for this class.
StandardModel::checkEWPOscheme
bool checkEWPOscheme(const std::string scheme) const
A method to check if a given scheme name in string form is valid.
Definition: StandardModel.h:2578
QCD::getQuarks
Particle getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:534
StandardModel::deltaKappaZ_f
virtual gslpp::complex deltaKappaZ_f(const Particle f) const
Flavour non-universal vertex corrections to , denoted by .
Definition: StandardModel.cpp:1729
EWSMTwoLoopQCD::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopQCD.cpp:51
StandardModel::FlagKappaZ
std::string FlagKappaZ
A string for the model flag KappaZ.
Definition: StandardModel.h:2796
EWSMThreeLoopEW2QCD::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:24
EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem
double DeltaR_TwoLoopEW_rem(const double Mw_i) const
.
Definition: EWSMApproximateFormulae.cpp:252
QCD::quark
quark
An enum type for quarks.
Definition: QCD.h:323
CKM::getRhoBar
double getRhoBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:60
EWSMThreeLoopEW2QCD::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:68
StandardModel::CacheSize
static const int CacheSize
Defines the depth of the cache.
Definition: StandardModel.h:2823
QCD::BelowTh
double BelowTh(const double mu) const
The active flavour threshold below the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:429
EWSMcache::delta_f
double delta_f(const Particle f, const double Mw_i) const
.
Definition: EWSMcache.h:323
QCD::requireYd
bool requireYd
Switch for generating the Yukawa couplings to the down-type quarks.
Definition: QCD.h:922
EWSMOneLoopEW::FW
gslpp::complex FW(const double s, const Particle f, const double Mw_i) const
The unified form factor for .
Definition: EWSMOneLoopEW.cpp:1070
StandardModel::R0_f
virtual double R0_f(const Particle f) const
The ratio .
Definition: StandardModel.cpp:1369
StandardModel::AleWithInit
double AleWithInit(double mu, double alsi, double mu_i, orders order) const
Definition: StandardModel.cpp:779
StandardModel::myCKM
CKM myCKM
An object of type CKM.
Definition: StandardModel.h:2497
EWSMTwoLoopEW::DeltaRho
double DeltaRho(const double Mw_i) const
Leading two-loop contribution of to , denoted as .
Definition: EWSMTwoLoopEW.cpp:54
EWSMOneLoopEW::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMOneLoopEW.cpp:35
StandardModel::resumKappaZ
double resumKappaZ(const double DeltaRho[orders_EW_size], const double deltaKappa_rem[orders_EW_size], const double DeltaRbar_rem, const bool bool_Zbb) const
A method to compute the real part of the effetvive coupling from , and .
Definition: StandardModel.cpp:2001
PMNS::getPMNS
gslpp::matrix< gslpp::complex > getPMNS() const
A member for returning the PMNS matrix.
Definition: PMNS.h:42
StandardModel::Beta_s
double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
Definition: StandardModel.cpp:528
QCD::QCD
QCD()
Constructor.
Definition: QCD.cpp:30
Particle::setMass
void setMass(double mass)
A set method to fix the particle mass.
Definition: Particle.h:70
StandardModelMatching::updateSMParameters
void updateSMParameters()
Updates to new Standard Model parameter sets.
Definition: StandardModelMatching.cpp:105
CKM::getEtaBar
double getEtaBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:69
StandardModel::myThreeLoopEW
EWSMThreeLoopEW * myThreeLoopEW
A pointer to an object of type EWSMThreeLoopEW.
Definition: StandardModel.h:2788
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
EWSMcache::getZeta2
double getZeta2() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:137
StandardModel::myEWSMcache
EWSMcache * myEWSMcache
A pointer to an object of type EWSMcache.
Definition: StandardModel.h:2782
StandardModel::s12
double s12
Definition: StandardModel.h:2533
QCD::PreUpdate
virtual bool PreUpdate()
The pre-update method for QCD.
Definition: QCD.cpp:116
StandardModel::resumMw
double resumMw(const double Mw_i, const double DeltaRho[orders_EW_size], const double DeltaR_rem[orders_EW_size]) const
A method to compute the -boson mass from and .
Definition: StandardModel.cpp:1835
StandardModel::computeYukawas
virtual void computeYukawas()
The method to compute the Yukawa matrices.
Definition: StandardModel.cpp:345
EWSMcache::Xt_GF
double Xt_GF() const
The quantity with the coupling .
Definition: EWSMcache.h:343
EWSMApproximateFormulae::sin2thetaEff_l_full
double sin2thetaEff_l_full() const
with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:1528
StandardModel::computeCKM
virtual void computeCKM()
The method to compute the CKM matrix.
Definition: StandardModel.cpp:325
StandardModel::iterationNo
int iterationNo
Definition: StandardModel.h:2819
Flavour::setSMupdated
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:281
StandardModel::Weak
Definition: StandardModel.h:480
StandardModel::RVq
double RVq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the vector-current...
Definition: StandardModel.cpp:2116
EWSMThreeLoopEW
A class for three-loop corrections to the EW precision observables.
Definition: EWSMThreeLoopEW.h:35
StandardModel::alpha31
double alpha31
Definition: StandardModel.h:2533
StandardModel::gV_f
virtual gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.
Definition: StandardModel.cpp:1542
StandardModel::Mw_tree
virtual double Mw_tree() const
The tree-level mass of the boson, .
Definition: StandardModel.cpp:925
StandardModel::s02
double s02() const
The square of the sine of the weak mixing angle defined without weak radiative corrections.
Definition: StandardModel.cpp:930
Flavour::setFlag
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:26
StandardModel::Yn
gslpp::matrix< gslpp::complex > Yn
The Yukawa matrix of the neutrinos.
Definition: StandardModel.h:2503
StandardModel::requireCKM
bool requireCKM
An internal flag to control whether the CKM matrix has to be recomputed.
Definition: StandardModel.h:2775
StandardModel::computeSigmaVBF
double computeSigmaVBF(const double sqrt_s) const
The VBF cross section in the Standard Model.
Definition: StandardModel.h:1989
EWSMOneLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMOneLoopEW.cpp:49
StandardModel::useKappaZ_f_cache
bool useKappaZ_f_cache[12]
Definition: StandardModel.h:2817
EWSMThreeLoopEW::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW.cpp:114
Mw
An observable class for the -boson mass.
Definition: Mw.h:22
EWSMThreeLoopEW::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW.cpp:120
StandardModel::computeSigmaggH_tt
double computeSigmaggH_tt(const double sqrt_s) const
The square of the top-quark contribution to the ggH cross section in the Standard Model.
Definition: StandardModel.h:1910
QCD::Mrun
double Mrun(const double mu, const double m, const orders order=FULLNNLO) const
Computes a running quark mass from .
Definition: QCD.cpp:1064
EWSMThreeLoopQCD::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMThreeLoopQCD.cpp:48
StandardModel::SMFlavour
Flavour SMFlavour
An object of type Flavour.
Definition: StandardModel.h:2779
QCD::STRANGE
Definition: QCD.h:327
StandardModel::AlsWithInit
double AlsWithInit(double mu, double alsi, double mu_i, orders order, bool qed_flag) const
Definition: StandardModel.cpp:663
CKM::getV_us
gslpp::complex getV_us() const
A member for returning the value of the CKM element .
Definition: CKM.h:201
QCD::requireYu
bool requireYu
Switch for generating the Yukawa couplings to the up-type quarks.
Definition: QCD.h:921
gslpp::complex::real
const double & real() const
Definition: gslpp_complex.cpp:53
QCD::FullOrder
orders FullOrder(orders order) const
Return the FULLORDER enum corresponding to order.
Definition: QCD.cpp:603
StandardModel::als_cache
double als_cache[11][CacheSize]
Cache for .
Definition: StandardModel.h:2824
CKM::getV_ub
gslpp::complex getV_ub() const
A member for returning the value of the CKM element .
Definition: CKM.h:210
EWSMThreeLoopEW2QCD::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopEW2QCD.cpp:74
StandardModel::leptons
Particle leptons[6]
An array of Particle objects for the leptons.
Definition: StandardModel.h:2496
StandardModel::GammaZ
virtual double GammaZ(const Particle f) const
The partial decay width, .
Definition: StandardModel.cpp:1201
Particle::getIndex
int getIndex() const
Definition: Particle.h:160
StandardModel::etab
double etab
The CKM parameter in the Wolfenstein parameterization.
Definition: StandardModel.h:2527
CKM::getA
double getA() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:87
Model::isModelSUSY
bool isModelSUSY() const
Definition: Model.h:182
QCD::setFlagStr
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of QCD.
Definition: QCD.cpp:393
StandardModel::requireYe
bool requireYe
An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.
Definition: StandardModel.h:2776
Model::name
std::string name
The name of the model.
Definition: Model.h:267
StandardModel::Mz
double Mz
The mass of the boson in GeV.
Definition: StandardModel.h:2510
QCD::AboveTh
double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:420
StandardModel::myPMNS
PMNS myPMNS
Definition: StandardModel.h:2498
StandardModel::kappaZ_f_cache
gslpp::complex kappaZ_f_cache[12]
A cache of the value of .
Definition: StandardModel.h:2811
QCD::NfThresholdCorrections
double NfThresholdCorrections(double mu, double M, double als, int nf, orders order) const
Threshold corrections in matching with from eq. (34) of hep-ph/0512060.
Definition: QCD.cpp:583
QCD::Nc
double Nc
The number of colours.
Definition: QCD.h:932
StandardModel::NUMofLEP2RCs
Definition: StandardModel.h:485
StandardModel::EW2QCD1
Three-loop of .
Definition: StandardModel.h:497
NLO
Definition: OrderScheme.h:34
StandardModel::FlagCacheInStandardModel
bool FlagCacheInStandardModel
A flag for caching (true by default).
Definition: StandardModel.h:2804
StandardModel::ComputeDeltaRho
void ComputeDeltaRho(const double Mw_i, double DeltaRho[orders_EW_size]) const
A method to collect computed via subclasses.
Definition: StandardModel.cpp:1024
StandardModel::Mw
virtual double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Definition: StandardModel.cpp:944
StandardModel::myApproximateFormulae
EWSMApproximateFormulae * myApproximateFormulae
A pointer to an object of type EWSMApproximateFormulae.
Definition: StandardModel.h:2789
StandardModel::Mzbar
double Mzbar() const
The -boson mass in the complex-pole/fixed-width scheme.
Definition: StandardModel.cpp:1085
StandardModel::gA_f
virtual gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
Definition: StandardModel.cpp:1548
EWSMTwoLoopQCD::deltaKappa_rem_f
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMTwoLoopQCD.cpp:58
StandardModel::requireYn
bool requireYn
An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.
Definition: StandardModel.h:2777
StandardModel::delR0b
double delR0b
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:2523
StandardModel::GeVminus2_to_nb
static const double GeVminus2_to_nb
Definition: StandardModel.h:511
StandardModel::Vus
double Vus
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:2528
StandardModel::myThreeLoopEW2QCD
EWSMThreeLoopEW2QCD * myThreeLoopEW2QCD
A pointer to an object of type EWSMThreeLoopEW2QCD.
Definition: StandardModel.h:2787
StandardModel::useGammaW_cache
bool useGammaW_cache
Definition: StandardModel.h:2815
StandardModel::delSin2th_l
double delSin2th_l
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:2516
QCD::CA
double CA
Definition: QCD.h:933
StandardModel::QEDFSR
Definition: StandardModel.h:483
QCD::AlsWithInit
double AlsWithInit(const double mu, const double alsi, const double mu_i, const orders order) const
Computes the running strong coupling from in the scheme, where it is forbidden to across a flavour...
Definition: QCD.cpp:498
StandardModel::SMparamsForEWPO_cache
double SMparamsForEWPO_cache[NumSMParamsForEWPO]
Definition: StandardModel.h:2805
QCD::CF
double CF
Definition: QCD.h:933
EWSMcache::alsMt
double alsMt() const
The strong coupling at NNLO.
Definition: EWSMcache.h:378
FULLNNLO
Definition: OrderScheme.h:38
StandardModel::Gamma_Z
virtual double Gamma_Z() const
The total decay width of the boson, .
Definition: StandardModel.cpp:1318
StandardModel::delsigma0H
double delsigma0H
The theoretical uncertainty in , denoted as in nb.
Definition: StandardModel.h:2520
StandardModel::setFlagCacheInStandardModel
void setFlagCacheInStandardModel(bool FlagCacheInStandardModel)
A set method to change the model flag CacheInStandardModel of StandardModel.
Definition: StandardModel.h:695
QCD::DOWN
Definition: QCD.h:325
StandardModel::kappaZ_f
virtual gslpp::complex kappaZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.
Definition: StandardModel.cpp:1618
QCD::setFlag
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of QCD.
Definition: QCD.cpp:380
StandardModel::muw
double muw
A matching scale around the weak scale in GeV.
Definition: StandardModel.h:2532
StandardModel::Yd
gslpp::matrix< gslpp::complex > Yd
The Yukawa matrix of the down-type quarks.
Definition: StandardModel.h:2502
StandardModel::EW1QCD2
Three-loop of .
Definition: StandardModel.h:495
FULLNLO
Definition: OrderScheme.h:37
EWSMcache::v_f
double v_f(const Particle f, const double Mw_i) const
The tree-level vector coupling for , denoted as .
Definition: EWSMcache.h:290
StandardModel::FlagWolfenstein
bool FlagWolfenstein
A boolean for the model flag Wolfenstein.
Definition: StandardModel.h:2797
QCD::NEUTRINO_1
Definition: QCD.h:311
StandardModel::checkSMparamsForEWPO
bool checkSMparamsForEWPO()
A method to check whether the parameters relevant to the EWPO are updated.
Definition: StandardModel.cpp:458
QCD::quarks
Particle quarks[6]
The vector of all SM quarks.
Definition: QCD.h:934
StandardModel::WeakBox
Definition: StandardModel.h:481
Model::setModelInitialized
void setModelInitialized(bool ModelInitialized)
A set method to fix the failure or success of the initialization of the model.
Definition: Model.h:145
EWSMTwoLoopQCD::DeltaAlpha_t
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
Definition: EWSMTwoLoopQCD.cpp:25
StandardModel::orders_EW_size
The size of this enum.
Definition: StandardModel.h:499
StandardModel::myTwoLoopQCD
EWSMTwoLoopQCD * myTwoLoopQCD
A pointer to an object of type EWSMTwoLoopQCD.
Definition: StandardModel.h:2784
StandardModel::Vcb
double Vcb
used as an input for FlagWolfenstein = FALSE
Definition: StandardModel.h:2529
EWSMTwoLoopEW::DeltaR_rem
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
Definition: EWSMTwoLoopEW.cpp:81
QCD::MU
Definition: QCD.h:314
StandardModel::delSin2th_b
double delSin2th_b
The theoretical uncertainty in , denoted as .
Definition: StandardModel.h:2518
QCD::mut
double mut
The threshold between six- and five-flavour theory in GeV.
Definition: QCD.h:928
EWSMThreeLoopQCD::deltaRho_rem_f
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
Definition: EWSMThreeLoopQCD.cpp:66
StandardModel::computeSigmaggH_tb
double computeSigmaggH_tb(const double sqrt_s) const
The top-bottom interference contribution to the ggH cross section in the Standard Model.
Definition: StandardModel.h:1960
StandardModel::delta
double delta
Definition: StandardModel.h:2533
Particle::getName
std::string getName() const
Definition: Particle.h:147
StandardModel::alpha21
double alpha21
Definition: StandardModel.h:2533
EWSMApproximateFormulae::sin2thetaEff
double sin2thetaEff(const Particle p) const
Definition: EWSMApproximateFormulae.h:68
StandardModel::FlagNoApproximateGammaZ
bool FlagNoApproximateGammaZ
A boolean for the model flag NoApproximateGammaZ.
Definition: StandardModel.h:2793
StandardModel::orders_EW
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...
Definition: StandardModel.h:492