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.
Mw_inp \(M_W\) The mass of the \(W\) boson in GeV. Only used if the flag MWinput is TRUE.
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\).
delGammaWlv \(\delta\,\Gamma_W_{l\nu}\) The theoretical uncertainty in \(\Gamma_W_{l\nu}\). RELATIVE uncertainty.
delGammaWqq \(\delta\,\Gamma_W_{qq}\) The theoretical uncertainty in \(\Gamma_W_{qq}\). RELATIVE uncertainty.
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, delGammaWlv, delGammaWqq 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, the ratios \(R_l^0\), \(R_c^0\) and \(R_b^0\), and the \(W\)-boson partial decay widths into leptons and quarks, 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.
UseVud FALSE / TRUE This flag controls the way the CKM matrix is parameterized. If set to FALSE, with Wolfenstein FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). If set to TRUE, with Wolfenstein FALSE, the CKM matrix is computed starting from \(\vert V_{ud} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). If Wolfenstein is set to TRUE, this flag has no effect. The default value is FALSE.
FixMuwMut FALSE / TRUE This flag controls the way the weak matching scale and the top quark decoupling scale are varied. If set to FALSE, the \(\mu_W\) parameter is introduced to float the matching scale independently of the top decoupling scale \(\mu_t\). If set to TRUE, the \(\mu_t\) parameter is fixed to \(\mu_W / M_W * \m_t\) Notice that in this case the \(\mu_t\) parameter defined in QCD becomes irrelevant, therefore it is advisable to fix it to a constant in the configuration file The default value is FALSE.
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.
MWinput TRUE / FALSE This auxiliary flag is used for setting the W mass as a SM input, instead of the electromagnetic constant parameter dAle5Mz. The default value is FALSE.
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 [Sirlin:1980nh], [Marciano:1980pb], [Bardin:1980fe], [Bardin:1981sv] 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.

Definition at line 521 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 , D_S , B_D , B_P , B_S , B_C , PHI , K_star , K_star_P , K_S , 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 const 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 const double AFB (const Particle f) const
 
gslpp::complex AH_f (const double tau) const
 Fermionic loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings. More...
 
gslpp::complex AH_W (const double tau) const
 W loop function entering in the calculation of the effective \(H\gamma\gamma\) coupling. More...
 
gslpp::complex AHZga_f (const double tau, const double lambda) const
 Fermionic loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
gslpp::complex AHZga_W (const double tau, const double lambda) const
 W loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
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...
 
const double ale_OS (const double mu, orders order=FULLNLO) const
 The running electromagnetic coupling \(\alpha(\mu)\) in the on-shell scheme. More...
 
virtual const double alphaMz () const
 The electromagnetic coupling at the \(Z\)-mass scale, \(\alpha(M_Z^2)=\alpha/(1-\Delta\alpha(M_Z^2))\). More...
 
virtual const double alrmoller (const double q2, const double y) const
 The computation of the parity violating asymmetry in Moller scattering. More...
 
const double Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double Als (const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
 The running QCD coupling \(\alpha(\mu)\) in the \(\overline{MS}\) scheme including QED corrections. More...
 
const double Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
 
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...
 
virtual const double amuon () const
 The computation of the anomalous magnetic moment of the muon \(a_\mu=(g_\mu-2)/2\). More...
 
const double Beta_e (int nm, unsigned int nf) const
 QED beta function coefficients - eq. (36) hep-ph/0512066. More...
 
const double Beta_s (int nm, unsigned int nf) const
 QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066. More...
 
virtual const double BrHtobb () const
 The Br \((H\to b \bar{b})\) in the Standard Model. More...
 
virtual const double BrHtocc () const
 The Br \((H\to c \bar{c})\) in the Standard Model. More...
 
virtual const double BrHtogaga () const
 The Br \((H\to \gamma \gamma)\) in the Standard Model. More...
 
virtual const double BrHtogg () const
 The Br \(\(H\to gg)\) in the Standard Model. More...
 
virtual const double BrHtomumu () const
 The Br \((H\to \mu^+ \mu^-)\) in the Standard Model. More...
 
virtual const double BrHtoss () const
 The Br \((H\to s \bar{s})\) in the Standard Model. More...
 
virtual const double BrHtotautau () const
 The Br \((H\to \tau^+ \tau^-)\) in the Standard Model. More...
 
virtual const double BrHtoWWstar () const
 The Br \((H\to W W^*)\) in the Standard Model. More...
 
virtual const double BrHtoZga () const
 The Br \((H\to Z \gamma)\) in the Standard Model. More...
 
virtual const double BrHtoZZstar () const
 The Br \((H\to Z Z^*)\) in the Standard Model. More...
 
virtual const double BrW (const Particle fi, const Particle fj) const
 The branching ratio of the \(W\) boson decaying into a SM fermion pair, \(Br(W\to f_i f_j)\). More...
 
const 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...
 
const double computeBrHto4f () const
 The Br \((H\to 4f)\) in the Standard Model. More...
 
const double computeBrHto4l2 () const
 The Br \((H\to 4l)\) \(l=e,\mu\) in the Standard Model. More...
 
const double computeBrHto4l3 () const
 The Br \((H\to 4l)\) \(l=e,\mu,\tau\) in the Standard Model. More...
 
const double computeBrHto4q () const
 The Br \((H\to 4q)\) in the Standard Model. More...
 
const double computeBrHto4v () const
 The Br \((H\to 4\nu)\) in the Standard Model. More...
 
const double computeBrHtobb () const
 The Br \((H\to bb)\) in the Standard Model. More...
 
const double computeBrHtocc () const
 The Br \((H\to cc)\) in the Standard Model. More...
 
const double computeBrHtoevmuv () const
 The Br \((H\to e \nu \mu \nu)\) in the Standard Model. More...
 
const double computeBrHtogaga () const
 The Br \((H\to\gamma\gamma)\) in the Standard Model. More...
 
const double computeBrHtogg () const
 The Br \((H\to gg)\) in the Standard Model. More...
 
const double computeBrHtollvv2 () const
 The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model. More...
 
const double computeBrHtollvv3 () const
 The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model. More...
 
const double computeBrHtomumu () const
 The Br \((H\to \mu\mu)\) in the Standard Model. More...
 
const double computeBrHtoss () const
 The Br \((H\to ss)\) in the Standard Model. More...
 
const double computeBrHtotautau () const
 The Br \((H\to \tau\tau)\) in the Standard Model. More...
 
const double computeBrHtoWW () const
 The Br \((H\to WW)\) in the Standard Model. More...
 
const double computeBrHtoZga () const
 The Br \((H\to Z\gamma)\) in the Standard Model. More...
 
const double computeBrHtoZZ () const
 The Br \((H\to ZZ)\) 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...
 
const double computeGammaHgaga_tt () const
 The top loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgaga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgaga_WW () const
 The \(W\) loop contribution to \(H\to\gamma\gamma\) in the Standard Model. More...
 
const double computeGammaHgg_bb () const
 The bottom loop contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHgg_tb () const
 The top-bottom interference contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHgg_tt () const
 The top loop contribution to \(H\to gg\) in the Standard Model. More...
 
const double computeGammaHTotal () const
 The Higgs total width in the Standard Model. More...
 
const double computeGammaHZga_tt () const
 The top loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
const double computeGammaHZga_tW () const
 The mixed \(t-W\) loop contribution to \(H\to Z\gamma\) in the Standard Model. More...
 
const 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. [Heinemeyer:2013tqa]. More...
 
const double computeSigmabbH (const double sqrt_s) const
 The bbH production cross section in the Standard Model. More...
 
const double computeSigmaggH (const double sqrt_s) const
 The ggH cross section in the Standard Model. More...
 
const 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...
 
const double computeSigmaggH_tb (const double sqrt_s) const
 The top-bottom interference contribution to the ggH cross section in the Standard Model. More...
 
const 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...
 
const double computeSigmatHq (const double sqrt_s) const
 The tHq production cross section in the Standard Model. More...
 
const double computeSigmattH (const double sqrt_s) const
 The ttH production cross section in the Standard Model. More...
 
const double computeSigmaVBF (const double sqrt_s) const
 The VBF cross section in the Standard Model. More...
 
const double computeSigmaWF (const double sqrt_s) const
 The W fusion contribution \(\sigma_{WF}\) to higgs-production cross section in the Standard Model. More...
 
const double computeSigmaWH (const double sqrt_s) const
 The WH production cross section in the Standard Model. More...
 
const double computeSigmaZF (const double sqrt_s) const
 The Z fusion contribution \(\sigma_{ZF}\) to higgs-production cross section in the Standard Model. More...
 
const double computeSigmaZH (const double sqrt_s) const
 The ZH production cross section in the Standard Model. More...
 
const 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 const double cW2 () const
 
virtual const 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...
 
virtual const double Dalpha5hMz () const
 The 5-quark contribution to the running of the em constant to the \(Z\) pole. \(\Delta\alpha_{had}^{(5)}(M_Z)\). More...
 
const double DeltaAlpha () const
 The total corrections to the electromagnetic coupling \(\alpha\) at the \(Z\)-mass scale, denoted as \(\Delta\alpha(M_Z^2)\). More...
 
const 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...
 
const double DeltaAlphaLepton (const double s) const
 Leptonic contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{lept}}(s)\). More...
 
const double DeltaAlphaTop (const double s) const
 Top-quark contribution to the electromagnetic coupling \(\alpha\), denoted as \(\Delta\alpha_{\mathrm{top}}(s)\). More...
 
virtual const 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 const double DeltaR () const
 The SM prediction for \(\Delta r\) derived from that for the \(W\) boson mass. More...
 
virtual const double DeltaRbar () const
 The SM prediction for \(\Delta \overline{r}\) derived from that for the \(W\)-boson mass. More...
 
virtual const 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 const double eeffAFBbottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBcharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBe (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBetsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBmu (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBstrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffAFBtau (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRbottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRcharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRelectron (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRelectrontsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRmuon (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRstrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffRtau (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigma (const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
 
virtual const double eeffsigmaBottom (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaCharm (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaE (const double pol_e, const double pol_p, const double s) const
 
const double eeffsigmaEbin (const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const
 
virtual const double eeffsigmaEtsub (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaHadron (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaMu (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaStrange (const double pol_e, const double pol_p, const double s) const
 
virtual const double eeffsigmaTau (const double pol_e, const double pol_p, const double s) const
 
virtual const double epsilon1 () const
 The SM contribution to the epsilon parameter \(\varepsilon_1\). More...
 
virtual const double epsilon2 () const
 The SM contribution to the epsilon parameter \(\varepsilon_2\). More...
 
virtual const double epsilon3 () const
 The SM contribution to the epsilon parameter \(\varepsilon_3\). More...
 
virtual const double epsilonb () const
 The SM contribution to the epsilon parameter \(\varepsilon_b\). More...
 
gslpp::complex f_triangle (const double tau) const
 Loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings. More...
 
gslpp::complex g_triangle (const double tau) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
virtual const gslpp::complex gA_f (const Particle f) const
 The effective leptonic neutral-current axial-vector coupling \(g_A^l\) in the SM. More...
 
virtual const double Gamma_had () const
 The hadronic decay width of the \(Z\) boson, \(\Gamma_{h}\). More...
 
virtual const double Gamma_inv () const
 The invisible partial decay width of the \(Z\) boson, \(\Gamma_{\mathrm{inv}}\). More...
 
virtual const double Gamma_muon () const
 The computation of the muon decay. More...
 
virtual const double Gamma_tau_l_nunu (const Particle l) const
 The computation of the leptonic tau decays. More...
 
virtual const double Gamma_Z () const
 The total decay width of the \(Z\) boson, \(\Gamma_Z\). More...
 
virtual const double GammaHtobb () const
 The \(\Gamma(H\to b \bar{b})\) in the Standard Model. More...
 
virtual const double GammaHtocc () const
 The \(\Gamma(H\to c \bar{c})\) in the Standard Model. More...
 
virtual const double GammaHtogaga () const
 The \(\Gamma(H\to \gamma \gamma)\) in the Standard Model. More...
 
virtual const double GammaHtogg () const
 The \(\Gamma(H\to gg)\) in the Standard Model. More...
 
virtual const double GammaHtomumu () const
 The \(\Gamma(H\to \mu^+ \mu^-)\) in the Standard Model. More...
 
virtual const double GammaHtoss () const
 The \(\Gamma(H\to s \bar{s})\) in the Standard Model. More...
 
virtual const double GammaHTot () const
 The total Higgs width \(\Gamma(H)\) in the Standard Model. More...
 
virtual const double GammaHtotautau () const
 The \(\Gamma(H\to \tau^+ \tau^-)\) in the Standard Model. More...
 
virtual const double GammaHtoWWstar () const
 The \(\Gamma(H\to W W^*)\) in the Standard Model. More...
 
virtual const double GammaHtoZga () const
 The \(\Gamma(H\to Z \gamma)\) in the Standard Model. More...
 
virtual const double GammaHtoZZstar () const
 The \(\Gamma(H\to Z Z^*)\) in the Standard Model. More...
 
virtual const double GammaW () const
 The total width of the \(W\) boson, \(\Gamma_W\). More...
 
virtual const 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 const double GammaZ (const Particle f) const
 The \(Z\to \ell\bar{\ell}\) partial decay width, \(\Gamma_\ell\). More...
 
virtual const double gAnue () const
 The effective (muon) neutrino-electron axial-vector coupling: gAnue. More...
 
const double getAle () const
 A get method to retrieve the fine-structure constant \(\alpha\). More...
 
const double getAlsMz () const
 A get method to access the value of \(\alpha_s(M_Z)\). More...
 
virtual const double getCBd () const
 The ratio of the absolute value of the $B_d$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCBs () const
 The ratio of the absolute value of the $B_s$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCCC1 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC2 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC3 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC4 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCCC5 () const
 A virtual implementation for the RealWeakEFTCC class. More...
 
virtual const double getCDMK () const
 The ratio of the real part of the $K$ mixing amplitude over the Standard Model value. More...
 
virtual const double getCepsK () const
 The ratio of the imaginary part of the $K$ mixing amplitude over the Standard Model value. More...
 
const CKMgetCKM () const
 A get method to retrieve the member object of type CKM. More...
 
const 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...
 
const double getDelGammaWlv () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\). More...
 
const double getDelGammaWqq () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\). More...
 
const double getDelGammaZ () const
 A get method to retrieve the theoretical uncertainty in \(\Gamma_Z\), denoted as \(\delta\,\Gamma_Z\). More...
 
const double getDelMw () const
 A get method to retrieve the theoretical uncertainty in \(M_W\), denoted as \(\delta\,M_W\). More...
 
const double getDelR0b () const
 A get method to retrieve the theoretical uncertainty in \(R_b^0\), denoted as \(\delta\,R_b^0\). More...
 
const double getDelR0c () const
 A get method to retrieve the theoretical uncertainty in \(R_c^0\), denoted as \(\delta\,R_c^0\). More...
 
const double getDelR0l () const
 A get method to retrieve the theoretical uncertainty in \(R_l^0\), denoted as \(\delta\,R_l^0\). More...
 
const double getDelSigma0H () const
 A get method to retrieve the theoretical uncertainty in \(\sigma_{Hadron}^0\), denoted as \(\delta\,\sigma_{Hadron}^0\). More...
 
const 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...
 
const 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...
 
const 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...
 
const std::string getFlagKappaZ () const
 A method to retrieve the model flag KappaZ. More...
 
const std::string getFlagMw () const
 A method to retrieve the model flag Mw. More...
 
const std::string getFlagRhoZ () const
 A method to retrieve the model flag RhoZ. More...
 
const FlavourgetFlavour () const
 
const double getGF () const
 A get method to retrieve the Fermi constant \(G_\mu\). More...
 
const int getIterationNo () const
 
const ParticlegetLeptons (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 const double getMHl () const
 A get method to retrieve the Higgs mass \(m_h\). More...
 
virtual const double getmq (const QCD::quark q, const double mu) const
 The MSbar running quark mass computed at NLO. More...
 
const double getMuw () const
 A get method to retrieve the matching scale \(\mu_W\) around the weak scale. More...
 
const double getMw () const
 A get method to access the input value of the mass of the \(W\) boson \(M_W\). 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
 
EWSMTwoFermionsLEP2getMyTwoFermionsLEP2 () const
 A get method to retrieve the member pointer of type EWSMTwoFermionsLEP2. More...
 
EWSMTwoLoopEWgetMyTwoLoopEW () const
 
EWSMTwoLoopQCDgetMyTwoLoopQCD () const
 
const double getMz () const
 A get method to access the mass of the \(Z\) boson \(M_Z\). More...
 
virtual const double getPhiBd () const
 Half the relative phase of the $B_d$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual const double getPhiBs () const
 Half the relative phase of the $B_s$ mixing amplitude w.r.t. the Standard Model one. More...
 
virtual const StandardModelgetTrueSM () const
 
const gslpp::matrix< gslpp::complex > getUPMNS () const
 A get method to retrieve the object of the PMNS matrix. More...
 
const gslpp::matrix< gslpp::complex > getVCKM () const
 A get method to retrieve the CKM matrix. More...
 
const gslpp::matrix< gslpp::complex > & getYd () const
 A get method to retrieve the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
const gslpp::matrix< gslpp::complex > & getYe () const
 A get method to retrieve the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
const gslpp::matrix< gslpp::complex > & getYn () const
 A get method to retrieve the Yukawa matrix of the neutrinos, \(Y_\nu\). More...
 
const gslpp::matrix< gslpp::complex > & getYu () const
 A get method to retrieve the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual const double gLnuN2 () const
 The effective neutrino nucleon LH coupling: gLnuN2. More...
 
virtual const double gRnuN2 () const
 The effective neutrino nucleon RH coupling: gRnuN2. More...
 
virtual const gslpp::complex gV_f (const Particle f) const
 The effective leptonic neutral-current vector coupling \(g_V^l\) in the SM. More...
 
virtual const double gVnue () const
 The effective (muon) neutrino-electron vector coupling: gVnue. More...
 
gslpp::complex I_triangle_1 (const double tau, const double lambda) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. More...
 
gslpp::complex I_triangle_2 (const double tau, const double lambda) const
 Loop function entering in the calculation of the effective \(HZ\gamma\) coupling. 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...
 
const double intMLL2eeeeus2 (const double s, const double t0, const double t1) const
 
const double intMLR2eeeets2 (const double s, const double t0, const double t1) const
 
const double intMLRtilde2eeeest2 (const double s, const double t0, const double t1) const
 
const double intMRR2eeeeus2 (const double s, const double t0, const double t1) const
 
const bool IsFlagNoApproximateGammaZ () const
 A method to retrieve the model flag NoApproximateGammaZ. More...
 
const bool IsFlagWithoutNonUniversalVC () const
 A method to retrieve the model flag WithoutNonUniversalVC. More...
 
const bool isSMSuccess () const
 A get method to retrieve the success status of the Standard Model update and matching. More...
 
virtual const gslpp::complex kappaZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\kappa_Z^l\) in the SM. More...
 
virtual const double LEP2AFBbottom (const double s) const
 
virtual const double LEP2AFBcharm (const double s) const
 
virtual const double LEP2AFBe (const double s) const
 
virtual const double LEP2AFBmu (const double s) const
 
virtual const double LEP2AFBtau (const double s) const
 
virtual const double LEP2dsigmadcosBinE (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosBinMu (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosBinTau (const double s, const double cos, const double cosmin, const double cosmax) const
 
virtual const double LEP2dsigmadcosE (const double s, const double cos) const
 
virtual const double LEP2dsigmadcosMu (const double s, const double cos) const
 
virtual const double LEP2dsigmadcosTau (const double s, const double cos) const
 
virtual const double LEP2Rbottom (const double s) const
 
virtual const double LEP2Rcharm (const double s) const
 
virtual const double LEP2sigmaBottom (const double s) const
 
virtual const double LEP2sigmaCharm (const double s) const
 
virtual const double LEP2sigmaE (const double s) const
 
virtual const double LEP2sigmaHadron (const double s) const
 
virtual const double LEP2sigmaMu (const double s) const
 
virtual const double LEP2sigmaTau (const double s) const
 
const double MLL2eeff (const Particle f, const double s, const double t) const
 
const double MLR2eeff (const Particle f, const double s) const
 
const double MRL2eeff (const Particle f, const double s) const
 
const double MRR2eeff (const Particle f, const double s, const double t) const
 
virtual const double Mw () const
 The SM prediction for the \(W\)-boson mass in the on-shell scheme, \(M_{W,\mathrm{SM}}\). More...
 
const double Mw_tree () const
 The tree-level mass of the \(W\) boson, \(M_W^{\mathrm{tree}}\). More...
 
const 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...
 
const 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 const 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 const double Qwemoller (const double q2, const double y) const
 The computation of the electron's weak charge. More...
 
virtual const double Qwn () const
 The computation of the neutron weak charge: Qwn. More...
 
virtual const double Qwp () const
 The computation of the proton weak charge: Qwp. More...
 
virtual const double R0_f (const Particle f) const
 The ratio \(R_\ell^0=\Gamma(Z\to {\rm hadrons})/\Gamma(Z\to \ell^+ \ell^-)\). More...
 
virtual const double R_inv () const
 The ratio of the invisible and leptonic (electron) decay widths of the \(Z\) boson, \(R_{inv}\). More...
 
virtual const 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 const gslpp::complex rhoZ_f (const Particle f) const
 The effective leptonic neutral-current coupling \(\rho_Z^l\) in the SM. More...
 
virtual const double Ruc () const
 
virtual const double RWc () const
 The ratio \(R_{W,c)=\Gamma(W\to c + X)/\Gamma(W\to had)\). More...
 
virtual const double RWlilj (const Particle li, const Particle lj) const
 The lepton universality ratio \(R_{W,l_i/l_j)=\Gamma(W\to l_i \nu_i)/\Gamma(W\to l_j \nu_j)\). More...
 
virtual const double RZlilj (const Particle li, const Particle lj) const
 The lepton universality ratio \(R_{Z,l_i/l_j)=\Gamma(Z\to l_i^+ l_i^-)/\Gamma(Z\to l_j^+ l_j^-)\). More...
 
const double s02 () const
 The square of the sine of the weak mixing angle \(s_0^2\) defined without weak radiative corrections. More...
 
void setCKM (const CKM &CKMMatrix)
 A set method to change the CKM matrix. 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)
 
bool setFlagSigmaForAFB (const bool flagSigmaForAFB_i)
 
bool setFlagSigmaForR (const bool flagSigmaForR_i)
 
virtual bool setFlagStr (const std::string name, const std::string value)
 A method to set a flag of StandardModel. More...
 
void setRequireCKM (bool requireCKM)
 A set method to change the value of requireCKM. More...
 
void setSMSuccess (bool success) const
 A set method to change the success status of the Standard Model update and matching. More...
 
void setYd (const gslpp::matrix< gslpp::complex > &Yd)
 A set method to set the Yukawa matrix of the down-type quarks, \(Y_d\). More...
 
void setYe (const gslpp::matrix< gslpp::complex > &Ye)
 A set method to set the Yukawa matrix of the charged leptons, \(Y_e\). More...
 
void setYu (const gslpp::matrix< gslpp::complex > &Yu)
 A set method to set the Yukawa matrix of the up-type quarks, \(Y_u\). More...
 
virtual const 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 const double SigmaeeHee (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model. More...
 
virtual const double SigmaeeHvv (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model. More...
 
virtual const double SigmaeeZH (const double sqrt_s, const double Pe, const double Pp) const
 The \(\sigma(e^+ e^- \to Z H)\) in the Standard Model. More...
 
virtual const 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...
 
const double sW2 () const
 
virtual const 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...
 
const double sW2_MSbar_Approx () const
 The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme, denoted as \(\hat{s}_{W}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) More...
 
const double sW2_ND () const
 The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t/M_Z)$ terms), denoted as \(\hat{s}_{ND}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) (eq. 10.13a/10.13b) More...
 
virtual const double TauLFU_gmuge () const
 The computation of the LFU ratio \(g_\mu/ g_e \). More...
 
virtual const double TauLFU_gtauge () const
 The computation of the LFU ratio \(g_\tau/ g_e \). More...
 
virtual const double TauLFU_gtaugmu () const
 The computation of the LFU ratio \(g_\tau/ g_\mu \). More...
 
virtual const double TauLFU_gtaugmuK () const
 The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_K \). More...
 
virtual const double TauLFU_gtaugmuPi () const
 The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_\pi \). More...
 
virtual const double ThetaLnuN () const
 The effective neutrino nucleon LH parameter: ThetaLnuN. More...
 
virtual const double ThetaRnuN () const
 The effective neutrino nucleon RH parameter: ThetaRnuN. More...
 
const double tovers2 (const double cosmin, const double cosmax) const
 
const double uovers2 (const double cosmin, const double cosmax) const
 
virtual bool Update (const std::map< std::string, double > &DPars)
 The update method for StandardModel. More...
 
const double v () const
 The Higgs vacuum expectation value. More...
 
virtual ~StandardModel ()
 The default destructor. More...
 
- Public Member Functions inherited from QCD
const 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...
 
const double Als (const double mu, const int Nf_in, const orders order=FULLNLO) const
 Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda(). More...
 
const double Als (const double mu, const orders order=FULLNLO, const bool Nf_thr=true) const
 
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...
 
const double AlsByOrder (const double mu, const int Nf_in, const orders order=FULLNLO) const
 
const double AlsByOrder (const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
 
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...
 
const double AlsWithInit (const double mu, const double alsi, const double mu_i, const int nf, 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...
 
const 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...
 
const double BelowTh (const double mu) const
 The active flavour threshold below the scale \(\mu\) as defined in QCD::Thresholds(). More...
 
const double Beta0 (const double nf) const
 The \(\beta_0(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta1 (const double nf) const
 The \(\beta_1(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const double Beta2 (const double nf) const
 The \(\beta_2(n_f)\) coefficient for a certain number of flavours \(n_f\). More...
 
const 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
 
const orders FullOrder (orders order) const
 Return the FULLORDER enum corresponding to order. More...
 
const double Gamma0 (const double nf) const
 The \(\gamma_0\) coefficient used to compute the running of a mass. More...
 
const double Gamma1 (const double nf) const
 The \(\gamma_1\) coefficient used to compute the running of a mass. More...
 
const double Gamma2 (const double nf) const
 The \(\gamma_2\) coefficient used to compute the running of a mass. More...
 
const double getAlsM () const
 A get method to access the value of \(\alpha_s(M_{\alpha_s})\). More...
 
const BParametergetBBd () 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...
 
const BParametergetBBd_subleading () const
 For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_d\) meson system. More...
 
const BParametergetBBs () 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...
 
const BParametergetBBs_subleading () const
 For getting the subleading bag parameters \(R_2 - R_3\) in \(\Delta b = 2\) process in the \(B_s\) meson system. More...
 
const BParametergetBD () 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...
 
const BParametergetBK () 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...
 
const BParametergetBKd1 () const
 
const BParametergetBKd3 () const
 
const double getCF () const
 A get method to access the Casimir factor of QCD. More...
 
const double getMAls () const
 A get method to access the mass scale \(M_{\alpha_s}\) at which the strong coupling constant measurement is provided. More...
 
const MesongetMesons (const QCD::meson m) const
 A get method to access a meson as an object of the type Meson. More...
 
const double getMtpole () const
 A get method to access the pole mass of the top quark. More...
 
const double getMub () const
 A get method to access the threshold between five- and four-flavour theory in GeV. More...
 
const double getMuc () const
 A get method to access the threshold between four- and three-flavour theory in GeV. More...
 
const double getMut () const
 A get method to access the threshold between six- and five-flavour theory in GeV. More...
 
const double getNc () const
 A get method to access the number of colours \(N_c\). More...
 
const double getOptionalParameter (std::string name) const
 A method to get parameters that are specific to only one set of observables. More...
 
const ParticlegetQuarks (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...
 
bool isQCDsuccess () const
 A getter for the QCDsuccess flag. More...
 
const double logLambda (const double nf, orders order) const
 Computes \(\ln\Lambda_\mathrm{QCD}\) with nf flavours in GeV. More...
 
const double Mbar2Mp (const double mbar, const quark q, const orders order=FULLNNLO) const
 Converts the \(\overline{\mathrm{MS}}\) mass \(m(m)\) to the pole mass. More...
 
const double Mofmu2Mbar (const double m, const double mu, const quark q) const
 Converts a quark running mass at an arbitrary scale to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
const double Mp2Mbar (const double mp, const quark q, orders order=FULLNNLO) const
 Converts a quark pole mass to the corresponding \(\overline{\mathrm{MS}}\) mass \(m(m)\). More...
 
const double Mrun (const double mu, const double m, const quark q, const orders order=FULLNNLO) const
 Computes a running quark mass \(m(\mu)\) from \(m(m)\). More...
 
const double Mrun (const double mu_f, const double mu_i, const double m, const quark q, const orders order=FULLNNLO) const
 Runs a quark mass from \(\mu_i\) to \(\mu_f\). More...
 
const 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...
 
const double MS2DRqmass (const double MSbar) const
 Converts a quark mass from the \(\overline{\mathrm{MS}}\) scheme to the \(\overline{\mathrm{DR}}\) scheme. More...
 
const 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...
 
const double Nf (const double mu) const
 The number of active flavour at scale \(\mu\). More...
 
const 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...
 
const std::string orderToString (const orders order) const
 Converts an object of the enum type "orders" to the corresponding string. More...
 
 QCD ()
 Constructor. More...
 
void setComputemt (bool computemt)
 A set method to change the value of computemt. More...
 
void setMtpole (double mtpole_in)
 A method to set the pole mass of the top quark. 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...
 
void setQuarkMass (const quark q, const double mass)
 A set method to change the mass of a quark. More...
 
const 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 isModelFWC_DF2 () const
 
bool isModelGeneralTHDM () const
 
bool isModelGeorgiMachacek () const
 
bool IsModelInitialized () const
 A method to check if the model is initialized. More...
 
bool isModelLinearized () const
 
bool isModelNPquadratic () 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 setModelFWC_DF2 ()
 
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 setModelNPquadratic (bool NPquadratic=true)
 
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 = 28
 The number of the model parameters in StandardModel. More...
 
static const int NumSMParamsForEWPO = 35
 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

const double AFB_NoISR_l (const QCD::lepton l_flavor, const double s) const
 
const double AFB_NoISR_q (const QCD::quark q_flavor, const double s) const
 
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 Yukawas matrix. 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...
 
const double getIntegrand_AFBnumeratorWithISR_bottom133 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom167 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_bottom207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm133 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm167 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_charm207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu130 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu136 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu161 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_mu207 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau130 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau136 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau161 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau172 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau183 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau189 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau192 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau196 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau200 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau202 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau205 (double x) const
 
const double getIntegrand_AFBnumeratorWithISR_tau207 (double x) const
 
const double getIntegrand_dsigmaBox_bottom130 (double x) const
 
const double getIntegrand_dsigmaBox_bottom133 (double x) const
 
const double getIntegrand_dsigmaBox_bottom136 (double x) const
 
const double getIntegrand_dsigmaBox_bottom161 (double x) const
 
const double getIntegrand_dsigmaBox_bottom167 (double x) const
 
const double getIntegrand_dsigmaBox_bottom172 (double x) const
 
const double getIntegrand_dsigmaBox_bottom183 (double x) const
 
const double getIntegrand_dsigmaBox_bottom189 (double x) const
 
const double getIntegrand_dsigmaBox_bottom192 (double x) const
 
const double getIntegrand_dsigmaBox_bottom196 (double x) const
 
const double getIntegrand_dsigmaBox_bottom200 (double x) const
 
const double getIntegrand_dsigmaBox_bottom202 (double x) const
 
const double getIntegrand_dsigmaBox_bottom205 (double x) const
 
const double getIntegrand_dsigmaBox_bottom207 (double x) const
 
const double getIntegrand_dsigmaBox_charm130 (double x) const
 
const double getIntegrand_dsigmaBox_charm133 (double x) const
 
const double getIntegrand_dsigmaBox_charm136 (double x) const
 
const double getIntegrand_dsigmaBox_charm161 (double x) const
 
const double getIntegrand_dsigmaBox_charm167 (double x) const
 
const double getIntegrand_dsigmaBox_charm172 (double x) const
 
const double getIntegrand_dsigmaBox_charm183 (double x) const
 
const double getIntegrand_dsigmaBox_charm189 (double x) const
 
const double getIntegrand_dsigmaBox_charm192 (double x) const
 
const double getIntegrand_dsigmaBox_charm196 (double x) const
 
const double getIntegrand_dsigmaBox_charm200 (double x) const
 
const double getIntegrand_dsigmaBox_charm202 (double x) const
 
const double getIntegrand_dsigmaBox_charm205 (double x) const
 
const double getIntegrand_dsigmaBox_charm207 (double x) const
 
const double getIntegrand_dsigmaBox_down130 (double x) const
 
const double getIntegrand_dsigmaBox_down133 (double x) const
 
const double getIntegrand_dsigmaBox_down136 (double x) const
 
const double getIntegrand_dsigmaBox_down161 (double x) const
 
const double getIntegrand_dsigmaBox_down167 (double x) const
 
const double getIntegrand_dsigmaBox_down172 (double x) const
 
const double getIntegrand_dsigmaBox_down183 (double x) const
 
const double getIntegrand_dsigmaBox_down189 (double x) const
 
const double getIntegrand_dsigmaBox_down192 (double x) const
 
const double getIntegrand_dsigmaBox_down196 (double x) const
 
const double getIntegrand_dsigmaBox_down200 (double x) const
 
const double getIntegrand_dsigmaBox_down202 (double x) const
 
const double getIntegrand_dsigmaBox_down205 (double x) const
 
const double getIntegrand_dsigmaBox_down207 (double x) const
 
const double getIntegrand_dsigmaBox_mu130 (double x) const
 
const double getIntegrand_dsigmaBox_mu133 (double x) const
 
const double getIntegrand_dsigmaBox_mu136 (double x) const
 
const double getIntegrand_dsigmaBox_mu161 (double x) const
 
const double getIntegrand_dsigmaBox_mu167 (double x) const
 
const double getIntegrand_dsigmaBox_mu172 (double x) const
 
const double getIntegrand_dsigmaBox_mu183 (double x) const
 
const double getIntegrand_dsigmaBox_mu189 (double x) const
 
const double getIntegrand_dsigmaBox_mu192 (double x) const
 
const double getIntegrand_dsigmaBox_mu196 (double x) const
 
const double getIntegrand_dsigmaBox_mu200 (double x) const
 
const double getIntegrand_dsigmaBox_mu202 (double x) const
 
const double getIntegrand_dsigmaBox_mu205 (double x) const
 
const double getIntegrand_dsigmaBox_mu207 (double x) const
 
const double getIntegrand_dsigmaBox_strange130 (double x) const
 
const double getIntegrand_dsigmaBox_strange133 (double x) const
 
const double getIntegrand_dsigmaBox_strange136 (double x) const
 
const double getIntegrand_dsigmaBox_strange161 (double x) const
 
const double getIntegrand_dsigmaBox_strange167 (double x) const
 
const double getIntegrand_dsigmaBox_strange172 (double x) const
 
const double getIntegrand_dsigmaBox_strange183 (double x) const
 
const double getIntegrand_dsigmaBox_strange189 (double x) const
 
const double getIntegrand_dsigmaBox_strange192 (double x) const
 
const double getIntegrand_dsigmaBox_strange196 (double x) const
 
const double getIntegrand_dsigmaBox_strange200 (double x) const
 
const double getIntegrand_dsigmaBox_strange202 (double x) const
 
const double getIntegrand_dsigmaBox_strange205 (double x) const
 
const double getIntegrand_dsigmaBox_strange207 (double x) const
 
const double getIntegrand_dsigmaBox_tau130 (double x) const
 
const double getIntegrand_dsigmaBox_tau133 (double x) const
 
const double getIntegrand_dsigmaBox_tau136 (double x) const
 
const double getIntegrand_dsigmaBox_tau161 (double x) const
 
const double getIntegrand_dsigmaBox_tau167 (double x) const
 
const double getIntegrand_dsigmaBox_tau172 (double x) const
 
const double getIntegrand_dsigmaBox_tau183 (double x) const
 
const double getIntegrand_dsigmaBox_tau189 (double x) const
 
const double getIntegrand_dsigmaBox_tau192 (double x) const
 
const double getIntegrand_dsigmaBox_tau196 (double x) const
 
const double getIntegrand_dsigmaBox_tau200 (double x) const
 
const double getIntegrand_dsigmaBox_tau202 (double x) const
 
const double getIntegrand_dsigmaBox_tau205 (double x) const
 
const double getIntegrand_dsigmaBox_tau207 (double x) const
 
const double getIntegrand_dsigmaBox_up130 (double x) const
 
const double getIntegrand_dsigmaBox_up133 (double x) const
 
const double getIntegrand_dsigmaBox_up136 (double x) const
 
const double getIntegrand_dsigmaBox_up161 (double x) const
 
const double getIntegrand_dsigmaBox_up167 (double x) const
 
const double getIntegrand_dsigmaBox_up172 (double x) const
 
const double getIntegrand_dsigmaBox_up183 (double x) const
 
const double getIntegrand_dsigmaBox_up189 (double x) const
 
const double getIntegrand_dsigmaBox_up192 (double x) const
 
const double getIntegrand_dsigmaBox_up196 (double x) const
 
const double getIntegrand_dsigmaBox_up200 (double x) const
 
const double getIntegrand_dsigmaBox_up202 (double x) const
 
const double getIntegrand_dsigmaBox_up205 (double x) const
 
const double getIntegrand_dsigmaBox_up207 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom130 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom133 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom136 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom161 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom167 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom172 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom183 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom189 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom192 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom196 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom200 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom202 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom205 (double x) const
 
const double getIntegrand_sigmaWithISR_bottom207 (double x) const
 
const double getIntegrand_sigmaWithISR_charm130 (double x) const
 
const double getIntegrand_sigmaWithISR_charm133 (double x) const
 
const double getIntegrand_sigmaWithISR_charm136 (double x) const
 
const double getIntegrand_sigmaWithISR_charm161 (double x) const
 
const double getIntegrand_sigmaWithISR_charm167 (double x) const
 
const double getIntegrand_sigmaWithISR_charm172 (double x) const
 
const double getIntegrand_sigmaWithISR_charm183 (double x) const
 
const double getIntegrand_sigmaWithISR_charm189 (double x) const
 
const double getIntegrand_sigmaWithISR_charm192 (double x) const
 
const double getIntegrand_sigmaWithISR_charm196 (double x) const
 
const double getIntegrand_sigmaWithISR_charm200 (double x) const
 
const double getIntegrand_sigmaWithISR_charm202 (double x) const
 
const double getIntegrand_sigmaWithISR_charm205 (double x) const
 
const double getIntegrand_sigmaWithISR_charm207 (double x) const
 
const double getIntegrand_sigmaWithISR_down130 (double x) const
 
const double getIntegrand_sigmaWithISR_down133 (double x) const
 
const double getIntegrand_sigmaWithISR_down136 (double x) const
 
const double getIntegrand_sigmaWithISR_down161 (double x) const
 
const double getIntegrand_sigmaWithISR_down167 (double x) const
 
const double getIntegrand_sigmaWithISR_down172 (double x) const
 
const double getIntegrand_sigmaWithISR_down183 (double x) const
 
const double getIntegrand_sigmaWithISR_down189 (double x) const
 
const double getIntegrand_sigmaWithISR_down192 (double x) const
 
const double getIntegrand_sigmaWithISR_down196 (double x) const
 
const double getIntegrand_sigmaWithISR_down200 (double x) const
 
const double getIntegrand_sigmaWithISR_down202 (double x) const
 
const double getIntegrand_sigmaWithISR_down205 (double x) const
 
const double getIntegrand_sigmaWithISR_down207 (double x) const
 
const double getIntegrand_sigmaWithISR_mu130 (double x) const
 
const double getIntegrand_sigmaWithISR_mu136 (double x) const
 
const double getIntegrand_sigmaWithISR_mu161 (double x) const
 
const double getIntegrand_sigmaWithISR_mu172 (double x) const
 
const double getIntegrand_sigmaWithISR_mu183 (double x) const
 
const double getIntegrand_sigmaWithISR_mu189 (double x) const
 
const double getIntegrand_sigmaWithISR_mu192 (double x) const
 
const double getIntegrand_sigmaWithISR_mu196 (double x) const
 
const double getIntegrand_sigmaWithISR_mu200 (double x) const
 
const double getIntegrand_sigmaWithISR_mu202 (double x) const
 
const double getIntegrand_sigmaWithISR_mu205 (double x) const
 
const double getIntegrand_sigmaWithISR_mu207 (double x) const
 
const double getIntegrand_sigmaWithISR_strange130 (double x) const
 
const double getIntegrand_sigmaWithISR_strange133 (double x) const
 
const double getIntegrand_sigmaWithISR_strange136 (double x) const
 
const double getIntegrand_sigmaWithISR_strange161 (double x) const
 
const double getIntegrand_sigmaWithISR_strange167 (double x) const
 
const double getIntegrand_sigmaWithISR_strange172 (double x) const
 
const double getIntegrand_sigmaWithISR_strange183 (double x) const
 
const double getIntegrand_sigmaWithISR_strange189 (double x) const
 
const double getIntegrand_sigmaWithISR_strange192 (double x) const
 
const double getIntegrand_sigmaWithISR_strange196 (double x) const
 
const double getIntegrand_sigmaWithISR_strange200 (double x) const
 
const double getIntegrand_sigmaWithISR_strange202 (double x) const
 
const double getIntegrand_sigmaWithISR_strange205 (double x) const
 
const double getIntegrand_sigmaWithISR_strange207 (double x) const
 
const double getIntegrand_sigmaWithISR_tau130 (double x) const
 
const double getIntegrand_sigmaWithISR_tau136 (double x) const
 
const double getIntegrand_sigmaWithISR_tau161 (double x) const
 
const double getIntegrand_sigmaWithISR_tau172 (double x) const
 
const double getIntegrand_sigmaWithISR_tau183 (double x) const
 
const double getIntegrand_sigmaWithISR_tau189 (double x) const
 
const double getIntegrand_sigmaWithISR_tau192 (double x) const
 
const double getIntegrand_sigmaWithISR_tau196 (double x) const
 
const double getIntegrand_sigmaWithISR_tau200 (double x) const
 
const double getIntegrand_sigmaWithISR_tau202 (double x) const
 
const double getIntegrand_sigmaWithISR_tau205 (double x) const
 
const double getIntegrand_sigmaWithISR_tau207 (double x) const
 
const double getIntegrand_sigmaWithISR_up130 (double x) const
 
const double getIntegrand_sigmaWithISR_up133 (double x) const
 
const double getIntegrand_sigmaWithISR_up136 (double x) const
 
const double getIntegrand_sigmaWithISR_up161 (double x) const
 
const double getIntegrand_sigmaWithISR_up167 (double x) const
 
const double getIntegrand_sigmaWithISR_up172 (double x) const
 
const double getIntegrand_sigmaWithISR_up183 (double x) const
 
const double getIntegrand_sigmaWithISR_up189 (double x) const
 
const double getIntegrand_sigmaWithISR_up192 (double x) const
 
const double getIntegrand_sigmaWithISR_up196 (double x) const
 
const double getIntegrand_sigmaWithISR_up200 (double x) const
 
const double getIntegrand_sigmaWithISR_up202 (double x) const
 
const double getIntegrand_sigmaWithISR_up205 (double x) const
 
const double getIntegrand_sigmaWithISR_up207 (double x) const
 
const double Integrand_AFBnumeratorWithISR_l (double x, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_AFBnumeratorWithISR_q (double x, const QCD::quark q_flavor, const double s) const
 
const double Integrand_dsigmaBox_l (double cosTheta, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_dsigmaBox_q (double cosTheta, const QCD::quark q_flavor, const double s) const
 
const double Integrand_sigmaWithISR_l (double x, const QCD::lepton l_flavor, const double s) const
 
const double Integrand_sigmaWithISR_q (double x, const QCD::quark q_flavor, const double s) const
 
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...
 
const double sigma_NoISR_l (const QCD::lepton l_flavor, const double s) const
 
const double sigma_NoISR_q (const QCD::quark q_flavor, const double s) const
 
double taub () const
 Top-mass corrections to the \(Zb\bar{b}\) vertex, denoted by \(\tau_b\). More...
 
- Protected Member Functions inherited from QCD
const 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...
 
bool bSigmaForAFB
 
bool bSigmaForR
 
double dAl5hMz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\). (Non-input parameter) More...
 
double dAle5Mz
 The five-flavour hadronic contribution to the electromagnetic coupling, \(\Delta\alpha_{\mathrm{had}}^{(5)}(M_Z^2)\), used as input for FlagMWinput = FALSE. More...
 
double delGammaWlv
 The theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\). More...
 
double delGammaWqq
 The theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\). 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...
 
bool FlagFixMuwMut
 A boolean for the model flag FixMuwMut. More...
 
bool flagLEP2 [NUMofLEP2RCs]
 
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...
 
double Mw_inp
 The mass of the \(W\) boson in GeV used as input for FlagMWinput = TRUE. 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 Vud
 \(\vert V_{ud} \vert \) used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE More...
 
double Vus
 \(\vert V_{us} \vert \) used as an input for FlagWolfenstein = FALSE More...
 
gslpp::matrix< gslpp::complex > Yd
 The Yukawa matrix of the down-type quarks. More...
 
gslpp::matrix< gslpp::complex > Ye
 The Yukawa matrix of the charged leptons. More...
 
gslpp::matrix< gslpp::complex > Yn
 The Yukawa matrix of the neutrinos. More...
 
gslpp::matrix< gslpp::complex > Yu
 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
 
bool FlagMpole2MbarNumeric
 A flag to determine whether the pole mass to \(\over \mathrm{MS}\) mass conversion is done numerically. More...
 
bool FlagMtPole
 A flag to determine whether the pole mass of the top quark is used as input. More...
 
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...
 
bool QCDsuccess =true
 
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 = false
 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 = false
 A boolean set to false if update is successful. More...
 

Private Member Functions

const double AleWithInit (double mu, double alsi, double mu_i, orders order) const
 
const double AlsE (double mu, orders order, bool Nf_thr) const
 
const double AlsEByOrder (double mu, orders order, bool Nf_thr) const
 
const double AlsEWithInit (double mu, double alsi, double mu_i, const int nf_i, orders order) const
 

Private Attributes

double ale_cache [10][CacheSize]
 Cache for \(\alpha_e\). More...
 
double als_cache [11][CacheSize]
 Cache for \(\alpha_s\). More...
 
double average
 
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...
 
double error
 
gsl_function f_GSL
 
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 FlagMWinput
 A boolean for the model flag MWinput.
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 FlagUseVud
 A boolean for the model flag UseVud. 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...
 
EWSMTwoFermionsLEP2myTwoFermionsLEP2
 A pointer to an object of type EWSMTwoFermionsLEP2. 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]
 
double SMresult_cache
 
bool SMSuccess
 A boolean for the success of the Standard Model update and matching. More...
 
bool useDeltaAlpha_cache
 
bool useDeltaAlphaLepton_cache
 
bool useGammaW_cache
 
bool useKappaZ_f_cache [12]
 
bool useMw_cache
 
bool useRhoZ_f_cache [12]
 
gsl_integration_workspace * w_GSL1
 

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 526 of file StandardModel.h.

◆ 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 539 of file StandardModel.h.

539 {
540 EW1 = 0,
541 EW1QCD1,
542 EW1QCD2,
543 EW2,
544 EW2QCD1,
545 EW3,
547 };
@ EW1
One-loop of .
@ EW2QCD1
Three-loop of .
@ EW2
Two-loop of .
@ orders_EW_size
The size of this enum.
@ EW3
Three-loop of .
@ EW1QCD1
Two-loop of .
@ EW1QCD2
Three-loop of .

Constructor & Destructor Documentation

◆ StandardModel()

StandardModel::StandardModel ( )

The default constructor.

Definition at line 41 of file StandardModel/src/StandardModel.cpp.

42: QCD(), Yu(3, 3, 0.), Yd(3, 3, 0.), Yn(3, 3, 0.),
43SMM(*this), SMFlavour(*this), Ye(3, 3, 0.)
44{
45 setModelName("StandardModel");
46 requireCKM = false;
47 requireYe = false;
48 requireYn = false;
49
52 FlagMw = "APPROXIMATEFORMULA";
53 FlagRhoZ = "NORESUM";
54 FlagKappaZ = "APPROXIMATEFORMULA";
55 FlagWolfenstein = true;
56 FlagUseVud = false;
57 FlagFixMuwMut = false;
58
59 FlagMWinput = false;
60
61 FlagSMAux = false;
62
63 /* Internal flags for EWPO (for debugging) */
64 flag_order[EW1] = true;
65 flag_order[EW1QCD1] = true;
66 flag_order[EW1QCD2] = true;
67 flag_order[EW2] = true;
68 flag_order[EW2QCD1] = true;
69 flag_order[EW3] = true;
70
71 //Flags for LEP2 observables
72 flagLEP2[Weak] = true;
73 flagLEP2[WeakBox] = true;
74 flagLEP2[ISR] = true;
75 flagLEP2[QEDFSR] = true;
76 flagLEP2[QCDFSR] = true;
77
78 bSigmaForAFB = false;
79 bSigmaForR = false;
80
81 // Caches for EWPO
82 FlagCacheInStandardModel = true; // use caches in the current class
84 useDeltaAlpha_cache = false;
85 useMw_cache = false;
86 useGammaW_cache = false;
88 DeltaAlpha_cache = 0.0;
89 Mw_cache = 0.0;
90 GammaW_cache = 0.0;
91 for (int i = 0; i < 12; ++i) {
92 useRhoZ_f_cache[i] = false;
93 useKappaZ_f_cache[i] = false;
94 rhoZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
95 kappaZ_f_cache[i] = gslpp::complex(0.0, 0.0, false);
96 }
97
98 myEWSMcache = NULL;
99 myOneLoopEW = NULL;
100 myTwoLoopQCD = NULL;
101 myThreeLoopQCD = NULL;
102 myTwoLoopEW = NULL;
103 myThreeLoopEW2QCD = NULL;
104 myThreeLoopEW = NULL;
106 /* BEGIN: REMOVE FROM THE PACKAGE */
107 myTwoFermionsLEP2 = NULL;
108 /* END: REMOVE FROM THE PACKAGE */
109
110 // Particle(std::string name, double mass, double mass_scale = 0., double width = 0., double charge = 0.,double isospin = 0.);
111 leptons[NEUTRINO_1] = Particle("NEUTRINO_1", 0., 0., 0., 0., .5);
112 leptons[NEUTRINO_2] = Particle("NEUTRINO_2", 0., 0., 0., 0., .5);
113 leptons[NEUTRINO_3] = Particle("NEUTRINO_3", 0., 0., 0., 0., .5);
114 leptons[ELECTRON] = Particle("ELECTRON", 0., 0., 0., -1., -.5);
115 leptons[MU] = Particle("MU", 0., 0., 0., -1., -.5);
116 leptons[TAU] = Particle("TAU", 0., 0., 0., -1., -.5);
117
118 ModelParamMap.insert(std::make_pair("Mz", std::cref(Mz)));
119 ModelParamMap.insert(std::make_pair("AlsMz", std::cref(AlsMz)));
120 ModelParamMap.insert(std::make_pair("GF", std::cref(GF)));
121 ModelParamMap.insert(std::make_pair("ale", std::cref(ale)));
122 ModelParamMap.insert(std::make_pair("dAle5Mz", std::cref(dAle5Mz)));
123// ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
124 ModelParamMap.insert(std::make_pair("mHl", std::cref(mHl)));
125 ModelParamMap.insert(std::make_pair("delMw", std::cref(delMw)));
126 ModelParamMap.insert(std::make_pair("delSin2th_l", std::cref(delSin2th_l)));
127 ModelParamMap.insert(std::make_pair("delSin2th_q", std::cref(delSin2th_q)));
128 ModelParamMap.insert(std::make_pair("delSin2th_b", std::cref(delSin2th_b)));
129 ModelParamMap.insert(std::make_pair("delGammaZ", std::cref(delGammaZ)));
130 ModelParamMap.insert(std::make_pair("delsigma0H", std::cref(delsigma0H)));
131 ModelParamMap.insert(std::make_pair("delR0l", std::cref(delR0l)));
132 ModelParamMap.insert(std::make_pair("delR0c", std::cref(delR0c)));
133 ModelParamMap.insert(std::make_pair("delR0b", std::cref(delR0b)));
134 ModelParamMap.insert(std::make_pair("delGammaWlv", std::cref(delGammaWlv)));
135 ModelParamMap.insert(std::make_pair("delGammaWqq", std::cref(delGammaWqq)));
136 ModelParamMap.insert(std::make_pair("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
137 ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
138 ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
139 ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
140 ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
141 ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
142 ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
143 ModelParamMap.insert(std::make_pair("A", std::cref(A)));
144 ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
145 ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
146 ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
147
148 iterationNo = 0;
149 realorder = LO;
150
151 w_GSL1 = gsl_integration_workspace_alloc (200);
152}
@ LO
Definition: OrderScheme.h:34
std::map< std::string, std::reference_wrapper< const double > > ModelParamMap
Definition: Model.h:280
void setModelName(const std::string name)
A method to set the name of the model.
Definition: Model.h:50
A class for particles.
Definition: Particle.h:26
QCD()
Constructor.
Definition: QCD.cpp:29
@ NEUTRINO_2
Definition: QCD.h:313
@ NEUTRINO_1
Definition: QCD.h:311
@ MU
Definition: QCD.h:314
@ ELECTRON
Definition: QCD.h:312
@ NEUTRINO_3
Definition: QCD.h:315
@ TAU
Definition: QCD.h:316
double dAle5Mz
The five-flavour hadronic contribution to the electromagnetic coupling, , used as input for FlagMWinp...
EWSMThreeLoopEW * myThreeLoopEW
A pointer to an object of type EWSMThreeLoopEW.
double delSin2th_b
The theoretical uncertainty in , denoted as .
double A
The CKM parameter in the Wolfenstein parameterization.
bool requireCKM
An internal flag to control whether the CKM matrix has to be recomputed.
std::string FlagRhoZ
A string for the model flag RhoZ.
double Mz
The mass of the boson in GeV.
EWSMThreeLoopQCD * myThreeLoopQCD
A pointer to an object of type EWSMThreeLoopQCD.
double delGammaWlv
The theoretical uncertainty in , denoted as .
double GammaW_cache
A cache of the value of .
double delMw
The theoretical uncertainty in , denoted as , in GeV.
bool flag_order[orders_EW_size]
An array of internal flags controlling the inclusions of higher-order corrections.
EWSMTwoLoopEW * myTwoLoopEW
A pointer to an object of type EWSMTwoLoopEW.
bool FlagFixMuwMut
A boolean for the model flag FixMuwMut.
bool useDeltaAlpha_cache
bool requireYn
An internal flag to control whether the neutrino Yukawa matrix has to be recomputed.
gsl_integration_workspace * w_GSL1
gslpp::matrix< gslpp::complex > Yn
The Yukawa matrix of the neutrinos.
EWSMTwoFermionsLEP2 * myTwoFermionsLEP2
A pointer to an object of type EWSMTwoFermionsLEP2.
Matching< StandardModelMatching, StandardModel > SMM
An object of type Matching.
gslpp::matrix< gslpp::complex > Yu
The Yukawa matrix of the up-type quarks.
std::string FlagMw
A string for the model flag Mw.
double delsigma0H
The theoretical uncertainty in , denoted as in nb.
double rhob
The CKM parameter in the Wolfenstein parameterization.
Particle leptons[6]
An array of Particle objects for the leptons.
double delSin2th_l
The theoretical uncertainty in , denoted as .
bool FlagMWinput
A boolean for the model flag MWinput.
Flavour SMFlavour
An object of type Flavour.
bool FlagWithoutNonUniversalVC
A boolean for the model flag WithoutNonUniversalVC.
bool FlagSMAux
A boolean for the model flag SMAux.
gslpp::matrix< gslpp::complex > Yd
The Yukawa matrix of the down-type quarks.
EWSMOneLoopEW * myOneLoopEW
A pointer to an object of type EWSMOneLoopEW.
double delR0c
The theoretical uncertainty in , denoted as .
std::string FlagKappaZ
A string for the model flag KappaZ.
double GF
The Fermi constant in .
EWSMApproximateFormulae * myApproximateFormulae
A pointer to an object of type EWSMApproximateFormulae.
double Mw_cache
A cache of the value of .
double DeltaAlphaLepton_cache
A cache of the value of .
double delGammaWqq
The theoretical uncertainty in , denoted as .
double delSin2th_q
The theoretical uncertainty in , denoted as .
bool FlagUseVud
A boolean for the model flag UseVud.
bool FlagNoApproximateGammaZ
A boolean for the model flag NoApproximateGammaZ.
gslpp::complex kappaZ_f_cache[12]
A cache of the value of .
double lambda
The CKM parameter in the Wolfenstein parameterization.
bool useDeltaAlphaLepton_cache
double etab
The CKM parameter in the Wolfenstein parameterization.
EWSMcache * myEWSMcache
A pointer to an object of type EWSMcache.
gslpp::complex rhoZ_f_cache[12]
A cache of the value of .
double mHl
The Higgs mass in GeV.
double ale
The fine-structure constant .
bool flagLEP2[NUMofLEP2RCs]
double AlsMz
The strong coupling constant at the Z-boson mass, .
double delGammaZ
The theoretical uncertainty in , denoted as , in GeV.
gslpp::matrix< gslpp::complex > Ye
The Yukawa matrix of the charged leptons.
double muw
A matching scale around the weak scale in GeV.
bool useRhoZ_f_cache[12]
double delR0b
The theoretical uncertainty in , denoted as .
EWSMTwoLoopQCD * myTwoLoopQCD
A pointer to an object of type EWSMTwoLoopQCD.
bool FlagWolfenstein
A boolean for the model flag Wolfenstein.
bool requireYe
An internal flag to control whether the charged-lepton Yukawa matrix has to be recomputed.
EWSMThreeLoopEW2QCD * myThreeLoopEW2QCD
A pointer to an object of type EWSMThreeLoopEW2QCD.
bool useKappaZ_f_cache[12]
bool FlagCacheInStandardModel
A flag for caching (true by default).
double DeltaAlpha_cache
A cache of the value of .
double delR0l
The theoretical uncertainty in , denoted as .

◆ ~StandardModel()

StandardModel::~StandardModel ( )
virtual

The default destructor.

Definition at line 154 of file StandardModel/src/StandardModel.cpp.

155{
156 if (IsModelInitialized()) {
157 if (myEWSMcache != NULL) delete(myEWSMcache);
158 if (myOneLoopEW != NULL) delete(myOneLoopEW);
159 if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
160 if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
161 if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
162 if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
163 if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
164 if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
165 if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
166 /* BEGIN: REMOVE FROM THE PACKAGE */
167 if (myTwoFermionsLEP2 != NULL) delete(myTwoFermionsLEP2);
168 /* END: REMOVE FROM THE PACKAGE */
169 }
170}
bool IsModelInitialized() const
A method to check if the model is initialized.
Definition: Model.h:136
LeptonFlavour * myLeptonFlavour
A pointer to an object of the type LeptonFlavour.

Member Function Documentation

◆ A_f()

const 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 NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1345 of file StandardModel/src/StandardModel.cpp.

1346{
1347 double Re_kappa = kappaZ_f(f).real();
1348 double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1349 return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1350}
double getCharge() const
A get method to access the particle charge.
Definition: Particle.h:97
virtual const gslpp::complex kappaZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.

◆ AFB()

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

Reimplemented in NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1352 of file StandardModel/src/StandardModel.cpp.

1353{
1354 return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1355}
virtual const double A_f(const Particle f) const
The left-right asymmetry in at the -pole, .

◆ AFB_NoISR_l()

const double StandardModel::AFB_NoISR_l ( const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8039 of file StandardModel/src/StandardModel.cpp.

8040{
8041 double ml = getLeptons(l_flavor).getMass();
8042 double AFB = myTwoFermionsLEP2->AFB_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8043
8044 return AFB;
8045}
double AFB_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
const Particle & getLeptons(const QCD::lepton p) const
A get method to retrieve the member object of a lepton.
virtual const double AFB(const Particle f) const
virtual const double Gamma_Z() const
The total decay width of the boson, .
virtual const double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Test Observable.

◆ AFB_NoISR_q()

const double StandardModel::AFB_NoISR_q ( const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8047 of file StandardModel/src/StandardModel.cpp.

8048{
8049 double mq = m_q(q_flavor, sqrt(s));
8050 double AFB = myTwoFermionsLEP2->AFB_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8051
8052 if (flagLEP2[QCDFSR])
8053 AFB *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, s);
8054
8055 return AFB;
8056}
double AFB_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double QCD_FSR_forAFB(const QCD::quark q, const double mf, const double s) const
double m_q(const QCD::quark q, const double mu, const orders order=FULLNLO) const

◆ AH_f()

gslpp::complex StandardModel::AH_f ( const double  tau) const

Fermionic loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings.

\(A^H_f(\tau)=2\tau [1+(1-\tau)f(\tau)]\)

Parameters
[in]

_form#4756, with \(M\) the mass of the fermion in the loop.

Returns
\(A^H_f(\tau)\)

Definition at line 3302 of file StandardModel/src/StandardModel.cpp.

3302 {
3303 return (2.0 * tau * (1.0 + (1.0 - tau) * f_triangle(tau)));
3304}
gslpp::complex f_triangle(const double tau) const
Loop function entering in the calculation of the effective and couplings.

◆ AH_W()

gslpp::complex StandardModel::AH_W ( const double  tau) const

W loop function entering in the calculation of the effective \(H\gamma\gamma\) coupling.

\(A^H_W(\tau)=-[2+3\tau + 3\tau*(2-\tau) f(\tau)]\)

Parameters
[in]

_form#4756, with \(M\) the mass of the fermion in the loop.

Returns
\(A^H_W(\tau)\)

Definition at line 3306 of file StandardModel/src/StandardModel.cpp.

3306 {
3307 return -(2.0 + 3.0 * tau + 3.0 * tau * (2.0 - tau) * f_triangle(tau));
3308}

◆ AHZga_f()

gslpp::complex StandardModel::AHZga_f ( const double  tau,
const double  lambda 
) const

Fermionic loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4756, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the fermion in the loop.

Returns
\(A^{HZ\gamma}_f(\tau,\lambda)\)

Definition at line 3310 of file StandardModel/src/StandardModel.cpp.

3310 {
3311 return I_triangle_1(tau, lambda) - I_triangle_2(tau, lambda);
3312}
gslpp::complex I_triangle_1(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.
gslpp::complex I_triangle_2(const double tau, const double lambda) const
Loop function entering in the calculation of the effective coupling.

◆ AHZga_W()

gslpp::complex StandardModel::AHZga_W ( const double  tau,
const double  lambda 
) const

W loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4756, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the fermion in the loop.

Returns
\(A^{HZ\gamma}_W(\tau,\lambda)\)

Definition at line 3314 of file StandardModel/src/StandardModel.cpp.

3314 {
3315 gslpp::complex tmp;
3316
3317 double tan2w = sW2() / cW2();
3318
3319 tmp = 4.0 * (3.0 - tan2w) * I_triangle_2(tau, lambda);
3320
3321 tmp = tmp + ((1.0 + 2.0 / tau) * tan2w - (5.0 + 2.0 / tau)) * I_triangle_1(tau, lambda);
3322
3323 return sqrt(cW2()) * tmp;
3324}
virtual const double cW2() const

◆ Ale()

const 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 [Huber:2005ig]

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 783 of file StandardModel/src/StandardModel.cpp.

784{
785 int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
786 double ale, aletmp, mutmp, aleMz = alphaMz();
787 orders fullord;
788
789 for (i = 0; i < CacheSize; ++i)
790 if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
791 (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
792 (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
793 (muc == ale_cache[6][i])
794 && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
795 return ale_cache[9][i];
796
797 switch (order)
798 {
799 case FULLNLO:
800 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
801 case FULLNNLO:
802 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
803 case FULLNNNLO:
804 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
805 case LO:
806 if (nfAle == nfmu)
807 return(AleWithInit(mu, aleMz, Mz, order));
808 case NLO:
809 case NNLO:
810 case NNNLO:
811 if (nfAle == nfmu)
812 return(0.);
813 fullord = FullOrder(order);
814 if (nfAle > nfmu) {
815 mutmp = BelowTh(Mz);
816 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
817// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
818 for (i = nfAle - 1; i > nfmu; i--) {
819 mutmp = BelowTh(mutmp - MEPS);
820 aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
821// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
822 }
823 ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
824 }
825
826 if (nfAle < nfmu) {
827 mutmp = AboveTh(Mz) - MEPS;
828 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
829// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
830 for (i = nfAle + 1; i < nfmu; i++) {
831 mutmp = AboveTh(mutmp) - MEPS;
832 aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
833// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
834 }
835 ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
836 }
837
839 ale_cache[0][0] = mu;
840 ale_cache[1][0] = (double) order;
841 ale_cache[2][0] = AlsMz;
842 ale_cache[3][0] = Mz;
843 ale_cache[4][0] = mut;
844 ale_cache[5][0] = mub;
845 ale_cache[6][0] = muc;
846 ale_cache[7][0] = (double) Nf_thr;
847 ale_cache[8][0] = aleMz;
848 ale_cache[9][0] = ale;
849
850 return ale;
851 default:
852 throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
853 }
854}
@ FULLNNNLO
Definition: OrderScheme.h:40
@ NNLO
Definition: OrderScheme.h:36
@ NNNLO
Definition: OrderScheme.h:37
@ NLO
Definition: OrderScheme.h:35
@ FULLNNLO
Definition: OrderScheme.h:39
@ FULLNLO
Definition: OrderScheme.h:38
double mut
The threshold between six- and five-flavour theory in GeV.
Definition: QCD.h:1021
double muc
The threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:1023
const double BelowTh(const double mu) const
The active flavour threshold below the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:559
const std::string orderToString(const orders order) const
Converts an object of the enum type "orders" to the corresponding string.
Definition: QCD.cpp:95
const double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:547
const double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:571
const orders FullOrder(orders order) const
Return the FULLORDER enum corresponding to order.
Definition: QCD.cpp:728
double mub
The threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:1022
void CacheShift(double cache[][5], int n) const
A member used to manage the caching for this class.
const double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
const double AleWithInit(double mu, double alsi, double mu_i, orders order) const
double ale_cache[10][CacheSize]
Cache for .
virtual const double alphaMz() const
The electromagnetic coupling at the -mass scale, .
static const int CacheSize
Defines the depth of the cache.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:33

◆ ale_OS()

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

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

See [Baikov:2012rr].

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 611 of file StandardModel/src/StandardModel.cpp.

612{
613 if (mu < 50.0)
614 throw std::runtime_error("out of range in StandardModel::ale_OS()");
615
616 double N = 20.0 / 3.0;
617 double beta1 = N / 3.0;
618 double beta2 = N / 4.0;
619 double alpha_ini = alphaMz();
620 double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
621
622 switch (order) {
623 case LO:
624 return ( alpha_ini / v);
625 case FULLNLO:
626 return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
627 default:
628 throw std::runtime_error("Error in StandardModel::ale_OS()");
629 }
630}
const double v() const
The Higgs vacuum expectation value.

◆ AleWithInit()

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

Definition at line 856 of file StandardModel/src/StandardModel.cpp.

857{
858 if (fabs(mu - mu_i) < MEPS) return(alei);
859
860 double nf = Nf(mu), alsi = (mu_i == Mz ? AlsMz : Als(mu_i, FULLNNNLO, true, true));
861 double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
862 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
863 double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
864
865 switch (order)
866 {
867 case LO:
868 return (alei / ve);
869 case NLO:
870 return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
871 // Higher order terms ? Need to understand eq. (35)
872 case FULLNLO:
873 return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
874 default:
875 throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
876 }
877}
const double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
const double Als(const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
The running QCD coupling in the scheme including QED corrections.
const double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.

◆ alphaMz()

const double StandardModel::alphaMz ( ) const
virtual

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)\)

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 944 of file StandardModel/src/StandardModel.cpp.

945{
946 return (ale / (1.0 - DeltaAlpha()));
947// return(1./127.918); // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
948// return(1./127.955); // FOR HEFFDF1 TEST: VALUE IN 2007.04191
949}
const double DeltaAlpha() const
The total corrections to the electromagnetic coupling at the -mass scale, denoted as .

◆ alrmoller()

const double StandardModel::alrmoller ( const double  q2,
const double  y 
) const
virtual

The computation of the parity violating asymmetry in Moller scattering.

Parameters
[in]q2the \(Q^2\) of the process
[in]y
Returns
\(A_{LR}\)

Definition at line 2769 of file StandardModel/src/StandardModel.cpp.

2770{
2771 // functions and inputs
2772 double alrmoller;
2773
2774 // which alfa is this? => alpha(0). is this ale?
2775
2776 // parity violation asymmetry
2777 // --------------------------
2778 alrmoller=-GF*q2*(1.0-y)/(sqrt(2.0)*M_PI*ale*(1.0+pow(y,4)+pow(1.0-y,4)))*Qwemoller(q2,y);
2779
2780 return alrmoller;
2781}
virtual const double alrmoller(const double q2, const double y) const
The computation of the parity violating asymmetry in Moller scattering.
virtual const double Qwemoller(const double q2, const double y) const
The computation of the electron's weak charge.

◆ Als() [1/3]

const double QCD::Als ( const double  mu,
const int  Nf_in,
const orders  order = FULLNLO 
) const

Computes the running strong coupling \(\alpha_s(\mu)\) with \(N_f\) active flavours in the \(\overline{\mathrm{MS}}\) scheme. In the cases of LO, NLO and FULLNLO, the coupling is computed with AlsWithInit(). On the other hand, in the cases of NNLO and FULLNNLO, the coupling is computed with AlsWithLambda().

Parameters
[in]muthe scale \(\mu\) in GeV
[in]Nf_innumber of active flavours
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
Returns
the strong coupling constant \(\alpha_s(\mu)\) in the \(\overline{\mathrm{MS}}\) scheme with \(N_f\) active flavours

Definition at line 839 of file QCD.cpp.

784{
785 switch (order)
786 {
787 case LO:
788 realorder = order;
789 return AlsByOrder(mu, Nf, LO);
790 case FULLNLO:
791 realorder = order;
792 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO));
793 case FULLNNLO:
794 realorder = order;
795 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO));
796 case FULLNNNLO:
797 realorder = order;
798 return (AlsByOrder(mu, Nf, LO) + AlsByOrder(mu, Nf, NLO) + AlsByOrder(mu, Nf, NNLO) + AlsByOrder(mu, Nf, NNNLO));
799 default:
800 throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
801 }
802}
const double AlsByOrder(const double mu, const orders order=FULLNLO, bool Nf_thr=true) const
Definition: QCD.cpp:804

◆ Als() [2/3]

const double StandardModel::Als ( const double  mu,
const orders  order,
const bool  Nf_thr,
const bool  qed_flag 
) const
inline

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

See [Huber:2005ig]

Parameters
[in]murenormalization scale \(\mu\) in GeV.
[in]orderorder in the \(\alpha_s\) expansion as defined in OrderScheme
[in]Nf_thrtrue: \(n_f\) = Nf(mu), false: \(n_f\) = Nf(AlsM)
[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
Returns
\(\alpha(\mu)\) in the \(\overline{MS}\) scheme

Definition at line 1120 of file StandardModel.h.

1121 {
1122 if (qed_flag && order == FULLNNNLO)
1123 return AlsE(mu, order, Nf_thr);
1124
1125 return Als(mu, order, Nf_thr);
1126 }
const double AlsE(double mu, orders order, bool Nf_thr) const

◆ Als() [3/3]

const double QCD::Als ( const double  mu,
const orders  order = FULLNLO,
const bool  Nf_thr = true 
) const

Definition at line 826 of file QCD.cpp.

763{
764 switch (order)
765 {
766 case LO:
767 realorder = order;
768 return AlsByOrder(mu, LO, Nf_thr);
769 case FULLNLO:
770 realorder = order;
771 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr));
772 case FULLNNLO:
773 realorder = order;
774 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr));
775 case FULLNNNLO:
776 realorder = order;
777 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsByOrder(mu, NNNLO, Nf_thr));
778 default:
779 throw std::runtime_error("QCD::Als(): " + orderToString(order) + " is not implemented.");
780 }
781}

◆ AlsE()

const double StandardModel::AlsE ( double  mu,
orders  order,
bool  Nf_thr 
) const
private

Definition at line 680 of file StandardModel/src/StandardModel.cpp.

681{
682 switch (order)
683 {
684 case FULLNNNLO:
685 realorder = order;
686 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsEByOrder(mu, NNNLO, Nf_thr));
687 default:
688 throw std::runtime_error("StandardModel::AlsE(): " + orderToString(order) + " is not implemented.");
689 }
690}
const double AlsEByOrder(double mu, orders order, bool Nf_thr) const

◆ AlsEByOrder()

const double StandardModel::AlsEByOrder ( double  mu,
orders  order,
bool  Nf_thr 
) const
private

Definition at line 692 of file StandardModel/src/StandardModel.cpp.

693{
694 int i, nfAls = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAls;
695 double als, alstmp, mutmp;
696 orders fullord;
697
698 for (i = 0; i < CacheSize; ++i)
699 if ((mu == als_cache[0][i]) && ((double) order == als_cache[1][i]) &&
700 (AlsMz == als_cache[2][i]) && (Mz == als_cache[3][i]) &&
701 (mut == als_cache[4][i]) && (mub == als_cache[5][i]) &&
702 (muc == als_cache[6][i]) && (double) true == als_cache[7][i]
703 && (double) Nf_thr == als_cache[8][i] && alphaMz() == als_cache[9][i])
704 return als_cache[10][i];
705
706 switch (order)
707 {
708 case NNNLO:
709 if (nfAls == nfmu)
710 als = AlsEWithInit(mu, AlsMz, Mz, nfAls, order);
711 fullord = FullOrder(order);
712 if (nfAls > nfmu) {
713 mutmp = BelowTh(Mz);
714 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
715 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAls), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
716 for (i = nfAls - 1; i > nfmu; i--) {
717 mutmp = BelowTh(mutmp - MEPS);
718 alstmp = AlsEWithInit(mutmp, alstmp, AboveTh(mutmp) - MEPS, i, realorder);
719 alstmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), alstmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
720 }
721 als = AlsEWithInit(mu, alstmp, AboveTh(mu) - MEPS, nfmu, order);
722 }
723
724 if (nfAls < nfmu) {
725 mutmp = AboveTh(Mz) - MEPS;
726 alstmp = AlsEWithInit(mutmp, AlsMz, Mz, nfAls, realorder);
727 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
728 for (i = nfAls + 1; i < nfmu; i++) {
729 mutmp = AboveTh(mutmp) - MEPS;
730 alstmp = AlsEWithInit(mutmp, alstmp, BelowTh(mutmp) + MEPS, i, realorder);
731 alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
732 }
733 als = AlsEWithInit(mu, alstmp, BelowTh(mu) + MEPS, nfmu, order);
734 }
735
737 als_cache[0][0] = mu;
738 als_cache[1][0] = (double) order;
739 als_cache[2][0] = AlsMz;
740 als_cache[3][0] = Mz;
741 als_cache[4][0] = mut;
742 als_cache[5][0] = mub;
743 als_cache[6][0] = muc;
744 als_cache[7][0] = (double) true;
745 als_cache[8][0] = (double) Nf_thr;
746 als_cache[9][0] = alphaMz();
747 als_cache[10][0] = als;
748
749 return als;
750 default:
751 throw std::runtime_error("StandardModel::AlsEByOrder(): " + orderToString(order) + " is not implemented.");
752 }
753}
const 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:709
const double MassOfNf(int nf) const
The Mbar mass of the heaviest quark in the theory with Nf active flavour.
Definition: QCD.cpp:745
double als_cache[11][CacheSize]
Cache for .
const double AlsEWithInit(double mu, double alsi, double mu_i, const int nf_i, orders order) const

◆ AlsEWithInit()

const double StandardModel::AlsEWithInit ( double  mu,
double  alsi,
double  mu_i,
const int  nf_i,
orders  order 
) const
private

Definition at line 755 of file StandardModel/src/StandardModel.cpp.

756{
757 double nf = (double) nf_i, alei = Ale(mu_i, FULLNLO); // CHANGE ME!
758 double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
759 double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
760 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
761 double logv = log(v), logve = log(ve);
762 double rho = 1. / (1. + b00e * alei / b00s / alsi);
763 double als = AlsWithInit(mu, alsi, mu_i, nf, order);
764 double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
765
766 switch (order)
767 {
768 case NNNLO:
769 als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
770 (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
771 b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
772 b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
773 break;
774 case FULLNNNLO:
775 return (AlsWithInit(mu, alsi, mu_i, nf_i, LO) + AlsWithInit(mu, alsi, mu_i, nf_i, NLO)+ AlsWithInit(mu, alsi, mu_i, nf_i, NNLO) + AlsEWithInit(mu, alsi, mu_i, nf_i, NNNLO));
776 default:
777 throw std::runtime_error("StandardModel::AlsEWithInit(): " + orderToString(order) + " is not implemented.");
778 }
779
780 return (als);
781}
const double AlsWithInit(const double mu, const double alsi, const double mu_i, const int nf, const orders order) const
Computes the running strong coupling from in the scheme, where it is forbidden to across a flavour...
Definition: QCD.cpp:627

◆ Alstilde5()

const 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 951 of file StandardModel/src/StandardModel.cpp.

952{
953 double mu_0 = Mz;
954 double alphatilde_e = alphaMz()/4./M_PI;
955 double alphatilde_s = AlsMz/4./M_PI;
956 unsigned int nf = 5;
957
958 double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
959 B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
960
961 double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
962
963 double B10soB00s = B10S / B00S;
964 double B01soB00e = B01S/B00E;
965
966 double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
967 double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
968 double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
969
970 double logve = log(ve);
971 double logvs = log(vs);
972 double logeos = log(ve/vs);
973 double logsoe = log(vs/ve);
974 double asovs = alphatilde_s/vs;
975 double aeove = alphatilde_e/ve;
976
977 double result = 0;
978
979 result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
980 + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
981 + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
982 + ps * ve * logve) * B01S * B10S/(B00E * B00S))
983 + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
984 - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
985 + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
986 + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
987 + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
988 + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
989 return (result);
990}
const double Beta2(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:611
const double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:606
const double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:601

◆ amuon()

const double StandardModel::amuon ( ) const
virtual

The computation of the anomalous magnetic moment of the muon \(a_\mu=(g_\mu-2)/2\).

Returns
\(a_\mu=(g_\mu-2)/2\)

Definition at line 2441 of file StandardModel/src/StandardModel.cpp.

2442{
2443
2444// output
2445 double amu;
2446
2447// -----------------------------------------------------------------
2448// qed contributions
2449 double amuqed,alfa0pi;
2450
2451// ew contributions
2452 double amuew,amuew1,amuew2b,amuew2f,amuew2,amuew3,cft,cf,corr1amuew2, corr2amuew2,corrwaamuew2,al,aq,b1; //,b2;
2453
2454// qcd contributions
2455 double amuhad,amuhhovp,amuhholbl,amuhho,amuhlo;
2456
2457// -----------------------------------------------------------------
2458// numerical constants
2459 const double sn2=0.2604341;
2460
2461// -----------------------------------------------------------------
2462// SM parameters
2463
2464// light quark masses. constituent masses
2465 const double umass=0.3;
2466 const double dmass=0.3;
2467 const double smass=0.5;
2468
2469 const double mum=leptons[MU].getMass(),taum=leptons[TAU].getMass();
2470 const double cqm=quarks[CHARM].getMass(),bqm=quarks[BOTTOM].getMass();
2471
2472// all fermion masses (constituent masses for u,d,s. for the other from model)
2473 double fermmass[9]={leptons[ELECTRON].getMass(),mum,taum,
2474 dmass,umass,
2475 smass,cqm,
2476 bqm,mtpole};
2477
2478// w mass and on-shell weak angle
2479 double MwSM, s2;
2480
2481// running of alfa_qed and dummy variable
2482 double aqed;
2483
2484// for the 2-loop bosonic corrections
2485 double a2l[4]={0.,0.,0.,0.},b2l[4]={0.,0.,0.,0.},sw2l[4]={0.,0.,0.,0.};
2486
2487// for the 2-loop corrections from the renormalization of weak angle
2488 double c2lren[6]={0.,0.,0.,0.,0.,0.};
2489
2490// w mass
2491 MwSM=Mw();
2492
2493 s2=1.0 - MwSM*MwSM/Mz/Mz;
2494
2495//------------------------------------------------------------------
2496// qed contribution to amu (arxiv: hep-ph/0606174)
2497 alfa0pi=ale/M_PI;
2498
2499 amuqed=alfa0pi*(0.5+alfa0pi*(0.765857410+alfa0pi*(24.05050964+
2500 + alfa0pi*(130.8055+663.0*alfa0pi))));
2501
2502//-----------------------------------------------------------------
2503// one-loop ew correction(phys.rev.lett. 76,3267 (1996))
2504
2505 amuew1=5.0*GF*mum*mum/(24.0*sqrt(2.0)*M_PI*M_PI)*(1.0+
2506 + 0.2*(1.0-4.0*s2)*(1.0-4.0*s2));
2507
2508//-----------------------------------------------------------------
2509// two-loop computation
2510
2511// these depend on aqed and since we are going to include also three-loop
2512// effects we need to include in the two-loop results the running of aqed at
2513// 1-loop up to the scale mum
2514//-----------------------------------------------------------------
2515// running of alpha em down to mu mass (1-loop)
2516
2517 aqed = 1.0/ale + 2.0 * log(fermmass[0]/mum)/3.0/M_PI;
2518
2519 aqed = 1.0/aqed;
2520
2521//-----------------------------------------------------------------
2522// two-loop ew bosonic correction(phys.rev.lett. 76,3267 (1996))
2523
2524// previous definitions
2525 a2l[0]=19.0/36.0-99.0*sn2/8.0-1.0*2.0*log(mHl/MwSM)/24.0;
2526
2527 b2l[0]=155.0/192.0+3.0*M_PI*M_PI/8.0-9.0*sn2/8.0+3.0*2.0*pow(log(mHl/MwSM),2)/2.0-21.0*2.0*log(mHl/MwSM)/16.0;
2528
2529 sw2l[0]=1.0/s2;
2530
2531 a2l[1]=-859.0/18.0+11.0*M_PI/sqrt(3.0)+20.0*M_PI*M_PI/9.0+ 393.0*sn2/8.0-65.0*2.0*log(MwSM/mum)/9.0+ 31.0*2.0*log(mHl/MwSM)/72.0;
2532
2533 b2l[1]=433.0/36.0+5.0*M_PI*M_PI/24.0-51.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/8.0+9.0*2.0*log(mHl/MwSM)/4.0;
2534
2535 sw2l[1]=1.0;
2536
2537 a2l[2]=165169.0/1080.0-385.0*M_PI/(6.0*sqrt(3.0))-29.0*M_PI*M_PI/6.0+ 33.0*sn2/8.0+92.0*2.0*log(MwSM/mum)/9.0- 133.0*2.0*log(mHl/MwSM)/72.0;
2538
2539 b2l[2]=-431.0/144.0+3.0*M_PI*M_PI/8.0+315.0*sn2/8.0+ 3.0*4.0*pow(log(mHl/MwSM),2)/2.0-11.0*2.0*log(mHl/MwSM)/8.0;
2540
2541 sw2l[2]=s2;
2542
2543 a2l[3]=-195965.0/864.0+265.0*M_PI/(3.0*sqrt(3.0))+163.0*M_PI*M_PI/18.0+ 223.0*sn2/12.0-184.0*2.0*log(MwSM/mum)/9.0- 5.0*2.0*log(mHl/MwSM)/8.0;
2544
2545 b2l[3]=433.0/216.0+13.0*M_PI*M_PI/24.0+349.0*sn2/24.0+ 21.0*4.0*pow(log(mHl/MwSM),2)/8.0-49.0*2.0*log(mHl/MwSM)/12.0;
2546
2547 sw2l[3]=s2*s2;
2548
2549// computation
2550
2551 amuew2b=0.0;
2552
2553 for (int i = 0; i < 4; ++i) {
2554 amuew2b=amuew2b+a2l[i]*sw2l[i]+(MwSM*MwSM/mHl/mHl)*b2l[i]*sw2l[i];
2555 }
2556
2557// the contribution with the running of aqed up to the mu scale
2558 amuew2b=mum*mum*aqed*GF*amuew2b/(8.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2559
2560//-----------------------------------------------------------------
2561// two-loop ew fermionic correction(phys.rev.d 52,r2619(1995)
2562
2563// contribution from higgs boson diagram
2564 if (mHl < (mtpole-10.0)) {
2565 cft=-104.0/45.0-16.0*2.0*log(mtpole/mHl)/15.0;
2566 } else if (mHl > (mtpole+10)) {
2567 cft=-(mtpole*mtpole/mHl/mHl)*(24.0/5.0+8.0*M_PI*M_PI/15.0+
2568 + 8.0/5.0*pow(2.0*log(mHl/mtpole)-1.0,2));
2569 } else {
2570 cft=-(32.0/5.0)*(1.0-9.0*sn2/4.0);
2571 }
2572
2573 cf=pow((umass*cqm*Mz),(4.0/3.0));
2574
2575 cf=cf/(pow((dmass*smass*bqm),(1.0/3.0))*mum*mum*taum);
2576
2577 cf=-18.0*log(cf)/5.0-3.0*mtpole*mtpole/(16.0*s2*MwSM*MwSM)- 3.0*2.0*log(mtpole/MwSM)/(10.0*s2)- 8.0*2.0*log(mtpole/Mz)/5.0-41.0/5.0-7.0/(10.0*s2)+ 8.0*M_PI*M_PI/15.0+cft;
2578
2579// the contribution with the running of aqed up to the mu scale
2580 amuew2f=5.0*GF*mum*mum*cf*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI);
2581
2582//-----------------------------------------------------------------
2583// corrections from hadronic loops (phys.rev.d 67,073006(2003))
2584// i also include the running here even though in the previous reference seems that it is not included
2585// first family (eqs. (60) and (61))
2586 corr1amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(8.41- log(pow(umass,8)/(pow(mum,6)*pow(dmass,2)))-17.0/2.0);
2587// second family (eqs. (65) and (66))
2588 corr2amuew2=-aqed*GF*mum*mum/(8.0*M_PI*M_PI*M_PI*sqrt(2.0))*(17.1- log(pow(cqm,8)/(pow(mum,6)*pow(smass,2)))-47.0/6.0+8.0*M_PI*M_PI/9.0);
2589
2590//-----------------------------------------------------------------
2591// corrections from the renormalization of the weak mixing
2592// terms prop. to (1-4s2) included in eq. (7) of phys.rev.d 67,073006(2003)
2593// and neglected in the previous references
2594
2595 corrwaamuew2=-43.0*31.0*(1.0-4.0*s2)*(1.0-4.0*s2)/(215.0*3.0)*log(Mz/mum);
2596
2597 c2lren[0]=(72.0/135.0)*(-1.0+2.0*s2)*(1.0-4.0*s2); //leptons
2598 c2lren[1]=(72.0/135.0)*(-1.0+2.0*s2/3.0)*(1.0-4.0*s2); //d-quark
2599 c2lren[2]=-(144.0/135.0)*(1.0-4.0*s2/3.0)*(1.0-4.0*s2); //u-quark
2600 c2lren[3]=c2lren[1];//d-quark
2601 c2lren[4]=c2lren[2]; //u-quark
2602 c2lren[5]=c2lren[1]; //d-quark
2603
2604 for (int i = 2; i < 8; ++i) {
2605 corrwaamuew2=corrwaamuew2+c2lren[i-2]*log(Mz/fermmass[i]);
2606 }
2607
2608 corrwaamuew2=5*GF*mum*mum*aqed/(24.0*sqrt(2.0)*M_PI*M_PI*M_PI)*corrwaamuew2;
2609
2610// finally i also add the small correction to the eq.8
2611 corrwaamuew2=corrwaamuew2-0.2e-11;
2612
2613//-----------------------------------------------------------------
2614// total 2-loop ew contribution
2615 amuew2=amuew2b+amuew2f+corr1amuew2+corr2amuew2+corrwaamuew2;
2616
2617//-----------------------------------------------------------------
2618// three-loop ew correction(phys.rev.d 67,073006(2003)
2619
2620 al=2789.0*log(Mz/mum)*log(Mz/mum)/90.0- 302.0*log(Mz/taum)*log(Mz/taum)/45.0+ 72.0*log(Mz/taum)*log(Mz/mum)/5.0;
2621
2622 aq=-2662.0*log(Mz/bqm)*log(Mz/bqm)/1215.0+11216.0*log(Mz/cqm)*log(Mz/cqm)/1215.0+1964.0*log(Mz/umass)*log(Mz/umass)/405.0+24.0*log(Mz/bqm)*log(Mz/mum)/5.0-96.0*log(Mz/cqm)*log(Mz/mum)/5.0-48.0*log(Mz/umass)*log(Mz/mum)/5.0+32.0*log(Mz/bqm)*log(Mz/cqm)/405.0+32.0*log(Mz/bqm)*log(Mz/umass)/135.0;
2623
2624 b1=-179.0/45.0*(log(Mz/bqm)*log(Mz/bqm)/3.0+log(Mz/taum)*log(Mz/taum)+4.0*log(Mz/cqm)*log(Mz/cqm)/3.0+2.0*log(Mz/umass)*log(Mz/umass)+2.0*log(Mz/mum)*log(Mz/mum))+2.0/5.0*(log(bqm/taum)*log(bqm/taum)+4.0/3.0*log(bqm/cqm)*log(bqm/cqm)+2.0*log(bqm/umass)*log(bqm/umass)+2.0*log(bqm/mum)*log(bqm/mum) )-8.0/5.0*(2.0*log(cqm/umass)*log(cqm/umass)+2.0*log(cqm/mum)*log(cqm/mum))+6.0/5.0*(4.0/3.0*log(taum/cqm)*log(taum/cqm)+2.0*log(taum/umass)*log(taum/umass)+2.0*log(taum/mum)*log(taum/mum))-8.0*log(umass/mum)*log(umass/mum)/5.0;
2625
2626 // b2 is not used, as it can be absorved in the two loop part if alpha(m_mu) is used instead of alpha(Mz), as done above
2627 // b2=2.0/5.0*(2.0*log(Mz/mum)+2.0*log(Mz/umass)+4.0*log(Mz/cqm)/3.0+log(Mz/taum)+log(Mz/bqm)/3.0)*(215.0*log(Mz/mum)/9.0-4.0*log(Mz/umass)-8.0*log(Mz/cqm)+6.0*log(Mz/taum)+2.0*log(Mz/bqm));
2628
2629// the final correction(it is implied aqed at mum for the 2-loop
2630// correction
2631
2632 amuew3=amuew1*(ale*ale/M_PI/M_PI)*(al+aq+b1);
2633
2634//-----------------------------------------------------------------
2635// total ew correction
2636
2637 amuew=amuew1+amuew2+amuew3;
2638
2639//-----------------------------------------------------------------
2640// hadronic contributions (arxiv: 0908.4300 & 1001.5401 [hep-ph])
2641
2642// leading order: vacuum polarization (arxiv: 0908.4300 [hep-ph])
2643 amuhlo=6955.e-11;
2644
2645// higher order: vacuum polarization
2646 amuhhovp=-97.9e-11;
2647
2648// higher order: light-by-light
2649 amuhholbl=105.e-11;
2650
2651 amuhho=amuhhovp+amuhholbl;
2652
2653// total hadronic contribution
2654
2655 amuhad=amuhlo+amuhho;
2656
2657//-----------------------------------------------------------------
2658// final value for the muon (g-2)/2
2659
2660 amu=amuqed+amuew+amuhad;
2661
2662//-----------------------------------------------------------------
2663
2664 return amu;
2665
2666}
@ BOTTOM
Definition: QCD.h:329
@ CHARM
Definition: QCD.h:326
Particle quarks[6]
The vector of all SM quarks.
Definition: QCD.h:1027
A class for , the pole mass of the top quark.
Definition: masses.h:164

◆ Beta_e()

const 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 660 of file StandardModel/src/StandardModel.cpp.

661{
662 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
663 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
664 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
665 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
666
667 switch(nm)
668 {
669 case 00:
670 return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
671 case 10:
672 return(4. * (Qbar4 * Nc + 3.));
673 case 01:
674 return(4. * CF * Nc * Qbar2);
675 default:
676 throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
677 }
678}
double CF
Definition: QCD.h:1026
double Nc
The number of colours.
Definition: QCD.h:1025

◆ Beta_s()

const 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 632 of file StandardModel/src/StandardModel.cpp.

633{
634 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
635 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
636 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
637 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
638
639 switch(nm)
640 {
641 case 00:
642 return(Beta0((double) nf));
643 case 10:
644 return(Beta1((double) nf));
645 case 20:
646 return(Beta2((double) nf));
647 case 30:
648 return(Beta3((double) nf));
649 case 01:
650 return(-4. * TF * Qbar2 );
651 case 11:
652 return((4. * CF - 8. * CA) * TF * Qbar2 );
653 case 02:
654 return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
655 default:
656 throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
657 }
658}
double CA
Definition: QCD.h:1026
double TF
Definition: QCD.h:1026
const double Beta3(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:618

◆ BrHtobb()

const double StandardModel::BrHtobb ( ) const
virtual

The Br \((H\to b \bar{b})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to b \bar{b})\)

Definition at line 3697 of file StandardModel/src/StandardModel.cpp.

3698{
3699 return GammaHtobb()/GammaHTot();
3700}
virtual const double GammaHtobb() const
The in the Standard Model.
virtual const double GammaHTot() const
The total Higgs width in the Standard Model.

◆ BrHtocc()

const double StandardModel::BrHtocc ( ) const
virtual

The Br \((H\to c \bar{c})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to c \bar{c})\)

Definition at line 3687 of file StandardModel/src/StandardModel.cpp.

3688{
3689 return GammaHtocc()/GammaHTot();
3690}
virtual const double GammaHtocc() const
The in the Standard Model.

◆ BrHtogaga()

const double StandardModel::BrHtogaga ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \gamma \gamma)\)

Definition at line 3672 of file StandardModel/src/StandardModel.cpp.

3673{
3674 return GammaHtogaga()/GammaHTot();
3675}
virtual const double GammaHtogaga() const
The in the Standard Model.

◆ BrHtogg()

const double StandardModel::BrHtogg ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

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

Definition at line 3652 of file StandardModel/src/StandardModel.cpp.

3653{
3654 return GammaHtogg()/GammaHTot();
3655}
virtual const double GammaHtogg() const
The in the Standard Model.

◆ BrHtomumu()

const double StandardModel::BrHtomumu ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \mu^+ \mu^-)\)

Definition at line 3677 of file StandardModel/src/StandardModel.cpp.

3678{
3679 return GammaHtomumu()/GammaHTot();
3680}
virtual const double GammaHtomumu() const
The in the Standard Model.

◆ BrHtoss()

const double StandardModel::BrHtoss ( ) const
virtual

The Br \((H\to s \bar{s})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to s \bar{s})\)

Definition at line 3692 of file StandardModel/src/StandardModel.cpp.

3693{
3694 return GammaHtoss()/GammaHTot();
3695}
virtual const double GammaHtoss() const
The in the Standard Model.

◆ BrHtotautau()

const double StandardModel::BrHtotautau ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to \tau^+ \tau^-)\)

Definition at line 3682 of file StandardModel/src/StandardModel.cpp.

3683{
3684 return GammaHtotautau()/GammaHTot();
3685}
virtual const double GammaHtotautau() const
The in the Standard Model.

◆ BrHtoWWstar()

const double StandardModel::BrHtoWWstar ( ) const
virtual

The Br \((H\to W W^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to W W^*)\)

Definition at line 3662 of file StandardModel/src/StandardModel.cpp.

3663{
3664 return GammaHtoWWstar()/GammaHTot();
3665}
virtual const double GammaHtoWWstar() const
The in the Standard Model.

◆ BrHtoZga()

const double StandardModel::BrHtoZga ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to Z \gamma)\)

Definition at line 3667 of file StandardModel/src/StandardModel.cpp.

3668{
3669 return GammaHtoZga()/GammaHTot();
3670}
virtual const double GammaHtoZga() const
The in the Standard Model.

◆ BrHtoZZstar()

const double StandardModel::BrHtoZZstar ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
Br \((H\to Z Z^*)\)

Definition at line 3657 of file StandardModel/src/StandardModel.cpp.

3658{
3659 return GammaHtoZZstar()/GammaHTot();
3660}
virtual const double GammaHtoZZstar() const
The in the Standard Model.

◆ BrW()

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

The branching ratio of the \(W\) boson decaying into a SM fermion pair, \(Br(W\to f_i f_j)\).

Returns
\(Br(W\to f_i f_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1289 of file StandardModel/src/StandardModel.cpp.

1290{
1291 double GammW = GammaW();
1292 double GammWij = GammaW(fi, fj);
1293
1294 return GammWij/GammW;
1295}
virtual const double GammaW() const
The total width of the boson, .

◆ c02()

const 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 [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(s_0^2\)

Definition at line 1020 of file StandardModel/src/StandardModel.cpp.

1021{
1022 return ( 1.0 - s02());
1023}
const double s02() const
The square of the sine of the weak mixing angle defined without weak radiative corrections.

◆ 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 3552 of file StandardModel.h.

3553 {
3554 if (scheme.compare("NORESUM") == 0
3555 || scheme.compare("OMSI") == 0
3556 || scheme.compare("INTERMEDIATE") == 0
3557 || scheme.compare("OMSII") == 0
3558 || scheme.compare("APPROXIMATEFORMULA") == 0)
3559 return true;
3560 else
3561 return false;
3562 }

◆ 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 553 of file StandardModel/src/StandardModel.cpp.

554{
555 return (QCD::CheckFlags());
556}
virtual bool CheckFlags() const
A method to check the sanity of the set of model flags.
Definition: QCD.cpp:517

◆ 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 CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, NPDF2, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFTd6, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 370 of file StandardModel/src/StandardModel.cpp.

371{
372 for (int i = 0; i < NSMvars; i++) {
373 if (DPars.find(SMvars[i]) == DPars.end()) {
374 std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
377 }
378 }
379 return (QCD::CheckParameters(DPars));
380}
std::map< std::string, double > DPars
Definition: Minimal.cpp:11
void addMissingModelParameter(const std::string &missingParameterName)
Definition: Model.h:250
void raiseMissingModelParameterCount()
Definition: Model.h:260
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:421
static std::string SMvars[NSMvars]
A string array containing the labels of the model parameters in StandardModel.
static const int NSMvars
The number of the model parameters in StandardModel.

◆ 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 562 of file StandardModel/src/StandardModel.cpp.

563{
564 // 11 parameters in QCD:
565 // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
566 // mut, mub, muc
567 // 21 parameters in StandardModel
568 // GF, ale, dAle5Mz, mHl,
569 // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
570 // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b, delGammaWlv, delGammaWqq,
571 // 3 flags in StandardModel
572 // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
573
574 // Note: When modifying the array below, the constant NumSMParams has to
575 // be modified accordingly.
576 double SMparams[NumSMParamsForEWPO] = {
578 mHl, mtpole,
583 leptons[MU].getMass(),
585 quarks[UP].getMass(),
590 mut, mub, muc,
595 };
596
597 // check updated parameters
598 bool bNotUpdated = true;
599 for (int i = 0; i < NumSMParamsForEWPO; ++i) {
600 if (SMparamsForEWPO_cache[i] != SMparams[i]) {
601 SMparamsForEWPO_cache[i] = SMparams[i];
602 bNotUpdated &= false;
603 }
604 }
605
606 return bNotUpdated;
607}
@ UP
Definition: QCD.h:324
@ DOWN
Definition: QCD.h:325
@ STRANGE
Definition: QCD.h:327
double mtpole
The pole mass of the top quark.
Definition: QCD.h:1020
double SMparamsForEWPO_cache[NumSMParamsForEWPO]
double Mw_inp
The mass of the boson in GeV used as input for FlagMWinput = TRUE.
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...
static const int NumSMParamsForEWPO
The number of the SM parameters that are relevant to the EW precision observables.

◆ computeBrHto4f()

const double StandardModel::computeBrHto4f ( ) const
inline

The Br \((H\to 4f)\) 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 4f)\) in the Standard Model

Definition at line 2978 of file StandardModel.h.

2979 {
2980 return 2.406e-01; // Mh=125.1 GeV
2981 }

◆ computeBrHto4l2()

const double StandardModel::computeBrHto4l2 ( ) const
inline

The Br \((H\to 4l)\) \(l=e,\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 4l)\) \(l=e,\muu\) in the Standard Model

Definition at line 2945 of file StandardModel.h.

2946 {
2947 return 1.252e-04; // Mh=125.1 GeV
2948 }

◆ computeBrHto4l3()

const double StandardModel::computeBrHto4l3 ( ) const
inline

The Br \((H\to 4l)\) \(l=e,\mu,\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 4l)\) \(l=e,\mu,\tau\) in the Standard Model

Definition at line 2956 of file StandardModel.h.

2957 {
2958 return 2.771e-04; // Mh=125.1 GeV
2959 }

◆ computeBrHto4q()

const double StandardModel::computeBrHto4q ( ) const
inline

The Br \((H\to 4q)\) 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 4q)\) in the Standard Model

Definition at line 2967 of file StandardModel.h.

2968 {
2969 return 1.098e-01; // Mh=125.1 GeV
2970 }

◆ computeBrHto4v()

const double StandardModel::computeBrHto4v ( ) const
inline

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

Returns
Br \((H\to 4\nu)\) in the Standard Model

Definition at line 2901 of file StandardModel.h.

2902 {
2903 return 1.06e-3;
2904 }

◆ computeBrHtobb()

const 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 2888 of file StandardModel.h.

2889 {
2890 return 5.807e-1; // Mh=125.1 GeV
2891 //return 5.67e-1; // Mh=125.6 GeV
2892 }

◆ computeBrHtocc()

const 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 2865 of file StandardModel.h.

2866 {
2867 return 2.883e-2; // Mh=125.1 GeV
2868 //return 2.86e-2; // Mh=125.6 GeV
2869 }

◆ computeBrHtoevmuv()

const double StandardModel::computeBrHtoevmuv ( ) const
inline

The Br \((H\to e \nu \mu \nu)\) 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 e \nu \mu \nu)\) in the Standard Model

Definition at line 2912 of file StandardModel.h.

2913 {
2914 return 2.539e-03; // Mh=125.1 GeV
2915 }

◆ computeBrHtogaga()

const 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 2831 of file StandardModel.h.

2832 {
2833 return 2.27e-3; // Mh=125.1 GeV
2834 }

◆ computeBrHtogg()

const 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 2784 of file StandardModel.h.

2785 {
2786 return 8.179e-2; // Mh=125.1 GeV
2787 }

◆ computeBrHtollvv2()

const double StandardModel::computeBrHtollvv2 ( ) const
inline

The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\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 l^+ l^- \nu \nu)\) \(l=e,\mu\) in the Standard Model

Definition at line 2923 of file StandardModel.h.

2924 {
2925 return 1.063e-02; // Mh=125.1 GeV
2926 }

◆ computeBrHtollvv3()

const double StandardModel::computeBrHtollvv3 ( ) const
inline

The Br \((H\to l^+ l^- \nu \nu)\) \(l=e,\mu,\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 l^+ l^- \nu \nu)\) \(l=e,\mu,\tau\) in the Standard Model

Definition at line 2934 of file StandardModel.h.

2935 {
2936 return 2.356e-02; // Mh=125.1 GeV
2937 }

◆ computeBrHtomumu()

const 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 2842 of file StandardModel.h.

2843 {
2844 return 2.17e-4; // Mh=125.1 GeV
2845 }

◆ computeBrHtoss()

const 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 2877 of file StandardModel.h.

2878 {
2879 return 4.0e-4;
2880 }

◆ computeBrHtotautau()

const 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 2853 of file StandardModel.h.

2854 {
2855 return 6.256e-2; // Mh=125.1 GeV
2856 //return 6.22e-2; // Mh=125.6 GeV
2857 }

◆ computeBrHtoWW()

const 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 2795 of file StandardModel.h.

2796 {
2797 //return 2.23e-1; // Mh=125.5 GeV
2798 return 2.154e-1; // Mh=125.1 GeV
2799 }

◆ computeBrHtoZga()

const 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 2819 of file StandardModel.h.

2820 {
2821 return 1.541e-3; // Mh=125.1 GeV
2822 //return 1.59e-3; // Mh=125.6 GeV
2823 }

◆ computeBrHtoZZ()

const 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 2807 of file StandardModel.h.

2808 {
2809 return 2.643e-2; // Mh=125.1 GeV
2810 //return 2.79e-2; // Mh=125.6 GeV
2811 }

◆ computeCKM()

void StandardModel::computeCKM ( )
protectedvirtual

The method to compute the CKM matrix.

Definition at line 382 of file StandardModel/src/StandardModel.cpp.

383{
384 if (requireCKM) {
385 if (FlagWolfenstein) {
387 Vus = myCKM.getV_us().abs();
388 Vcb = myCKM.getV_cb().abs();
389 Vub = myCKM.getV_ub().abs();
391 } else if (FlagUseVud) {
394 A = myCKM.getA();
395 rhob = myCKM.getRhoBar();
396 etab = myCKM.getEtaBar();
397 Vus = myCKM.getV_us().abs();
398 } else {
401 A = myCKM.getA();
402 rhob = myCKM.getRhoBar();
403 etab = myCKM.getEtaBar();
404 Vud = myCKM.getV_ud().abs();
405 }
406 }
407 myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
408}
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
const gslpp::complex getV_ud() const
A member for returning the value of the CKM element .
Definition: CKM.h:202
const gslpp::complex getV_us() const
A member for returning the value of the CKM element .
Definition: CKM.h:211
const double computeGamma() const
The CKM angle .
Definition: CKM.cpp:125
const gslpp::complex getV_cb() const
A member for returning the value of the CKM element .
Definition: CKM.h:247
const gslpp::complex getV_ub() const
A member for returning the value of the CKM element .
Definition: CKM.h:220
const double getA() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:97
void computeCKM(double Vus_v, double Vcb_v, double Vub_v, double gamma_v, bool useVud=false)
A set method to calculate the CKM matrix from CKM elements and .
Definition: CKM.cpp:86
const double getRhoBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:70
const double getLambda() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:88
const double getEtaBar() const
A member for returning the value of the Wolfenstein parameter .
Definition: CKM.h:79
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
double Vub
used as an input for FlagWolfenstein = FALSE
double gamma
used as an input for FlagWolfenstein = FALSE
double Vud
used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE
CKM myCKM
An object of type CKM.
double Vcb
used as an input for FlagWolfenstein = FALSE
double Vus
used as an input for FlagWolfenstein = FALSE

◆ 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 1161 of file StandardModel/src/StandardModel.cpp.

1163{
1164 if (flag_order[EW1])
1165 DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1166 else
1167 DeltaR_rem[EW1] = 0.0;
1168 if (flag_order[EW1QCD1])
1169 DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1170 else
1171 DeltaR_rem[EW1QCD1] = 0.0;
1172 if (flag_order[EW1QCD2])
1173 DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1174 else
1175 DeltaR_rem[EW1QCD2] = 0.0;
1176 if (flag_order[EW2])
1177 DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1178 else
1179 DeltaR_rem[EW2] = 0.0;
1180 if (flag_order[EW2QCD1])
1181 DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1182 else
1183 DeltaR_rem[EW2QCD1] = 0.0;
1184 if (flag_order[EW3])
1185 DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1186 else
1187 DeltaR_rem[EW3] = 0.0;
1188}
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .
double DeltaR_rem(const double Mw_i) const
Remainder contribution of to , denoted as .

◆ 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 1132 of file StandardModel/src/StandardModel.cpp.

1134{
1135 if (flag_order[EW1])
1136 DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1137 else
1138 DeltaRho[EW1] = 0.0;
1139 if (flag_order[EW1QCD1])
1140 DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1141 else
1142 DeltaRho[EW1QCD1] = 0.0;
1143 if (flag_order[EW1QCD2])
1144 DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1145 else
1146 DeltaRho[EW1QCD2] = 0.0;
1147 if (flag_order[EW2])
1148 DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1149 else
1150 DeltaRho[EW2] = 0.0;
1151 if (flag_order[EW2QCD1])
1152 DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1153 else
1154 DeltaRho[EW2QCD1] = 0.0;
1155 if (flag_order[EW3])
1156 DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1157 else
1158 DeltaRho[EW3] = 0.0;
1159}
double DeltaRho(const double Mw_i) const
Leading one-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading three-loop QCD contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading two-loop contribution of to , denoted as .
double DeltaRho(const double Mw_i) const
Leading two-loop QCD contribution of to , denoted as .

◆ computeGammaHgaga_tt()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3066 of file StandardModel.h.

3067 {
3068 return 662.84; // in eV for Mh=125 GeV
3069 //return 680.39; // in eV for Mh=126 GeV
3070 }

◆ computeGammaHgaga_tW()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3088 of file StandardModel.h.

3089 {
3090 return -6249.93; // in eV for Mh=125 GeV
3091 //return -6436.35; // in eV for Mh=126 GeV
3092 }

◆ computeGammaHgaga_WW()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3077 of file StandardModel.h.

3078 {
3079 return 14731.86; // in eV for Mh=125 GeV
3080 //return 15221.98; // in eV for Mh=126 GeV
3081 }

◆ computeGammaHgg_bb()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3011 of file StandardModel.h.

3012 {
3013 return 3.96; // in keV for Mh=125 GeV
3014 //return 3.95; // in keV for Mh=126 GeV
3015 }

◆ computeGammaHgg_tb()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3022 of file StandardModel.h.

3023 {
3024 return -42.1; // in keV for Mh=125 GeV
3025 //return -42.7; // in keV for Mh=126 GeV
3026 }

◆ computeGammaHgg_tt()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3000 of file StandardModel.h.

3001 {
3002 return 380.8; // in keV for Mh=125 GeV
3003 //return 389.6; // in keV for Mh=126 GeV
3004 }

◆ computeGammaHTotal()

const 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 2989 of file StandardModel.h.

2990 {
2991 return 4.101e-3; // Mh=125.1 GeV
2992 //return 4.15e-3; // Mh=125.6 GeV
2993 }

◆ computeGammaHZga_tt()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3033 of file StandardModel.h.

3034 {
3035 return 21.74; // in eV for Mh=125 GeV
3036 //return 23.51; // in eV for Mh=126 GeV
3037 }

◆ computeGammaHZga_tW()

const 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. [Heinemeyer:2013tqa]

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

Definition at line 3055 of file StandardModel.h.

3056 {
3057 return -780.4; // in eV for Mh=125 GeV
3058 //return -848.1; // in eV for Mh=126 GeV
3059 }

◆ computeGammaHZga_WW()

const 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. [Heinemeyer:2013tqa].

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

Definition at line 3044 of file StandardModel.h.

3045 {
3046 return 7005.6; // in eV for Mh=125 GeV
3047 //return 7648.4; // in eV for Mh=126 GeV
3048 }

◆ computeSigmabbH()

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

The bbH production cross section in the Standard Model.

Definition at line 2767 of file StandardModel.h.

2768 {
2769 if (sqrt_s == 13.0){
2770 return 0.4863; // in pb for Mh=125.09 GeV
2771 }
2772 else if (sqrt_s == 13.6) {
2773 return 0.566; // in pb for Mh=125.09 GeV (NLO+NNLLpart+ybyt matching)
2774 } else
2775 throw std::runtime_error("Bad argument in StandardModel::computeSigmabbH()");
2776 }

◆ computeSigmaggH()

const 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. [Heinemeyer:2013tqa] 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 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.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 2403 of file StandardModel.h.

2404 {
2405 if (sqrt_s == 7.0) {
2406 return 16.83; // in pb for Mh=125.1 GeV
2407 } else if (sqrt_s == 8.0) {
2408 return 21.40; // in pb for Mh=125.1 GeV
2409 } else if (sqrt_s == 13.0) {
2410 return 48.61; // in pb for Mh=125.09 GeV
2411 } else if (sqrt_s == 13.6) {
2412 return 52.17; // in pb for Mh=125.09 GeV
2413 } else if (sqrt_s == 14.0) {
2414 return 54.72; // in pb for Mh=125.09 GeV
2415 } else if (sqrt_s == 27.0) {
2416 return 146.65; // in pb for Mh=125.09 GeV
2417 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2418 return 740.3; // in pb for Mh=125. GeV
2419 } else if (sqrt_s == 1.96) {
2420 return 0.9493; // in pb for Mh=125 GeV
2421 } else
2422 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH()");
2423 }

◆ computeSigmaggH_bb()

const 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 For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

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

Definition at line 2465 of file StandardModel.h.

2466 {
2467 if (sqrt_s == 7.0) {
2468 return 0.04; // in pb for Mh=125.09 GeV
2469 } else if (sqrt_s == 8.0) {
2470 return 0.05; // in pb for Mh=125.09 GeV
2471 } else if (sqrt_s == 13.0) {
2472 return 0.10; // in pb for Mh=125.09 GeV
2473 } else if (sqrt_s == 13.6) {
2474 return 0.106; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2475 } else if (sqrt_s == 14.0) {
2476 return 0.11; // in pb for Mh=125.09 GeV
2477 } else if (sqrt_s == 27.0) {
2478 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2479 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2480 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2481 } else
2482 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_bb()");
2483 }
const double computeSigmaggH(const double sqrt_s) const
The ggH cross section in the Standard Model.
const double computeSigmaggH_bb(const double sqrt_s) const
The square of the bottom-quark contribution to the ggH cross section in the Standard Model.

◆ computeSigmaggH_tb()

const 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 For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

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

Definition at line 2495 of file StandardModel.h.

2496 {
2497 if (sqrt_s == 7.0) {
2498 return -0.66; // in pb for Mh=125.09 GeV
2499 } else if (sqrt_s == 8.0) {
2500 return -0.82; // in pb for Mh=125.09 GeV
2501 } else if (sqrt_s == 13.0) {
2502 return -1.73; // in pb for Mh=125.09 GeV
2503 } else if (sqrt_s == 13.6) {
2504 return -1.844; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2505 } else if (sqrt_s == 14.0) {
2506 return -1.92; // in pb for Mh=125.09 GeV
2507 } else if (sqrt_s == 27.0) {
2508 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2509 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2510 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2511 } else
2512 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tb()");
2513 }
const double computeSigmaggH_tb(const double sqrt_s) const
The top-bottom interference contribution to the ggH cross section in the Standard Model.

◆ computeSigmaggH_tt()

const 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 For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

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

Definition at line 2435 of file StandardModel.h.

2436 {
2437 if (sqrt_s == 7.0) {
2438 return 16.69; // in pb for Mh=125.09 GeV
2439 } else if (sqrt_s == 8.0) {
2440 return 21.20; // in pb for Mh=125.09 GeV
2441 } else if (sqrt_s == 13.0) {
2442 return 47.94; // in pb for Mh=125.09 GeV
2443 } else if (sqrt_s == 13.6) {
2444 return 51.534; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2445 } else if (sqrt_s == 14.0) {
2446 return 53.93; // in pb for Mh=125.09 GeV
2447 } else if (sqrt_s == 27.0) {
2448 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2449 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2450 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2451 } else
2452 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tt()");
2453 }
const double computeSigmaggH_tt(const double sqrt_s) const
The square of the top-quark contribution to the ggH cross section in the Standard Model.

◆ computeSigmatHq()

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

The tHq production cross section in the Standard Model.

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

Definition at line 2748 of file StandardModel.h.

2749 {
2750 if (sqrt_s == 13.0) {
2751 return 0.07426; // in pb for Mh=125.09 GeV
2752 } else
2753 throw std::runtime_error("Bad argument in StandardModel::computeSigmatHq()");
2754 }

◆ computeSigmattH()

const 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. [Heinemeyer:2013tqa] . 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 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.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 2718 of file StandardModel.h.

2719 {
2720 if (sqrt_s == 7.0) {
2721 return 0.0861; // in pb for Mh=125.1 GeV
2722 //return 0.0851; // in pb for Mh=125.6 GeV
2723 } else if (sqrt_s == 8.0) {
2724 return 0.129; // in pb for Mh=125.1 GeV
2725 //return 0.1274; // in pb for Mh=125.6 GeV
2726 } else if (sqrt_s == 13.0) {
2727 return 0.5060; // in pb for Mh=125.1 GeV
2728 } else if (sqrt_s == 13.6) {
2729 return 0.5688; // in pb for Mh=125.09 GeV
2730 } else if (sqrt_s == 14.0) {
2731 return 0.6128; // in pb for Mh=125.09 GeV
2732 } else if (sqrt_s == 27.0) {
2733 return 2.86; // in pb for Mh=125.09 GeV
2734 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2735 return 37.9; // in pb for Mh=125. GeV
2736 } else if (sqrt_s == 1.96) {
2737 return 0.0043; // in pb for Mh=125 GeV
2738 } else
2739 throw std::runtime_error("Bad argument in StandardModel::computeSigmattH()");
2740 }

◆ computeSigmaVBF()

const 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. [Heinemeyer:2013tqa] . 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 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.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 2528 of file StandardModel.h.

2529 {
2530 if (sqrt_s == 7.0) {
2531 return 1.241; // in pb for Mh=125.09 GeV
2532 } else if (sqrt_s == 8.0) {
2533 return 1.601; // in pb for Mh=125.09 GeV
2534 } else if (sqrt_s == 13.0) {
2535 return 3.766; // in pb for Mh=125.09 GeV
2536 } else if (sqrt_s == 13.6) {
2537 return 4.075; // in pb for Mh=125.09 GeV
2538 } else if (sqrt_s == 14.0) {
2539 return 4.260; // in pb for Mh=125.09 GeV
2540 } else if (sqrt_s == 27.0) {
2541 return 11.838; // in pb for Mh=125.09 GeV
2542 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2543 return 82.0; // in pb for Mh=125. GeV
2544 } else if (sqrt_s == 1.96) {
2545 return 0.0653; // in pb for Mh=125 GeV
2546 } else
2547 throw std::runtime_error("Bad argument in StandardModel::computeSigmaVBF()");
2548 }

◆ computeSigmaWF()

const 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 For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

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

Definition at line 2561 of file StandardModel.h.

2562 {
2563 if (sqrt_s == 7.0) {
2564 return 0.946; // in pb for Mh=125 GeV
2565 } else if (sqrt_s == 8.0) {
2566 return 1.220; // in pb for Mh=125 GeV
2567 } else if (sqrt_s == 13.0) {
2568 return 2.882; // in pb for Mh=125 GeV
2569 } else if (sqrt_s == 13.6) {
2570 return 3.1088; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2571 } else if (sqrt_s == 14.0) {
2572 return 3.260; // in pb for Mh=125 GeV
2573 } else if (sqrt_s == 27.0) {
2574 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2575 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2576 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2577 } else if (sqrt_s == 1.96) {
2578 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaWF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2579 } else
2580 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWF()");
2581 }
const double computeSigmaVBF(const double sqrt_s) const
The VBF cross section in the Standard Model.
const double computeSigmaWF(const double sqrt_s) const
The W fusion contribution to higgs-production cross section in the Standard Model.

◆ computeSigmaWH()

const 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. [Heinemeyer:2013tqa] . 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 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.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 2641 of file StandardModel.h.

2642 {
2643 if (sqrt_s == 7.0) {
2644 return 0.577; // in pb for Mh=125.1 GeV
2645 //return 0.5688; // in pb for Mh=125.6 GeV
2646 } else if (sqrt_s == 8.0) {
2647 return 0.7027; // in pb for Mh=125.1 GeV
2648 //return 0.6931; // in pb for Mh=125.6 GeV
2649 } else if (sqrt_s == 13.0) {
2650 return 1.358; // in pb for Mh=125.09 GeV
2651 } else if (sqrt_s == 13.6) {
2652 return 1.453; // in pb for Mh=125.09 GeV
2653 } else if (sqrt_s == 14.0) {
2654 return 1.498; // in pb for Mh=125.09 GeV
2655 } else if (sqrt_s == 27.0) {
2656 return 3.397; // in pb for Mh=125.09 GeV
2657 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2658 return 15.9; // in pb for Mh=125. GeV
2659 } else if (sqrt_s == 1.96) {
2660 return 0.1295; // in pb for Mh=125 GeV
2661 } else
2662 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWH()");
2663 }

◆ computeSigmaZF()

const 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 For 13.6 TeV we follow what is done in some cases in the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1 and use linear interpolation between the values at 13 and 14 TeV

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

Definition at line 2594 of file StandardModel.h.

2595 {
2596 if (sqrt_s == 7.0) {
2597 return 0.333; // in pb for Mh=125 GeV
2598 } else if (sqrt_s == 8.0) {
2599 return 0.432; // in pb for Mh=125 GeV
2600 } else if (sqrt_s == 13.0) {
2601 return 1.049; // in pb for Mh=125 GeV
2602 } else if (sqrt_s == 13.6) {
2603 return 1.1342; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2604 } else if (sqrt_s == 14.0) {
2605 return 1.191; // in pb for Mh=125 GeV
2606 } else if (sqrt_s == 27.0) {
2607 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2608 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2609 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2610 } else if (sqrt_s == 1.96) {
2611 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaZF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2612 } else
2613 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZF()");
2614 }
const double computeSigmaZF(const double sqrt_s) const
The Z fusion contribution to higgs-production cross section in the Standard Model.

◆ computeSigmaZH()

const 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. [Heinemeyer:2013tqa] . 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 13.6 TeV we follow the LHC Higgs WG note: arXiv: 2402.09955 [hep-ph] V1: https://arxiv.org/pdf/2402.09955v1.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 2678 of file StandardModel.h.

2679 {
2680 if (sqrt_s == 7.0) {
2681 return 0.3341; // in pb for Mh=125.1 GeV
2682 //return 0.3299; // in pb for Mh=125.6 GeV
2683 } else if (sqrt_s == 8.0) {
2684 return 0.4142; // in pb for Mh=125.1 GeV
2685 //return 0.4091; // in pb for Mh=125.6 GeV
2686 } else if (sqrt_s == 13.0) {
2687 return 0.880; // in pb for Mh=125.09 GeV
2688 } else if (sqrt_s == 13.6) {
2689 return 0.9422; // in pb for Mh=125.09 GeV
2690 } else if (sqrt_s == 14.0) {
2691 return 0.981; // in pb for Mh=125.09 GeV
2692 } else if (sqrt_s == 27.0) {
2693 return 2.463; // in pb for Mh=125.09 GeV
2694 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2695 return 11.26; // in pb for Mh=125. GeV
2696 } else if (sqrt_s == 1.96) {
2697 return 0.0785; // in pb for Mh=125 GeV
2698 } else
2699 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZH()");
2700 }

◆ computeSigmaZWF()

const 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 2623 of file StandardModel.h.

2624 {
2625 return 0.;
2626 }

◆ computeYukawas()

void StandardModel::computeYukawas ( )
protectedvirtual

The method to compute the Yukawas matrix.

Reimplemented in SUSY.

Definition at line 416 of file StandardModel/src/StandardModel.cpp.

417{
418 if (requireYu || requireCKM) {
419 Yu.reset();
420 for (int i = 0; i < 3; i++) {
421 Yu.assign(i, i, this->getmq(quark(UP + 2 * i), v()/ sqrt(2.))/ v() * sqrt(2.));
422// std::cout << quarks[UP + 2 * i].getName() << " mass at EW scale is " << this->getmq(quark(UP + 2 * i), v() / sqrt(2.)) << std::endl;
423 }
424// std::cout << "(top MSbar mass is " << this->Mp2Mbar(this->getMtpole()) << ")" << std::endl;
425 Yu = Yu * myCKM.getCKM();
426 }
427 if (requireYd) {
428 Yd.reset();
429 for (int i = 0; i < 3; i++) {
430 Yd.assign(i, i, this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) / v() * sqrt(2.));
431// std::cout << quarks[DOWN + 2 * i].getName() << " mass at " << v() / sqrt(2) << " is " << this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) << std::endl;
432 }
433 }
434 if (requireYe) {
435 Ye = gslpp::matrix<gslpp::complex>::Id(3);
436 for (int i = 0; i < 3; i++)
437 Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
438 }
439 if (requireYn) {
440 Yn = gslpp::matrix<gslpp::complex>::Id(3);
441 for (int i = 0; i < 3; i++)
442 Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
443 Yn = Yn * myPMNS.getPMNS().hconjugate();
444 }
445}
const gslpp::matrix< gslpp::complex > getCKM() const
A member for returning the CKM matrix.
Definition: CKM.h:59
gslpp::matrix< gslpp::complex > getPMNS() const
A member for returning the PMNS matrix.
Definition: PMNS.h:42
bool requireYu
Switch for generating the Yukawa couplings to the up-type quarks.
Definition: QCD.h:1012
quark
An enum type for quarks.
Definition: QCD.h:323
bool requireYd
Switch for generating the Yukawa couplings to the down-type quarks.
Definition: QCD.h:1013
virtual const double getmq(const QCD::quark q, const double mu) const
The MSbar running quark mass computed at NLO.

◆ cW2() [1/2]

const double StandardModel::cW2 ( ) const
virtual

Definition at line 1087 of file StandardModel/src/StandardModel.cpp.

1088{
1089 return ( cW2(Mw()));
1090// return (1.0 - 0.2312); // FOR HEFFDF1 TEST
1091}

◆ cW2() [2/2]

const 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 1082 of file StandardModel/src/StandardModel.cpp.

1083{
1084 return ( Mw_i * Mw_i / Mz / Mz);
1085}

◆ Dalpha5hMz()

const double StandardModel::Dalpha5hMz ( ) const
virtual

The 5-quark contribution to the running of the em constant to the \(Z\) pole. \(\Delta\alpha_{had}^{(5)}(M_Z)\).

Depending on the flag MWinput this is given by the input parameter dAle5Mz (MWinput=false) or it is computed from Mw (MWinput=true)

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

Definition at line 1074 of file StandardModel/src/StandardModel.cpp.

1075{
1076 if (FlagMWinput){
1078 } else
1079 return dAle5Mz;
1080}
double dAlpha5hMw() const
The value of obtained from the -boson mass, using the full two-loop EW corrections.

◆ 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 [Czarnecki:1996ei] and [Harlander:1997zb].

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

Definition at line 2139 of file StandardModel/src/StandardModel.cpp.

2140{
2141 switch (q) {
2142 case QCD::UP:
2143 case QCD::CHARM:
2144 return ( -0.000113);
2145 case QCD::TOP:
2146 return ( 0.0);
2147 case QCD::DOWN:
2148 case QCD::STRANGE:
2149 return ( -0.000160);
2150 case QCD::BOTTOM:
2151 return ( -0.000040);
2152 default:
2153 throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2154 }
2155}
@ TOP
Definition: QCD.h:328

◆ DeltaAlpha()

const 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 932 of file StandardModel/src/StandardModel.cpp.

933{
936 return DeltaAlpha_cache;
937
938 double Mz2 = Mz*Mz;
940 useDeltaAlpha_cache = true;
941 return DeltaAlpha_cache;
942}
const double DeltaAlphaTop(const double s) const
Top-quark contribution to the electromagnetic coupling , denoted as .
const double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...

◆ DeltaAlphaL5q()

const 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 907 of file StandardModel/src/StandardModel.cpp.

908{
909 double Mz2 = Mz*Mz;
910 return (DeltaAlphaLepton(Mz2) + dAl5hMz);
911}
double dAl5hMz
The five-flavour hadronic contribution to the electromagnetic coupling, . (Non-input parameter)
const double DeltaAlphaLepton(const double s) const
Leptonic contribution to the electromagnetic coupling , denoted as .

◆ DeltaAlphaLepton()

const 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 879 of file StandardModel/src/StandardModel.cpp.

880{
881 if (s == Mz * Mz)
885
886 double DeltaAlphaL = 0.0;
887 if (flag_order[EW1])
888 DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
889 if (flag_order[EW1QCD1])
890 DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
891 if (flag_order[EW1QCD2])
892 DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
893 if (flag_order[EW2])
894 DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
895 if (flag_order[EW2QCD1])
896 DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
897 if (flag_order[EW3])
898 DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
899
900 if (s == Mz * Mz) {
901 DeltaAlphaLepton_cache = DeltaAlphaL;
903 }
904 return DeltaAlphaL;
905}
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_l(const double s) const
Leptonic contribution of to the electromagnetic coupling , denoted as .

◆ DeltaAlphaTop()

const 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 913 of file StandardModel/src/StandardModel.cpp.

914{
915 double DeltaAlpha = 0.0;
916 if (flag_order[EW1])
918 if (flag_order[EW1QCD1])
920 if (flag_order[EW1QCD2])
922 if (flag_order[EW2])
924 if (flag_order[EW2QCD1])
926 if (flag_order[EW3])
928
929 return DeltaAlpha;
930}
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .
double DeltaAlpha_t(const double s) const
Top-quark contribution of to the electromagnetic coupling , denoted as .

◆ deltaKappaZ_f()

const 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 [Ciuchini:2013pca] and references therein.

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

Definition at line 1770 of file StandardModel/src/StandardModel.cpp.

1771{
1772 Particle p1 = f, pe = leptons[ELECTRON];
1773
1774 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1775
1776 /* In the case of BOTTOM, the top contribution has to be subtracted.
1777 * The remaining contribution is the same as that for DOWN and STRANGE. */
1778 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1779
1780 double myMw = Mw();
1781 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1782 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1783 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1784 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1785 double deltal = myEWSMcache->delta_f(pe, myMw);
1786 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1787 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1788 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1789 double deltaf = myEWSMcache->delta_f(p1, myMw);
1790
1791 gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1792 - uf + ul;
1793 dKappa *= ale / 4.0 / M_PI / sW2;
1794 return dKappa;
1795}
gslpp::complex FZ(const double s, const double Mw_i) const
The unified form factor .
gslpp::complex FW(const double s, const Particle f, const double Mw_i) const
The unified form factor for .
double a_f(const Particle f) const
The tree-level axial-vector coupling for , denoted as .
Definition: EWSMcache.h:301
double v_f(const Particle f, const double Mw_i) const
The tree-level vector coupling for , denoted as .
Definition: EWSMcache.h:290
double delta_f(const Particle f, const double Mw_i) const
.
Definition: EWSMcache.h:323
bool is(std::string name_i) const
Definition: Particle.cpp:23

◆ DeltaR()

const 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 1118 of file StandardModel/src/StandardModel.cpp.

1119{
1120 /* in the experimental/running-width scheme */
1121 double myMw = Mw();
1122 double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1123 double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1124 if (FlagMw.compare("NORESUM") == 0
1125 || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1126 return (tmp - 1.0);
1127 } else {
1128 return (1.0 - 1.0 / tmp);
1129 }
1130}

◆ DeltaRbar()

const 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 [Bardin:1988xt].

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

Definition at line 1228 of file StandardModel/src/StandardModel.cpp.

1229{
1230 double Mwbar_SM = MwbarFromMw(Mw());
1231 double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1232 double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1233
1234 return (tmp - 1.0);
1235}
double Mzbar() const
The -boson mass in the complex-pole/fixed-width scheme.
const 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...

◆ deltaRhoZ_f()

const 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 [Ciuchini:2013pca] and references therein.

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

Definition at line 1745 of file StandardModel/src/StandardModel.cpp.

1746{
1747 Particle p1 = f, pe = leptons[ELECTRON];
1748
1749 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1750
1751 /* In the case of BOTTOM, the top contribution has to be subtracted.
1752 * The remaining contribution is the same as that for DOWN and STRANGE. */
1753 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1754
1755 double myMw = Mw();
1756 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1757
1758 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1759 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1760 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1761 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1762 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1763 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1764
1765 gslpp::complex dRho = 2.0 * (uf - ul);
1766 dRho *= ale / 4.0 / M_PI / sW2;
1767 return dRho;
1768}

◆ eeffAFBbottom()

virtual const double StandardModel::eeffAFBbottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3289 of file StandardModel.h.

3290 {
3291 return ( ( eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3292 }
virtual const double eeffsigma(const Particle f, const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const

◆ eeffAFBcharm()

virtual const double StandardModel::eeffAFBcharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3285 of file StandardModel.h.

3286 {
3287 return ( ( eeffsigma(quarks[CHARM], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) );
3288 }

◆ eeffAFBe()

virtual const double StandardModel::eeffAFBe ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3259 of file StandardModel.h.

3260 {
3261 double cosmin = -0.90; // As in LEP2
3262 double cosmax = 0.90; // As in LEP2
3263
3264 return (( eeffsigmaEbin(pol_e, pol_p, s, 0.0 , cosmax) - eeffsigmaEbin(pol_e, pol_p, s, cosmin, 0.0) ) / eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax));
3265 }
const double eeffsigmaEbin(const double pol_e, const double pol_p, const double s, const double cosmin, const double cosmax) const

◆ eeffAFBetsub()

virtual const double StandardModel::eeffAFBetsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3266 of file StandardModel.h.

3267 {
3268 double cosmin = -0.90; // As in LEP2
3269 double cosmax = 0.90; // As in LEP2
3270
3271 return ( ( eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, 0.0 , cosmax) - eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, 0.0) ) / eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax) );
3272 }

◆ eeffAFBmu()

virtual const double StandardModel::eeffAFBmu ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3273 of file StandardModel.h.

3274 {
3275 return ( ( eeffsigma(leptons[MU], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0) );
3276 }

◆ eeffAFBstrange()

virtual const double StandardModel::eeffAFBstrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3281 of file StandardModel.h.

3282 {
3283 return ( ( eeffsigma(quarks[STRANGE], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0) );
3284 }

◆ eeffAFBtau()

virtual const double StandardModel::eeffAFBtau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3277 of file StandardModel.h.

3278 {
3279 return ( ( eeffsigma(leptons[TAU], pol_e, pol_p, s, 0.0, 1.0) - eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 0.0) ) / eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0) );
3280 }

◆ eeffRbottom()

virtual const double StandardModel::eeffRbottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3252 of file StandardModel.h.

3253 {
3254 return ( eeffsigmaBottom(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3255 }
virtual const double eeffsigmaBottom(const double pol_e, const double pol_p, const double s) const
virtual const double eeffsigmaHadron(const double pol_e, const double pol_p, const double s) const

◆ eeffRcharm()

virtual const double StandardModel::eeffRcharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3248 of file StandardModel.h.

3249 {
3250 return ( eeffsigmaCharm(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3251 }
virtual const double eeffsigmaCharm(const double pol_e, const double pol_p, const double s) const

◆ eeffRelectron()

virtual const double StandardModel::eeffRelectron ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3228 of file StandardModel.h.

3229 {
3230 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaE(pol_e, pol_p, s) );
3231 }
virtual const double eeffsigmaE(const double pol_e, const double pol_p, const double s) const

◆ eeffRelectrontsub()

virtual const double StandardModel::eeffRelectrontsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3232 of file StandardModel.h.

3233 {
3234 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaEtsub(pol_e, pol_p, s) );
3235 }
virtual const double eeffsigmaEtsub(const double pol_e, const double pol_p, const double s) const

◆ eeffRmuon()

virtual const double StandardModel::eeffRmuon ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3236 of file StandardModel.h.

3237 {
3238 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaMu(pol_e, pol_p, s) );
3239 }
virtual const double eeffsigmaMu(const double pol_e, const double pol_p, const double s) const

◆ eeffRstrange()

virtual const double StandardModel::eeffRstrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3244 of file StandardModel.h.

3245 {
3246 return ( eeffsigmaStrange(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3247 }
virtual const double eeffsigmaStrange(const double pol_e, const double pol_p, const double s) const

◆ eeffRtau()

virtual const double StandardModel::eeffRtau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3240 of file StandardModel.h.

3241 {
3242 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaTau(pol_e, pol_p, s) );
3243 }
virtual const double eeffsigmaTau(const double pol_e, const double pol_p, const double s) const

◆ eeffsigma()

const double StandardModel::eeffsigma ( const Particle  f,
const double  pol_e,
const double  pol_p,
const double  s,
const double  cosmin,
const double  cosmax 
) const
virtual

Definition at line 4059 of file StandardModel/src/StandardModel.cpp.

4059 {
4060 // Only valid for f=/=e (MLL2, MRR2 do not depend on t for f=/=e. Simply enter t=1 as argument)
4061 // For f=e this corresponds to t-subtracted definition from LEP
4062 double sumM2, sigma;
4063 double tdumm = 1.;
4064 double topb = 0.3894e+9;
4065
4066 //double cosmin = -1.0;
4067 //double cosmax = 1.0;
4068
4069 double Nf;
4070
4071 double pLH, pRH; //Polarization factors, minus the 1/4 average
4072
4073 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4074 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4075
4076 if (f.is("LEPTON")) {
4077 Nf = 1.0;
4078 } else {
4079 Nf = 3.0;
4080 }
4081
4082 sumM2 = (pLH * MLR2eeff(f, s) + pRH * MRL2eeff(f, s)) * tovers2(cosmin, cosmax)
4083 + (pLH * MLL2eeff(f, s, tdumm) + pRH * MRR2eeff(f, s, tdumm)) * uovers2(cosmin, cosmax);
4084
4085 sigma = Nf * 0.5 * M_PI * (alphaMz())*(alphaMz()) * sumM2 / s;
4086
4087 return topb * sigma;
4088}
const double MRL2eeff(const Particle f, const double s) const
const double uovers2(const double cosmin, const double cosmax) const
const double tovers2(const double cosmin, const double cosmax) const
const double MLL2eeff(const Particle f, const double s, const double t) const
const double MRR2eeff(const Particle f, const double s, const double t) const
const double MLR2eeff(const Particle f, const double s) const

◆ eeffsigmaBottom()

virtual const double StandardModel::eeffsigmaBottom ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3221 of file StandardModel.h.

3222 {
3223 return eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0);
3224 }

◆ eeffsigmaCharm()

virtual const double StandardModel::eeffsigmaCharm ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3216 of file StandardModel.h.

3217 {
3218 return eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0);
3219 }

◆ eeffsigmaE()

virtual const double StandardModel::eeffsigmaE ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3176 of file StandardModel.h.

3177 {
3178 double cosmin = -0.90; // As in LEP2
3179 double cosmax = 0.90; // As in LEP2
3180
3181 return eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax);
3182 }

◆ eeffsigmaEbin()

const double StandardModel::eeffsigmaEbin ( const double  pol_e,
const double  pol_p,
const double  s,
const double  cosmin,
const double  cosmax 
) const

Definition at line 4025 of file StandardModel/src/StandardModel.cpp.

4025 {
4026
4027 double sumM2, sigma;
4028 double topb = 0.3894e+9;
4029 double t0, t1, lambdaK;
4030
4031 double pLH, pRH; //Polarization factors, minus the 1/4 average
4032 double pLLH, pRRH;
4033
4034 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4035 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4036
4037 pLLH = (1.0 - pol_e) * (1.0 - pol_p);
4038 pRRH = (1.0 + pol_e) * (1.0 + pol_p);
4039
4040 // t values for cosmin and cosmax
4041 t0 = 0.5 * s * ( -1.0 + cosmin );
4042 t1 = 0.5 * s * ( -1.0 + cosmax );
4043
4044 // Kähllén function of (s,0,0)
4045 lambdaK = s*s;
4046
4047 // Sum of the integrals of the amplitudes squared x (t/s)^2, (s/t)^2, (u/s)^2
4048 sumM2 = (pLH + pRH) * ( intMLR2eeeets2(s, t0, t1) ) +
4049 (pLLH + pRRH) * ( intMLRtilde2eeeest2(s, t0, t1) ) +
4050 pLH * intMLL2eeeeus2(s, t0, t1) + pRH * intMRR2eeeeus2(s, t0, t1);
4051
4052 // Build the cross section
4053 sigma = M_PI * (alphaMz())*(alphaMz()) * sumM2 / s / sqrt(lambdaK);
4054
4055 return topb * sigma;
4056
4057}
const double intMLR2eeeets2(const double s, const double t0, const double t1) const
const double intMLRtilde2eeeest2(const double s, const double t0, const double t1) const
const double intMRR2eeeeus2(const double s, const double t0, const double t1) const
const double intMLL2eeeeus2(const double s, const double t0, const double t1) const

◆ eeffsigmaEtsub()

virtual const double StandardModel::eeffsigmaEtsub ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3186 of file StandardModel.h.

3187 {
3188 double cosmin = -0.90; // As in LEP2
3189 double cosmax = 0.90; // As in LEP2
3190
3191 return eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax);
3192 }

◆ eeffsigmaHadron()

virtual const double StandardModel::eeffsigmaHadron ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3204 of file StandardModel.h.

3205 {
3206 return ( eeffsigma(quarks[UP], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[DOWN], pol_e, pol_p, s, -1.0, 1.0)
3207 + eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0)
3208 + eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3209 }

◆ eeffsigmaMu()

virtual const double StandardModel::eeffsigmaMu ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3194 of file StandardModel.h.

3195 {
3196 return eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0);
3197 }

◆ eeffsigmaStrange()

virtual const double StandardModel::eeffsigmaStrange ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3211 of file StandardModel.h.

3212 {
3213 return eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0);
3214 }

◆ eeffsigmaTau()

virtual const double StandardModel::eeffsigmaTau ( const double  pol_e,
const double  pol_p,
const double  s 
) const
inlinevirtual

Definition at line 3199 of file StandardModel.h.

3200 {
3201 return eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0);
3202 }

◆ epsilon1()

const 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 [Altarelli:1990zd] and [Altarelli:1991fk].

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

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1800 of file StandardModel/src/StandardModel.cpp.

1801{
1802 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1803 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1804
1805 return DeltaRhoPrime;
1806}
virtual const gslpp::complex rhoZ_f(const Particle f) const
The effective leptonic neutral-current coupling in the SM.

◆ epsilon2()

const 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 [Altarelli:1990zd] and [Altarelli:1991fk].

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

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1808 of file StandardModel/src/StandardModel.cpp.

1809{
1810 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1811 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1812 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1813 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1814 double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1815
1816 return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1817 - 2.0 * s02() * DeltaKappaPrime);
1818}
const double c02() const
The square of the cosine of the weak mixing angle defined without weak radiative corrections.
An observable class for the leptonic effective weak mixing angle at the pole. To be used for the el...
Definition: sin2thetaEff.h:29

◆ epsilon3()

const 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 [Altarelli:1990zd] and [Altarelli:1991fk].

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

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1820 of file StandardModel/src/StandardModel.cpp.

1821{
1822 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1823 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1824 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1825 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1826
1827 return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1828}

◆ epsilonb()

const 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 [Altarelli:1990zd], [Altarelli:1991fk] and [Altarelli:1993sz] for the \(\varepsilon\) parameterization and [Ciuchini:2013pca] for the flavour non-universal vertex corrections.

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

Reimplemented in NPEpsilons, NPEpsilons_pureNP, NPSTU, and NPSTUVWXY.

Definition at line 1830 of file StandardModel/src/StandardModel.cpp.

1831{
1832 /* epsilon_b from g_A^b
1833 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1834 //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1835 //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1836 //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1837 //double eps1 = DeltaRhoPrime;
1838 //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1839
1840 /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1841 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1842 gslpp::complex kappaZe = kappaZ_f(leptons[ELECTRON]);
1843 gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1845 return ( kappaZe.real() / kappaZb.real() - 1.0);
1846 else
1847 return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1848 / kappaZb.real() - 1.0);
1849
1850 /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1851 * 1031 (1998) by Altarelli et al.
1852 * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1853 */
1854 //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1855 //double delta_als = (als_Mz - 0.119)/M_PI;
1856 //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1857 //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1858 //double a = als_Mz/M_PI;
1859 //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1860 //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1861 //double mb = 4.7;
1862 //std::cout << "mb = " << mb << std::endl;
1863 //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1864 //double Nc = 3.0;
1865 //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1866 //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1867 // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1868 // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1869 //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1870 // + 0.54*epsilon3_SM() )/2.29 );
1871}
const bool IsFlagWithoutNonUniversalVC() const
A method to retrieve the model flag WithoutNonUniversalVC.
virtual const gslpp::complex deltaKappaZ_f(const Particle f) const
Flavour non-universal vertex corrections to , denoted by .

◆ f_triangle()

gslpp::complex StandardModel::f_triangle ( const double  tau) const

Loop function entering in the calculation of the effective \(Hgg\) and \(H\gamma\gamma\) couplings.

Parameters
[in]

_form#4756, with \(M\) the mass of the particle in the loop.

Returns
\(f(\tau)\)

Definition at line 3262 of file StandardModel/src/StandardModel.cpp.

3262 {
3263 gslpp::complex tmp;
3264 if (tau >= 1.0) {
3265 tmp = asin(1.0 / sqrt(tau));
3266 return (tmp * tmp);
3267 } else {
3268 tmp = log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i();
3269 return (-0.25 * tmp * tmp);
3270 }
3271}

◆ g_triangle()

gslpp::complex StandardModel::g_triangle ( const double  tau) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4756, with \(M\) the mass of the particle in the loop.

Returns
\(g(\tau)\)

Definition at line 3273 of file StandardModel/src/StandardModel.cpp.

3273 {
3274 gslpp::complex tmp;
3275 if (tau >= 1.0) {
3276 tmp = sqrt(tau - 1.0) * asin(1.0 / sqrt(tau));
3277 return tmp;
3278 } else {
3279 tmp = sqrt(1.0 - tau) * (log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i());
3280 return 0.5 * tmp;
3281 }
3282}

◆ gA_f()

const 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 NPbase, and NPEpsilons.

Definition at line 1589 of file StandardModel/src/StandardModel.cpp.

1590{
1591 return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1592}
double getIsospin() const
A get method to access the particle isospin.
Definition: Particle.h:115

◆ Gamma_had()

const 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 [Bardin:1997xq] :

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

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

Reimplemented in NPbase.

Definition at line 1417 of file StandardModel/src/StandardModel.cpp.

1418{
1419 double Gamma_had_tmp = 0.0;
1420
1422
1423 /* SM contribution with the approximate formula */
1424 return myApproximateFormulae->X_full("Gamma_had");
1425
1426 } else {
1427
1428 Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1430
1431 /* Singlet vector contribution (not included in the approximate formula) */
1432 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1433 Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1434
1435 return Gamma_had_tmp;
1436 }
1437}
double X_full(const std::string observable) const
, , , , , , , , , , , or .
virtual const double GammaZ(const Particle f) const
The partial decay width, .
const bool IsFlagNoApproximateGammaZ() const
A method to retrieve the model flag NoApproximateGammaZ.
double RVh() const
The singlet vector corrections to the hadronic -boson width, denoted as .

◆ Gamma_inv()

const 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 1411 of file StandardModel/src/StandardModel.cpp.

1412{
1415}

◆ Gamma_muon()

const double StandardModel::Gamma_muon ( ) const
virtual

The computation of the muon decay.

Follows the formulae of PDG

Returns
\(\Gamma_\mu \)

Definition at line 3094 of file StandardModel/src/StandardModel.cpp.

3095{
3096 double Gamma;
3097 double me, mmu, x, Fx, H1x, H2x, H3x, zeta3;
3098 double alpha, rEW;
3099 double pi2;
3100
3101 me = leptons[ELECTRON].getMass();
3102 mmu = leptons[MU].getMass();
3103 pi2 = M_PI*M_PI;
3104
3105 x = me*me/mmu/mmu;
3106 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3107
3108 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3109
3110 zeta3 = 1.2020569031595942;
3111
3112 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3113
3114 H3x = -15.3;
3115
3116 // alpha(m_mu)
3117 alpha = 1./ale - log(x)/3./M_PI; // + 1./6./M_PI;
3118 alpha = 1./alpha;
3119
3120 // Rad. corrections
3121 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3122
3123 // Gamma: PDG formula
3124 Gamma = GF*GF*pow(mmu,5)*Fx*rEW/192./pow(M_PI,3);
3125
3126 return Gamma;
3127}
double zeta3
computed with the GSL.
Definition: QCD.h:1033

◆ Gamma_tau_l_nunu()

const double StandardModel::Gamma_tau_l_nunu ( const Particle  l) const
virtual

The computation of the leptonic tau decays.

Follows the formulae of PDG for muon, adapted to tau leptons

Returns
\(\Gamma(\tau \to l \nu \nu ) \)

Definition at line 3134 of file StandardModel/src/StandardModel.cpp.

3135{
3136 double Gamma;
3137 double ml, mtau, x, Fx, H1x, H2x, H3x, zeta3;
3138 double alpha, rEW;
3139 double pi2;
3140
3141 ml = l.getMass();
3142 mtau = leptons[TAU].getMass();
3143 pi2 = M_PI*M_PI;
3144
3145 x = ml*ml/mtau/mtau;
3146 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3147
3148 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3149
3150 zeta3 = 1.2020569031595942;
3151
3152 H2x= 156815./5184. - 518. * pi2/81. - 895. *zeta3/36. + 67.*pi2*pi2/720. + 53. *pi2*log(2.)/6. - 0.042 - (5./4.) * pi2*sqrt(x);
3153
3154 H3x = -15.3;
3155
3156 // alpha(m_tau)
3157 alpha = 1./133.29; // Improve
3158
3159 // Rad. corrections
3160 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3161
3162 // Gamma: PDG formula
3163 Gamma = GF*GF*pow(mtau,5)*Fx*rEW/192./pow(M_PI,3);
3164
3165 return Gamma;
3166}

◆ Gamma_Z()

const 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, NPSMEFTd6General, and NPZbbbar.

Definition at line 1439 of file StandardModel/src/StandardModel.cpp.

1440{
1442
1443 /* SM contribution with the approximate formula */
1444 return myApproximateFormulae->X_full("GammaZ");
1445
1446 } else {
1448 + Gamma_inv() + Gamma_had());
1449 }
1450}
virtual const double Gamma_inv() const
The invisible partial decay width of the boson, .
virtual const double Gamma_had() const
The hadronic decay width of the boson, .

◆ GammaHtobb()

const double StandardModel::GammaHtobb ( ) const
virtual

The \(\Gamma(H\to b \bar{b})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to b \bar{b})\)

Definition at line 3610 of file StandardModel/src/StandardModel.cpp.

3611{
3612 double mf0=quarks[BOTTOM].getMass(), mf;
3613 double beta;
3614 double Nc=3.0;
3615 double gamma;
3616 double asMH,DeltaQCD,Deltamt,NF;
3617
3618 // alfa_s(MH)
3619 asMH = Als(mHl, FULLNLO);
3620
3621 mf = Mrun(mHl, mf0, mf0, BOTTOM, FULLNLO);
3622
3623 beta=1.0-4.0*mf*mf/mHl/mHl;
3624
3625 NF=5;
3626
3627 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3628
3629 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3630
3631 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3632
3633 return gamma;
3634}
const double Mrun(const double mu, const double m, const quark q, const orders order=FULLNNLO) const
Computes a running quark mass from .
Definition: QCD.cpp:1353

◆ GammaHtocc()

const double StandardModel::GammaHtocc ( ) const
virtual

The \(\Gamma(H\to c \bar{c})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to c \bar{c})\)

Definition at line 3558 of file StandardModel/src/StandardModel.cpp.

3559{
3560 double mf0=quarks[CHARM].getMass(), mf;
3561 double beta;
3562 double Nc=3.0;
3563 double gamma;
3564 double asMH,DeltaQCD,Deltamt,NF;
3565
3566 // alfa_s(MH)
3567 asMH = Als(mHl, FULLNLO);
3568
3569 mf = Mrun(mHl, mf0, mf0, CHARM, FULLNLO);
3570
3571 beta=1.0-4.0*mf*mf/mHl/mHl;
3572
3573 NF=5;
3574
3575 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3576
3577 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3578
3579 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3580
3581 return gamma;
3582}

◆ GammaHtogaga()

const double StandardModel::GammaHtogaga ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \gamma \gamma)\)

Definition at line 3491 of file StandardModel/src/StandardModel.cpp.

3492{
3493 double gamma;
3494
3495 double m_t = mtpole;
3496 double m_b = quarks[BOTTOM].getMass();
3497 double m_c = quarks[CHARM].getMass();
3498 double m_s = quarks[STRANGE].getMass();
3499 double m_tau = leptons[TAU].getMass();
3500 double m_mu = leptons[MU].getMass();
3501
3502 double M_w_2 = pow(Mw(),2.0);
3503
3504 double Qt = quarks[TOP].getCharge();
3505 double Qb = quarks[BOTTOM].getCharge();
3506 double Qc = quarks[CHARM].getCharge();
3507 double Qs = quarks[STRANGE].getCharge();
3508 double Qtau = leptons[TAU].getCharge();
3509 double Qmu = leptons[MU].getCharge();
3510
3511 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3512 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3513 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3514 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3515 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3516 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3517 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3518
3519 gslpp::complex MSM;
3520
3521 MSM = ale * (3.0 * Qt * Qt * AH_f(tau_t) +
3522 3.0 * Qb * Qb * AH_f(tau_b) +
3523 3.0 * Qc * Qc * AH_f(tau_c) +
3524 3.0 * Qs * Qs * AH_f(tau_s) +
3525 Qtau * Qtau * AH_f(tau_tau) +
3526 Qmu * Qmu * AH_f(tau_mu) +
3527 AH_W(tau_W));
3528
3529 gamma = (4.0*GF/sqrt(2)) * (MSM.abs2()) * pow(mHl,3.0)/512.0/pow(M_PI,3);
3530
3531 return gamma;
3532}
gslpp::complex AH_f(const double tau) const
Fermionic loop function entering in the calculation of the effective and couplings.
gslpp::complex AH_W(const double tau) const
W loop function entering in the calculation of the effective coupling.

◆ GammaHtogg()

const double StandardModel::GammaHtogg ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to gg)\)

Definition at line 3368 of file StandardModel/src/StandardModel.cpp.

3369{
3370 double gamma;
3371 double tau_t = 4.0 * pow(quarks[TOP].getMass(),2)/mHl/mHl;
3372 double tau_b = 4.0 * pow(quarks[BOTTOM].getMass(),2)/mHl/mHl;
3373 double tau_c = 4.0 * pow(quarks[CHARM].getMass(),2)/mHl/mHl;
3374 double tau_s = 4.0 * pow(quarks[STRANGE].getMass(),2)/mHl/mHl;
3375 double asMH,LH,Lt,nl,h0,h1,h2, h3,G0;
3376
3377 // alfa_s(MH)
3378 asMH = Als(mHl, FULLNLO);
3379
3380 // NLO corrections ( See https://arxiv.org/pdf/0708.0916 and its REf. [25])
3381 // I only keep up to h3 in expr. (4), and use pole mass in tau factors for the moment
3382 nl = 5;
3383 LH = 0.; // log(mu^2/MH^2) evaluated at mu=MH
3384 Lt = 2.0*log(mHl/(quarks[TOP].getMass()));
3385
3386 h0 = (95./4.) + (11./2.)*LH + nl*(-7./6. - LH/3.);
3387 h1 = 5803./540. + 77.*LH/30. -14.*Lt/15. + nl * (-29./60. - 7. * LH / 45.);
3388 h2 = 1029839./189000. + 16973.*LH/12600. - 1543.*Lt/1575. + nl * ( - 89533./378000 - 1543.*LH/18900. );
3389 h3 = 9075763./2976750. + 1243*LH/1575. - 452.*Lt/575. + nl * ( - 3763./28350. -226. * LH / 4725. );
3390 G0 = GF * pow(mHl,3.0)/(36.*M_PI*sqrt(2.));
3391
3392 gamma = asMH*asMH * (4.0 * GF /sqrt(2.0)) * (mHl*mHl*mHl /64.0/pow(M_PI,3.0)) *
3393 ( AH_f(tau_t) + AH_f(tau_b) + AH_f(tau_c) + AH_f(tau_s) ).abs2()/4.0;
3394
3395 gamma = gamma + G0 * (asMH/M_PI) * (asMH/M_PI) * (asMH/M_PI) * (h0 + h1/tau_t + h2/tau_t/tau_t + h3/tau_t/tau_t/tau_t );
3396
3397 return gamma;
3398}

◆ GammaHtomumu()

const double StandardModel::GammaHtomumu ( ) const
virtual

The \(\Gamma(H\to \mu^+ \mu^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \mu^+ \mu^-)\)

Definition at line 3534 of file StandardModel/src/StandardModel.cpp.

3535{
3536 double mf=leptons[MU].getMass();
3537 double beta=1.0-4.0*mf*mf/mHl/mHl;
3538 double Nc=1.0;
3539 double gamma;
3540
3541 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3542
3543 return gamma;
3544}

◆ GammaHtoss()

const double StandardModel::GammaHtoss ( ) const
virtual

The \(\Gamma(H\to s \bar{s})\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to s \bar{s})\)

Definition at line 3584 of file StandardModel/src/StandardModel.cpp.

3585{
3586 double mf0=quarks[STRANGE].getMass(), mf;
3587 double beta;
3588 double Nc=3.0;
3589 double gamma;
3590 double asMH,DeltaQCD,Deltamt,NF;
3591
3592 // alfa_s(MH)
3593 asMH = Als(mHl, FULLNLO);
3594
3595 mf = Mrun(mHl, 2.0, mf0, STRANGE, FULLNLO);
3596
3597 beta=1.0-4.0*mf*mf/mHl/mHl;
3598
3599 NF=5;
3600
3601 DeltaQCD = 1 + (asMH/M_PI) * ( 17.0/3.0 + (asMH/M_PI) * ( (35.94 - 1.36*NF) + (164.14 - 25.77*NF + 0.26*NF*NF)*(asMH/M_PI) ) );
3602
3603 Deltamt = (asMH/M_PI) * (asMH/M_PI) * ( 1.57 + (4.0/3.0)*log(mHl/mtpole) + (4.0/9.0) * log(mf/mHl) * log(mf/mHl) );
3604
3605 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3606
3607 return gamma;
3608}

◆ GammaHTot()

const double StandardModel::GammaHTot ( ) const
virtual

The total Higgs width \(\Gamma(H)\) in the Standard Model.

At the same level of the individual contributions

Returns
\(\Gamma(H)\)

Definition at line 3636 of file StandardModel/src/StandardModel.cpp.

3637{
3638 double gamma;
3639
3640 gamma = GammaHtobb() + GammaHtocc() + GammaHtoss() +
3644
3645 return gamma;
3646}

◆ GammaHtotautau()

const double StandardModel::GammaHtotautau ( ) const
virtual

The \(\Gamma(H\to \tau^+ \tau^-)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to \tau^+ \tau^-)\)

Definition at line 3546 of file StandardModel/src/StandardModel.cpp.

3547{
3548 double mf=leptons[TAU].getMass();
3549 double beta=1.0-4.0*mf*mf/mHl/mHl;
3550 double Nc=1.0;
3551 double gamma;
3552
3553 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3554
3555 return gamma;
3556}

◆ GammaHtoWWstar()

const double StandardModel::GammaHtoWWstar ( ) const
virtual

The \(\Gamma(H\to W W^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to W W^*)\)

Definition at line 3416 of file StandardModel/src/StandardModel.cpp.

3417{
3418 double x=Mw()/mHl;
3419 double fx;
3420 double g2 = 4.0 * sqrt(2.0) * GF * pow(Mw(),2);
3421 double gamma;
3422
3423 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3424 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3425 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3426
3427 gamma = 3.0 * g2*g2 * mHl * fx / 512.0 / pow(M_PI,3.0);
3428
3429 return gamma;
3430}

◆ GammaHtoZga()

const double StandardModel::GammaHtoZga ( ) const
virtual

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

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to Z \gamma)\)

Definition at line 3432 of file StandardModel/src/StandardModel.cpp.

3433{
3434 double gamma;
3435
3436 double m_t = mtpole;
3437 double m_b = quarks[BOTTOM].getMass();
3438 double m_c = quarks[CHARM].getMass();
3439 double m_s = quarks[STRANGE].getMass();
3440 double m_tau = leptons[TAU].getMass();
3441 double m_mu = leptons[MU].getMass();
3442
3443 double M_w_2 = pow(Mw(),2.0);
3444
3445 double Qt = quarks[TOP].getCharge();
3446 double Qb = quarks[BOTTOM].getCharge();
3447 double Qc = quarks[CHARM].getCharge();
3448 double Qs = quarks[STRANGE].getCharge();
3449 double Qtau = leptons[TAU].getCharge();
3450 double Qmu = leptons[MU].getCharge();
3451
3452 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3453 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3454 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3455 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3456 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3457 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3458 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3459
3460 double lambda_t = 4.0 * m_t * m_t / Mz / Mz;
3461 double lambda_b = 4.0 * m_b * m_b / Mz / Mz;
3462 double lambda_c = 4.0 * m_c * m_c / Mz / Mz;
3463 double lambda_s = 4.0 * m_s * m_s / Mz / Mz;
3464 double lambda_tau = 4.0 * m_tau * m_tau / Mz / Mz;
3465 double lambda_mu = 4.0 * m_mu * m_mu / Mz / Mz;
3466 double lambda_W = 4.0 * M_w_2 / Mz / Mz;
3467
3468 double sc = sqrt(sW2()*cW2());
3469 double vSMt = (2.0 * (quarks[TOP].getIsospin()) - 4.0 * Qt * sW2())/sc;
3470 double vSMb = (2.0 * (quarks[BOTTOM].getIsospin()) - 4.0 * Qb * sW2())/sc;
3471 double vSMc = (2.0 * (quarks[CHARM].getIsospin()) - 4.0 * Qc * sW2())/sc;
3472 double vSMs = (2.0 * (quarks[STRANGE].getIsospin()) - 4.0 * Qs * sW2())/sc;
3473 double vSMtau = (2.0 * (leptons[TAU].getIsospin()) - 4.0 * Qtau * sW2())/sc;
3474 double vSMmu = (2.0 * (leptons[MU].getIsospin()) - 4.0 * Qmu * sW2())/sc;
3475
3476 gslpp::complex MSM;
3477
3478 MSM = (ale/4.0/M_PI) * ((3.0 * vSMt * Qt * AHZga_f(tau_t, lambda_t) +
3479 3.0 * vSMb * Qb * AHZga_f(tau_b, lambda_b) +
3480 3.0 * vSMc * Qc * AHZga_f(tau_c, lambda_c) +
3481 3.0 * vSMs * Qs * AHZga_f(tau_s, lambda_s) +
3482 vSMtau * Qtau * AHZga_f(tau_tau, lambda_tau) +
3483 vSMmu * Qmu * AHZga_f(tau_mu, lambda_mu)) +
3484 AHZga_W(tau_W, lambda_W)/sqrt(sW2()));
3485
3486 gamma = (4.0*sqrt(2)*GF) * (MSM.abs2()) * pow(mHl*(1.0-Mz*Mz/mHl/mHl),3.0)/32.0/M_PI;
3487
3488 return gamma;
3489}
gslpp::complex AHZga_W(const double tau, const double lambda) const
W loop function entering in the calculation of the effective coupling.
gslpp::complex AHZga_f(const double tau, const double lambda) const
Fermionic loop function entering in the calculation of the effective coupling.

◆ GammaHtoZZstar()

const double StandardModel::GammaHtoZZstar ( ) const
virtual

The \(\Gamma(H\to Z Z^*)\) in the Standard Model.

Currently, only at tree level. From Higgs Hunter's guide

Returns
\(\Gamma(H\to Z Z^*)\)

Definition at line 3400 of file StandardModel/src/StandardModel.cpp.

3401{
3402 double x=Mz/mHl;
3403 double fx;
3404 double g2 = 4.0 * sqrt(2.0) * GF * Mz * Mz;
3405 double gamma;
3406
3407 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3408 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3409 3.0*( 1.0 - 8.0*x*x + 20.0*x*x*x*x )*acos(( 3.0*x*x - 1.0 )/2.0/x/x/x)/sqrt( 4.0*x*x- 1.0);
3410
3411 gamma = g2*g2 * mHl * fx * ( 7.0 - 40.0*sW2()/3.0 + 160.0 *sW2()*sW2()/9.0 ) / 2048.0 / pow(M_PI,3.0);
3412
3413 return gamma;
3414}

◆ GammaW() [1/2]

const double StandardModel::GammaW ( ) const
virtual

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

Returns
\(\Gamma_W\) in GeV

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

Definition at line 1272 of file StandardModel/src/StandardModel.cpp.

1273{
1275 if (useGammaW_cache)
1276 return GammaW_cache;
1277
1278 double GammaWtmp = 0.;
1279
1280 for (int i = 0; i < 6; i += 2)
1281 GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1282
1283 GammaW_cache = GammaWtmp;
1284 useGammaW_cache = true;
1285 return GammaWtmp;
1286}

◆ GammaW() [2/2]

const 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 NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1248 of file StandardModel/src/StandardModel.cpp.

1249{
1250 if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1251 throw std::runtime_error("Error in StandardModel::GammaW()");
1252
1253 double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1254 gslpp::complex V(0.0, 0.0, false);
1255
1256 if (fi.is("TOP"))
1257 return (0.0);
1258
1259 if (fj.getIndex() - fi.getIndex() == 1)
1260 V = gslpp::complex(1.0, 0.0, false);
1261 else
1262 V = gslpp::complex(0.0, 0.0, false);
1263
1264 if (fi.is("LEPTON"))
1265 return ( V.abs2() * G0 * rho_GammaW(fi, fj) * ( 1.0 + delGammaWlv ) );
1266 else {
1267 double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, 5, FULLNLO);
1268 return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj) * (1.0 + AlsMw / M_PI) * ( 1.0 + delGammaWqq ) );
1269 }
1270}
int getIndex() const
Definition: Particle.h:160
virtual const double rho_GammaW(const Particle fi, const Particle fj) const
EW radiative corrections to the width of , denoted as .

◆ GammaZ()

const 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\) [Bardin:1999ak] :

\[ \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 1363 of file StandardModel/src/StandardModel.cpp.

1364{
1365 if (f.is("TOP"))
1366 return 0.0;
1367 double Gamma;
1369
1370 /* SM contribution with the approximate formula */
1371 if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1372 Gamma = myApproximateFormulae->X_full("Gamma_nu");
1373 else if (f.is("ELECTRON") || f.is("MU"))
1374 Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1375 else if (f.is("TAU"))
1376 Gamma = myApproximateFormulae->X_full("Gamma_tau");
1377 else if (f.is("UP"))
1378 Gamma = myApproximateFormulae->X_full("Gamma_u");
1379 else if (f.is("CHARM"))
1380 Gamma = myApproximateFormulae->X_full("Gamma_c");
1381 else if (f.is("DOWN") || f.is("STRANGE"))
1382 Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1383 else if (f.is("BOTTOM"))
1384 Gamma = myApproximateFormulae->X_full("Gamma_b");
1385 else
1386 throw std::runtime_error("Error in StandardModel::GammaZ()");
1387
1388 } else {
1389 gslpp::complex myrhoZ_f = rhoZ_f(f);
1390 gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1391 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1392 if (f.is("LEPTON")) {
1393 double myalphaMz = alphaMz();
1394 double Q = f.getCharge();
1395 double xl = pow(f.getMass() / Mz, 2.0);
1396 Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1397 * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1398 * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1399 } else if (f.is("QUARK")) {
1400 Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1401
1402 /* Nonfactorizable EW-QCD corrections */
1403 Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1404 } else
1405 throw std::runtime_error("Error in StandardModel::GammaZ()");
1406 }
1407
1408 return Gamma;
1409}
double Delta_EWQCD(const QCD::quark q) const
The non-factorizable EW-QCD corrections to the partial widths for , denoted as .
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...
double RVq(const QCD::quark q) const
The radiator factor associated with the final-state QED and QCD corrections to the the vector-current...
virtual const gslpp::complex gA_f(const Particle f) const
The effective leptonic neutral-current axial-vector coupling in the SM.
virtual const gslpp::complex gV_f(const Particle f) const
The effective leptonic neutral-current vector coupling in the SM.

◆ gAnue()

const double StandardModel::gAnue ( ) const
virtual

The effective (muon) neutrino-electron axial-vector coupling: gAnue.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_A^{\nu_\mu e}\)

Definition at line 3074 of file StandardModel/src/StandardModel.cpp.

3075{
3076 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3078
3079 /* SM contribution with the approximate formula */
3081
3082 } else {
3083 throw std::runtime_error("ERROR: StandardModel::gAnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3084 }
3085}
double LEgAnueApprox() const
The effective (muon) neutrino-electron axial-vector coupling: gAnue.

◆ getAle()

const double StandardModel::getAle ( ) const
inline

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

Returns
\(\alpha\)

Definition at line 801 of file StandardModel.h.

802 {
803 return ale;
804 }

◆ getAlsMz()

const 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 783 of file StandardModel.h.

784 {
785 return AlsMz;
786 }

◆ getCBd()

virtual const 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 3098 of file StandardModel.h.

3099 {
3100 return 1.;
3101 }

◆ getCBs()

virtual const 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 3107 of file StandardModel.h.

3108 {
3109 return 1.;
3110 }

◆ getCCC1()

virtual const double StandardModel::getCCC1 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1205 of file StandardModel.h.

1205{ return 0.; };

◆ getCCC2()

virtual const double StandardModel::getCCC2 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1210 of file StandardModel.h.

1210{ return 0.; };

◆ getCCC3()

virtual const double StandardModel::getCCC3 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1215 of file StandardModel.h.

1215{ return 0.; };

◆ getCCC4()

virtual const double StandardModel::getCCC4 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1220 of file StandardModel.h.

1220{ return 0.; };

◆ getCCC5()

virtual const double StandardModel::getCCC5 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1225 of file StandardModel.h.

1225{ return 0.; };

◆ getCDMK()

virtual const 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 3116 of file StandardModel.h.

3117 {
3118 return 1.;
3119 }

◆ getCepsK()

virtual const 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 3125 of file StandardModel.h.

3126 {
3127 return 1.;
3128 }

◆ getCKM()

const CKM & StandardModel::getCKM ( ) const
inline

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

Returns
a reference to the object of type CKM

Definition at line 952 of file StandardModel.h.

953 {
954 return myCKM;
955 }

◆ getDAle5Mz()

const 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 812 of file StandardModel.h.

813 {
814 return dAle5Mz;
815 }

◆ getDelGammaWlv()

const double StandardModel::getDelGammaWlv ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\).

Returns
\(\delta\,\Gamma_W_{l\nu}\) in GeV

Definition at line 924 of file StandardModel.h.

925 {
926 return delGammaWlv;
927 }

◆ getDelGammaWqq()

const double StandardModel::getDelGammaWqq ( ) const
inline

A get method to retrieve the theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\).

Returns
\(\delta\,\Gamma_W_{qq}\) in GeV

Definition at line 934 of file StandardModel.h.

935 {
936 return delGammaWqq;
937 }

◆ getDelGammaZ()

const 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 874 of file StandardModel.h.

875 {
876 return delGammaZ;
877 }

◆ getDelMw()

const 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 831 of file StandardModel.h.

832 {
833 return delMw;
834 }

◆ getDelR0b()

const 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 914 of file StandardModel.h.

915 {
916 return delR0b;
917 }

◆ getDelR0c()

const 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 904 of file StandardModel.h.

905 {
906 return delR0c;
907 }

◆ getDelR0l()

const 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 894 of file StandardModel.h.

895 {
896 return delR0l;
897 }

◆ getDelSigma0H()

const 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 884 of file StandardModel.h.

885 {
886 return delsigma0H;
887 }

◆ getDelSin2th_b()

const 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 864 of file StandardModel.h.

865 {
866 return delSin2th_b;
867 }

◆ getDelSin2th_l()

const 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 842 of file StandardModel.h.

843 {
844 return delSin2th_l;
845 }

◆ getDelSin2th_q()

const 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 853 of file StandardModel.h.

854 {
855 return delSin2th_q;
856 }

◆ getFlagKappaZ()

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

A method to retrieve the model flag KappaZ.

See StandardModelFlags for detail.

Returns

Definition at line 726 of file StandardModel.h.

727 {
728 return FlagKappaZ;
729 }

◆ getFlagMw()

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

A method to retrieve the model flag Mw.

See StandardModelFlags for detail.

Returns

Definition at line 706 of file StandardModel.h.

707 {
708 return FlagMw;
709 }

◆ getFlagRhoZ()

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

A method to retrieve the model flag RhoZ.

See StandardModelFlags for detail.

Returns

Definition at line 716 of file StandardModel.h.

717 {
718 return FlagRhoZ;
719 }

◆ getFlavour()

const Flavour & StandardModel::getFlavour ( ) const
inline

Definition at line 1065 of file StandardModel.h.

1066 {
1067 return SMFlavour;
1068 }

◆ getGF()

const 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 792 of file StandardModel.h.

793 {
794 return GF;
795 }

◆ getIntegrand_AFBnumeratorWithISR_bottom133()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133 ( double  x) const
protected

Definition at line 9545 of file StandardModel/src/StandardModel.cpp.

9546{
9547 double s = 133. * 133.;
9549}
const double Integrand_AFBnumeratorWithISR_q(double x, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_AFBnumeratorWithISR_bottom167()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167 ( double  x) const
protected

Definition at line 9551 of file StandardModel/src/StandardModel.cpp.

9552{
9553 double s = 167. * 167.;
9555}

◆ getIntegrand_AFBnumeratorWithISR_bottom172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom172 ( double  x) const
protected

Definition at line 9557 of file StandardModel/src/StandardModel.cpp.

9558{
9559 double s = 172. * 172.;
9561}

◆ getIntegrand_AFBnumeratorWithISR_bottom183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183 ( double  x) const
protected

Definition at line 9563 of file StandardModel/src/StandardModel.cpp.

9564{
9565 double s = 183. * 183.;
9567}

◆ getIntegrand_AFBnumeratorWithISR_bottom189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189 ( double  x) const
protected

Definition at line 9569 of file StandardModel/src/StandardModel.cpp.

9570{
9571 double s = 189. * 189.;
9573}

◆ getIntegrand_AFBnumeratorWithISR_bottom192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192 ( double  x) const
protected

Definition at line 9575 of file StandardModel/src/StandardModel.cpp.

9576{
9577 double s = 192. * 192.;
9579}

◆ getIntegrand_AFBnumeratorWithISR_bottom196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196 ( double  x) const
protected

Definition at line 9581 of file StandardModel/src/StandardModel.cpp.

9582{
9583 double s = 196. * 196.;
9585}

◆ getIntegrand_AFBnumeratorWithISR_bottom200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200 ( double  x) const
protected

Definition at line 9587 of file StandardModel/src/StandardModel.cpp.

9588{
9589 double s = 200. * 200.;
9591}

◆ getIntegrand_AFBnumeratorWithISR_bottom202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202 ( double  x) const
protected

Definition at line 9593 of file StandardModel/src/StandardModel.cpp.

9594{
9595 double s = 202. * 202.;
9597}

◆ getIntegrand_AFBnumeratorWithISR_bottom205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205 ( double  x) const
protected

Definition at line 9599 of file StandardModel/src/StandardModel.cpp.

9600{
9601 double s = 205. * 205.;
9603}

◆ getIntegrand_AFBnumeratorWithISR_bottom207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207 ( double  x) const
protected

Definition at line 9605 of file StandardModel/src/StandardModel.cpp.

9606{
9607 double s = 207. * 207.;
9609}

◆ getIntegrand_AFBnumeratorWithISR_charm133()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm133 ( double  x) const
protected

Definition at line 9476 of file StandardModel/src/StandardModel.cpp.

9477{
9478 double s = 133. * 133.;
9480}

◆ getIntegrand_AFBnumeratorWithISR_charm167()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm167 ( double  x) const
protected

Definition at line 9482 of file StandardModel/src/StandardModel.cpp.

9483{
9484 double s = 167. * 167.;
9486}

◆ getIntegrand_AFBnumeratorWithISR_charm172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm172 ( double  x) const
protected

Definition at line 9488 of file StandardModel/src/StandardModel.cpp.

9489{
9490 double s = 172. * 172.;
9492}

◆ getIntegrand_AFBnumeratorWithISR_charm183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm183 ( double  x) const
protected

Definition at line 9494 of file StandardModel/src/StandardModel.cpp.

9495{
9496 double s = 183. * 183.;
9498}

◆ getIntegrand_AFBnumeratorWithISR_charm189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm189 ( double  x) const
protected

Definition at line 9500 of file StandardModel/src/StandardModel.cpp.

9501{
9502 double s = 189. * 189.;
9504}

◆ getIntegrand_AFBnumeratorWithISR_charm192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm192 ( double  x) const
protected

Definition at line 9506 of file StandardModel/src/StandardModel.cpp.

9507{
9508 double s = 192. * 192.;
9510}

◆ getIntegrand_AFBnumeratorWithISR_charm196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm196 ( double  x) const
protected

Definition at line 9512 of file StandardModel/src/StandardModel.cpp.

9513{
9514 double s = 196. * 196.;
9516}

◆ getIntegrand_AFBnumeratorWithISR_charm200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm200 ( double  x) const
protected

Definition at line 9518 of file StandardModel/src/StandardModel.cpp.

9519{
9520 double s = 200. * 200.;
9522}

◆ getIntegrand_AFBnumeratorWithISR_charm202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm202 ( double  x) const
protected

Definition at line 9524 of file StandardModel/src/StandardModel.cpp.

9525{
9526 double s = 202. * 202.;
9528}

◆ getIntegrand_AFBnumeratorWithISR_charm205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm205 ( double  x) const
protected

Definition at line 9530 of file StandardModel/src/StandardModel.cpp.

9531{
9532 double s = 205. * 205.;
9534}

◆ getIntegrand_AFBnumeratorWithISR_charm207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_charm207 ( double  x) const
protected

Definition at line 9536 of file StandardModel/src/StandardModel.cpp.

9537{
9538 double s = 207. * 207.;
9540}

◆ getIntegrand_AFBnumeratorWithISR_mu130()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu130 ( double  x) const
protected

Definition at line 9314 of file StandardModel/src/StandardModel.cpp.

9315{
9316 double s = 130. * 130.;
9318}
lepton
An enum type for leptons.
Definition: QCD.h:310
const double Integrand_AFBnumeratorWithISR_l(double x, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_AFBnumeratorWithISR_mu136()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu136 ( double  x) const
protected

Definition at line 9320 of file StandardModel/src/StandardModel.cpp.

9321{
9322 double s = 136. * 136.;
9324}

◆ getIntegrand_AFBnumeratorWithISR_mu161()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu161 ( double  x) const
protected

Definition at line 9326 of file StandardModel/src/StandardModel.cpp.

9327{
9328 double s = 161. * 161.;
9330}

◆ getIntegrand_AFBnumeratorWithISR_mu172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu172 ( double  x) const
protected

Definition at line 9332 of file StandardModel/src/StandardModel.cpp.

9333{
9334 double s = 172. * 172.;
9336}

◆ getIntegrand_AFBnumeratorWithISR_mu183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu183 ( double  x) const
protected

Definition at line 9338 of file StandardModel/src/StandardModel.cpp.

9339{
9340 double s = 183. * 183.;
9342}

◆ getIntegrand_AFBnumeratorWithISR_mu189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu189 ( double  x) const
protected

Definition at line 9344 of file StandardModel/src/StandardModel.cpp.

9345{
9346 double s = 189. * 189.;
9348}

◆ getIntegrand_AFBnumeratorWithISR_mu192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu192 ( double  x) const
protected

Definition at line 9350 of file StandardModel/src/StandardModel.cpp.

9351{
9352 double s = 192. * 192.;
9354}

◆ getIntegrand_AFBnumeratorWithISR_mu196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu196 ( double  x) const
protected

Definition at line 9356 of file StandardModel/src/StandardModel.cpp.

9357{
9358 double s = 196. * 196.;
9360}

◆ getIntegrand_AFBnumeratorWithISR_mu200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu200 ( double  x) const
protected

Definition at line 9362 of file StandardModel/src/StandardModel.cpp.

9363{
9364 double s = 200. * 200.;
9366}

◆ getIntegrand_AFBnumeratorWithISR_mu202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu202 ( double  x) const
protected

Definition at line 9368 of file StandardModel/src/StandardModel.cpp.

9369{
9370 double s = 202. * 202.;
9372}

◆ getIntegrand_AFBnumeratorWithISR_mu205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu205 ( double  x) const
protected

Definition at line 9374 of file StandardModel/src/StandardModel.cpp.

9375{
9376 double s = 205. * 205.;
9378}

◆ getIntegrand_AFBnumeratorWithISR_mu207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_mu207 ( double  x) const
protected

Definition at line 9380 of file StandardModel/src/StandardModel.cpp.

9381{
9382 double s = 207. * 207.;
9384}

◆ getIntegrand_AFBnumeratorWithISR_tau130()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau130 ( double  x) const
protected

Definition at line 9387 of file StandardModel/src/StandardModel.cpp.

9388{
9389 double s = 130. * 130.;
9391}

◆ getIntegrand_AFBnumeratorWithISR_tau136()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau136 ( double  x) const
protected

Definition at line 9393 of file StandardModel/src/StandardModel.cpp.

9394{
9395 double s = 136. * 136.;
9397}

◆ getIntegrand_AFBnumeratorWithISR_tau161()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau161 ( double  x) const
protected

Definition at line 9399 of file StandardModel/src/StandardModel.cpp.

9400{
9401 double s = 161. * 161.;
9403}

◆ getIntegrand_AFBnumeratorWithISR_tau172()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau172 ( double  x) const
protected

Definition at line 9405 of file StandardModel/src/StandardModel.cpp.

9406{
9407 double s = 172. * 172.;
9409}

◆ getIntegrand_AFBnumeratorWithISR_tau183()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau183 ( double  x) const
protected

Definition at line 9411 of file StandardModel/src/StandardModel.cpp.

9412{
9413 double s = 183. * 183.;
9415}

◆ getIntegrand_AFBnumeratorWithISR_tau189()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau189 ( double  x) const
protected

Definition at line 9417 of file StandardModel/src/StandardModel.cpp.

9418{
9419 double s = 189. * 189.;
9421}

◆ getIntegrand_AFBnumeratorWithISR_tau192()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau192 ( double  x) const
protected

Definition at line 9423 of file StandardModel/src/StandardModel.cpp.

9424{
9425 double s = 192. * 192.;
9427}

◆ getIntegrand_AFBnumeratorWithISR_tau196()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau196 ( double  x) const
protected

Definition at line 9429 of file StandardModel/src/StandardModel.cpp.

9430{
9431 double s = 196. * 196.;
9433}

◆ getIntegrand_AFBnumeratorWithISR_tau200()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau200 ( double  x) const
protected

Definition at line 9435 of file StandardModel/src/StandardModel.cpp.

9436{
9437 double s = 200. * 200.;
9439}

◆ getIntegrand_AFBnumeratorWithISR_tau202()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau202 ( double  x) const
protected

Definition at line 9441 of file StandardModel/src/StandardModel.cpp.

9442{
9443 double s = 202. * 202.;
9445}

◆ getIntegrand_AFBnumeratorWithISR_tau205()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau205 ( double  x) const
protected

Definition at line 9447 of file StandardModel/src/StandardModel.cpp.

9448{
9449 double s = 205. * 205.;
9451}

◆ getIntegrand_AFBnumeratorWithISR_tau207()

const double StandardModel::getIntegrand_AFBnumeratorWithISR_tau207 ( double  x) const
protected

Definition at line 9453 of file StandardModel/src/StandardModel.cpp.

9454{
9455 double s = 207. * 207.;
9457}

◆ getIntegrand_dsigmaBox_bottom130()

const double StandardModel::getIntegrand_dsigmaBox_bottom130 ( double  x) const
protected

Definition at line 9206 of file StandardModel/src/StandardModel.cpp.

9207{
9208 double s = 130. * 130.;
9210}
const double Integrand_dsigmaBox_q(double cosTheta, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_dsigmaBox_bottom133()

const double StandardModel::getIntegrand_dsigmaBox_bottom133 ( double  x) const
protected

Definition at line 9212 of file StandardModel/src/StandardModel.cpp.

9213{
9214 double s = 133. * 133.;
9216}

◆ getIntegrand_dsigmaBox_bottom136()

const double StandardModel::getIntegrand_dsigmaBox_bottom136 ( double  x) const
protected

Definition at line 9218 of file StandardModel/src/StandardModel.cpp.

9219{
9220 double s = 136. * 136.;
9222}

◆ getIntegrand_dsigmaBox_bottom161()

const double StandardModel::getIntegrand_dsigmaBox_bottom161 ( double  x) const
protected

Definition at line 9224 of file StandardModel/src/StandardModel.cpp.

9225{
9226 double s = 161. * 161.;
9228}

◆ getIntegrand_dsigmaBox_bottom167()

const double StandardModel::getIntegrand_dsigmaBox_bottom167 ( double  x) const
protected

Definition at line 9230 of file StandardModel/src/StandardModel.cpp.

9231{
9232 double s = 167. * 167.;
9234}

◆ getIntegrand_dsigmaBox_bottom172()

const double StandardModel::getIntegrand_dsigmaBox_bottom172 ( double  x) const
protected

Definition at line 9236 of file StandardModel/src/StandardModel.cpp.

9237{
9238 double s = 172. * 172.;
9240}

◆ getIntegrand_dsigmaBox_bottom183()

const double StandardModel::getIntegrand_dsigmaBox_bottom183 ( double  x) const
protected

Definition at line 9242 of file StandardModel/src/StandardModel.cpp.

9243{
9244 double s = 183. * 183.;
9246}

◆ getIntegrand_dsigmaBox_bottom189()

const double StandardModel::getIntegrand_dsigmaBox_bottom189 ( double  x) const
protected

Definition at line 9248 of file StandardModel/src/StandardModel.cpp.

9249{
9250 double s = 189. * 189.;
9252}

◆ getIntegrand_dsigmaBox_bottom192()

const double StandardModel::getIntegrand_dsigmaBox_bottom192 ( double  x) const
protected

Definition at line 9254 of file StandardModel/src/StandardModel.cpp.

9255{
9256 double s = 192. * 192.;
9258}

◆ getIntegrand_dsigmaBox_bottom196()

const double StandardModel::getIntegrand_dsigmaBox_bottom196 ( double  x) const
protected

Definition at line 9260 of file StandardModel/src/StandardModel.cpp.

9261{
9262 double s = 196. * 196.;
9264}

◆ getIntegrand_dsigmaBox_bottom200()

const double StandardModel::getIntegrand_dsigmaBox_bottom200 ( double  x) const
protected

Definition at line 9266 of file StandardModel/src/StandardModel.cpp.

9267{
9268 double s = 200. * 200.;
9270}

◆ getIntegrand_dsigmaBox_bottom202()

const double StandardModel::getIntegrand_dsigmaBox_bottom202 ( double  x) const
protected

Definition at line 9272 of file StandardModel/src/StandardModel.cpp.

9273{
9274 double s = 202. * 202.;
9276}

◆ getIntegrand_dsigmaBox_bottom205()

const double StandardModel::getIntegrand_dsigmaBox_bottom205 ( double  x) const
protected

Definition at line 9278 of file StandardModel/src/StandardModel.cpp.

9279{
9280 double s = 205. * 205.;
9282}

◆ getIntegrand_dsigmaBox_bottom207()

const double StandardModel::getIntegrand_dsigmaBox_bottom207 ( double  x) const
protected

Definition at line 9284 of file StandardModel/src/StandardModel.cpp.

9285{
9286 double s = 207. * 207.;
9288}

◆ getIntegrand_dsigmaBox_charm130()

const double StandardModel::getIntegrand_dsigmaBox_charm130 ( double  x) const
protected

Definition at line 9028 of file StandardModel/src/StandardModel.cpp.

9029{
9030 double s = 130. * 130.;
9031 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9032}

◆ getIntegrand_dsigmaBox_charm133()

const double StandardModel::getIntegrand_dsigmaBox_charm133 ( double  x) const
protected

Definition at line 9034 of file StandardModel/src/StandardModel.cpp.

9035{
9036 double s = 133. * 133.;
9037 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9038}

◆ getIntegrand_dsigmaBox_charm136()

const double StandardModel::getIntegrand_dsigmaBox_charm136 ( double  x) const
protected

Definition at line 9040 of file StandardModel/src/StandardModel.cpp.

9041{
9042 double s = 136. * 136.;
9043 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9044}

◆ getIntegrand_dsigmaBox_charm161()

const double StandardModel::getIntegrand_dsigmaBox_charm161 ( double  x) const
protected

Definition at line 9046 of file StandardModel/src/StandardModel.cpp.

9047{
9048 double s = 161. * 161.;
9049 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9050}

◆ getIntegrand_dsigmaBox_charm167()

const double StandardModel::getIntegrand_dsigmaBox_charm167 ( double  x) const
protected

Definition at line 9052 of file StandardModel/src/StandardModel.cpp.

9053{
9054 double s = 167. * 167.;
9055 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9056}

◆ getIntegrand_dsigmaBox_charm172()

const double StandardModel::getIntegrand_dsigmaBox_charm172 ( double  x) const
protected

Definition at line 9058 of file StandardModel/src/StandardModel.cpp.

9059{
9060 double s = 172. * 172.;
9061 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9062}

◆ getIntegrand_dsigmaBox_charm183()

const double StandardModel::getIntegrand_dsigmaBox_charm183 ( double  x) const
protected

Definition at line 9064 of file StandardModel/src/StandardModel.cpp.

9065{
9066 double s = 183. * 183.;
9067 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9068}

◆ getIntegrand_dsigmaBox_charm189()

const double StandardModel::getIntegrand_dsigmaBox_charm189 ( double  x) const
protected

Definition at line 9070 of file StandardModel/src/StandardModel.cpp.

9071{
9072 double s = 189. * 189.;
9073 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9074}

◆ getIntegrand_dsigmaBox_charm192()

const double StandardModel::getIntegrand_dsigmaBox_charm192 ( double  x) const
protected

Definition at line 9076 of file StandardModel/src/StandardModel.cpp.

9077{
9078 double s = 192. * 192.;
9079 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9080}

◆ getIntegrand_dsigmaBox_charm196()

const double StandardModel::getIntegrand_dsigmaBox_charm196 ( double  x) const
protected

Definition at line 9082 of file StandardModel/src/StandardModel.cpp.

9083{
9084 double s = 196. * 196.;
9085 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9086}

◆ getIntegrand_dsigmaBox_charm200()

const double StandardModel::getIntegrand_dsigmaBox_charm200 ( double  x) const
protected

Definition at line 9088 of file StandardModel/src/StandardModel.cpp.

9089{
9090 double s = 200. * 200.;
9091 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9092}

◆ getIntegrand_dsigmaBox_charm202()

const double StandardModel::getIntegrand_dsigmaBox_charm202 ( double  x) const
protected

Definition at line 9094 of file StandardModel/src/StandardModel.cpp.

9095{
9096 double s = 202. * 202.;
9097 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9098}

◆ getIntegrand_dsigmaBox_charm205()

const double StandardModel::getIntegrand_dsigmaBox_charm205 ( double  x) const
protected

Definition at line 9100 of file StandardModel/src/StandardModel.cpp.

9101{
9102 double s = 205. * 205.;
9103 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9104}

◆ getIntegrand_dsigmaBox_charm207()

const double StandardModel::getIntegrand_dsigmaBox_charm207 ( double  x) const
protected

Definition at line 9106 of file StandardModel/src/StandardModel.cpp.

9107{
9108 double s = 207. * 207.;
9109 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9110}

◆ getIntegrand_dsigmaBox_down130()

const double StandardModel::getIntegrand_dsigmaBox_down130 ( double  x) const
protected

Definition at line 8940 of file StandardModel/src/StandardModel.cpp.

8941{
8942 double s = 130. * 130.;
8943 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8944}

◆ getIntegrand_dsigmaBox_down133()

const double StandardModel::getIntegrand_dsigmaBox_down133 ( double  x) const
protected

Definition at line 8946 of file StandardModel/src/StandardModel.cpp.

8947{
8948 double s = 133. * 133.;
8949 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8950}

◆ getIntegrand_dsigmaBox_down136()

const double StandardModel::getIntegrand_dsigmaBox_down136 ( double  x) const
protected

Definition at line 8952 of file StandardModel/src/StandardModel.cpp.

8953{
8954 double s = 136. * 136.;
8955 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8956}

◆ getIntegrand_dsigmaBox_down161()

const double StandardModel::getIntegrand_dsigmaBox_down161 ( double  x) const
protected

Definition at line 8958 of file StandardModel/src/StandardModel.cpp.

8959{
8960 double s = 161. * 161.;
8961 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8962}

◆ getIntegrand_dsigmaBox_down167()

const double StandardModel::getIntegrand_dsigmaBox_down167 ( double  x) const
protected

Definition at line 8964 of file StandardModel/src/StandardModel.cpp.

8965{
8966 double s = 167. * 167.;
8967 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8968}

◆ getIntegrand_dsigmaBox_down172()

const double StandardModel::getIntegrand_dsigmaBox_down172 ( double  x) const
protected

Definition at line 8970 of file StandardModel/src/StandardModel.cpp.

8971{
8972 double s = 172. * 172.;
8973 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8974}

◆ getIntegrand_dsigmaBox_down183()

const double StandardModel::getIntegrand_dsigmaBox_down183 ( double  x) const
protected

Definition at line 8976 of file StandardModel/src/StandardModel.cpp.

8977{
8978 double s = 183. * 183.;
8979 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8980}

◆ getIntegrand_dsigmaBox_down189()

const double StandardModel::getIntegrand_dsigmaBox_down189 ( double  x) const
protected

Definition at line 8982 of file StandardModel/src/StandardModel.cpp.

8983{
8984 double s = 189. * 189.;
8985 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8986}

◆ getIntegrand_dsigmaBox_down192()

const double StandardModel::getIntegrand_dsigmaBox_down192 ( double  x) const
protected

Definition at line 8988 of file StandardModel/src/StandardModel.cpp.

8989{
8990 double s = 192. * 192.;
8991 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8992}

◆ getIntegrand_dsigmaBox_down196()

const double StandardModel::getIntegrand_dsigmaBox_down196 ( double  x) const
protected

Definition at line 8994 of file StandardModel/src/StandardModel.cpp.

8995{
8996 double s = 196. * 196.;
8997 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8998}

◆ getIntegrand_dsigmaBox_down200()

const double StandardModel::getIntegrand_dsigmaBox_down200 ( double  x) const
protected

Definition at line 9000 of file StandardModel/src/StandardModel.cpp.

9001{
9002 double s = 200. * 200.;
9003 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9004}

◆ getIntegrand_dsigmaBox_down202()

const double StandardModel::getIntegrand_dsigmaBox_down202 ( double  x) const
protected

Definition at line 9006 of file StandardModel/src/StandardModel.cpp.

9007{
9008 double s = 202. * 202.;
9009 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9010}

◆ getIntegrand_dsigmaBox_down205()

const double StandardModel::getIntegrand_dsigmaBox_down205 ( double  x) const
protected

Definition at line 9012 of file StandardModel/src/StandardModel.cpp.

9013{
9014 double s = 205. * 205.;
9015 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9016}

◆ getIntegrand_dsigmaBox_down207()

const double StandardModel::getIntegrand_dsigmaBox_down207 ( double  x) const
protected

Definition at line 9018 of file StandardModel/src/StandardModel.cpp.

9019{
9020 double s = 207. * 207.;
9021 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
9022}

◆ getIntegrand_dsigmaBox_mu130()

const double StandardModel::getIntegrand_dsigmaBox_mu130 ( double  x) const
protected

Definition at line 8688 of file StandardModel/src/StandardModel.cpp.

8689{
8690 double s = 130. * 130.;
8691 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8692}
const double Integrand_dsigmaBox_l(double cosTheta, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_dsigmaBox_mu133()

const double StandardModel::getIntegrand_dsigmaBox_mu133 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_mu136()

const double StandardModel::getIntegrand_dsigmaBox_mu136 ( double  x) const
protected

Definition at line 8694 of file StandardModel/src/StandardModel.cpp.

8695{
8696 double s = 136. * 136.;
8697 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8698}

◆ getIntegrand_dsigmaBox_mu161()

const double StandardModel::getIntegrand_dsigmaBox_mu161 ( double  x) const
protected

Definition at line 8700 of file StandardModel/src/StandardModel.cpp.

8701{
8702 double s = 161. * 161.;
8703 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8704}

◆ getIntegrand_dsigmaBox_mu167()

const double StandardModel::getIntegrand_dsigmaBox_mu167 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_mu172()

const double StandardModel::getIntegrand_dsigmaBox_mu172 ( double  x) const
protected

Definition at line 8706 of file StandardModel/src/StandardModel.cpp.

8707{
8708 double s = 172. * 172.;
8709 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8710}

◆ getIntegrand_dsigmaBox_mu183()

const double StandardModel::getIntegrand_dsigmaBox_mu183 ( double  x) const
protected

Definition at line 8712 of file StandardModel/src/StandardModel.cpp.

8713{
8714 double s = 183. * 183.;
8715 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8716}

◆ getIntegrand_dsigmaBox_mu189()

const double StandardModel::getIntegrand_dsigmaBox_mu189 ( double  x) const
protected

Definition at line 8718 of file StandardModel/src/StandardModel.cpp.

8719{
8720 double s = 189. * 189.;
8721 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8722}

◆ getIntegrand_dsigmaBox_mu192()

const double StandardModel::getIntegrand_dsigmaBox_mu192 ( double  x) const
protected

Definition at line 8724 of file StandardModel/src/StandardModel.cpp.

8725{
8726 double s = 192. * 192.;
8727 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8728}

◆ getIntegrand_dsigmaBox_mu196()

const double StandardModel::getIntegrand_dsigmaBox_mu196 ( double  x) const
protected

Definition at line 8730 of file StandardModel/src/StandardModel.cpp.

8731{
8732 double s = 196. * 196.;
8733 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8734}

◆ getIntegrand_dsigmaBox_mu200()

const double StandardModel::getIntegrand_dsigmaBox_mu200 ( double  x) const
protected

Definition at line 8736 of file StandardModel/src/StandardModel.cpp.

8737{
8738 double s = 200. * 200.;
8739 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8740}

◆ getIntegrand_dsigmaBox_mu202()

const double StandardModel::getIntegrand_dsigmaBox_mu202 ( double  x) const
protected

Definition at line 8742 of file StandardModel/src/StandardModel.cpp.

8743{
8744 double s = 202. * 202.;
8745 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8746}

◆ getIntegrand_dsigmaBox_mu205()

const double StandardModel::getIntegrand_dsigmaBox_mu205 ( double  x) const
protected

Definition at line 8748 of file StandardModel/src/StandardModel.cpp.

8749{
8750 double s = 205. * 205.;
8751 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8752}

◆ getIntegrand_dsigmaBox_mu207()

const double StandardModel::getIntegrand_dsigmaBox_mu207 ( double  x) const
protected

Definition at line 8754 of file StandardModel/src/StandardModel.cpp.

8755{
8756 double s = 207. * 207.;
8757 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8758}

◆ getIntegrand_dsigmaBox_strange130()

const double StandardModel::getIntegrand_dsigmaBox_strange130 ( double  x) const
protected

Definition at line 9116 of file StandardModel/src/StandardModel.cpp.

9117{
9118 double s = 130. * 130.;
9120}

◆ getIntegrand_dsigmaBox_strange133()

const double StandardModel::getIntegrand_dsigmaBox_strange133 ( double  x) const
protected

Definition at line 9122 of file StandardModel/src/StandardModel.cpp.

9123{
9124 double s = 133. * 133.;
9126}

◆ getIntegrand_dsigmaBox_strange136()

const double StandardModel::getIntegrand_dsigmaBox_strange136 ( double  x) const
protected

Definition at line 9128 of file StandardModel/src/StandardModel.cpp.

9129{
9130 double s = 136. * 136.;
9132}

◆ getIntegrand_dsigmaBox_strange161()

const double StandardModel::getIntegrand_dsigmaBox_strange161 ( double  x) const
protected

Definition at line 9134 of file StandardModel/src/StandardModel.cpp.

9135{
9136 double s = 161. * 161.;
9138}

◆ getIntegrand_dsigmaBox_strange167()

const double StandardModel::getIntegrand_dsigmaBox_strange167 ( double  x) const
protected

Definition at line 9140 of file StandardModel/src/StandardModel.cpp.

9141{
9142 double s = 167. * 167.;
9144}

◆ getIntegrand_dsigmaBox_strange172()

const double StandardModel::getIntegrand_dsigmaBox_strange172 ( double  x) const
protected

Definition at line 9148 of file StandardModel/src/StandardModel.cpp.

9149{
9150 double s = 172. * 172.;
9152}

◆ getIntegrand_dsigmaBox_strange183()

const double StandardModel::getIntegrand_dsigmaBox_strange183 ( double  x) const
protected

Definition at line 9154 of file StandardModel/src/StandardModel.cpp.

9155{
9156 double s = 183. * 183.;
9158}

◆ getIntegrand_dsigmaBox_strange189()

const double StandardModel::getIntegrand_dsigmaBox_strange189 ( double  x) const
protected

Definition at line 9160 of file StandardModel/src/StandardModel.cpp.

9161{
9162 double s = 189. * 189.;
9164}

◆ getIntegrand_dsigmaBox_strange192()

const double StandardModel::getIntegrand_dsigmaBox_strange192 ( double  x) const
protected

Definition at line 9166 of file StandardModel/src/StandardModel.cpp.

9167{
9168 double s = 192. * 192.;
9170}

◆ getIntegrand_dsigmaBox_strange196()

const double StandardModel::getIntegrand_dsigmaBox_strange196 ( double  x) const
protected

Definition at line 9172 of file StandardModel/src/StandardModel.cpp.

9173{
9174 double s = 196. * 196.;
9176}

◆ getIntegrand_dsigmaBox_strange200()

const double StandardModel::getIntegrand_dsigmaBox_strange200 ( double  x) const
protected

Definition at line 9178 of file StandardModel/src/StandardModel.cpp.

9179{
9180 double s = 200. * 200.;
9182}

◆ getIntegrand_dsigmaBox_strange202()

const double StandardModel::getIntegrand_dsigmaBox_strange202 ( double  x) const
protected

Definition at line 9184 of file StandardModel/src/StandardModel.cpp.

9185{
9186 double s = 202. * 202.;
9188}

◆ getIntegrand_dsigmaBox_strange205()

const double StandardModel::getIntegrand_dsigmaBox_strange205 ( double  x) const
protected

Definition at line 9190 of file StandardModel/src/StandardModel.cpp.

9191{
9192 double s = 205. * 205.;
9194}

◆ getIntegrand_dsigmaBox_strange207()

const double StandardModel::getIntegrand_dsigmaBox_strange207 ( double  x) const
protected

Definition at line 9196 of file StandardModel/src/StandardModel.cpp.

9197{
9198 double s = 207. * 207.;
9200}

◆ getIntegrand_dsigmaBox_tau130()

const double StandardModel::getIntegrand_dsigmaBox_tau130 ( double  x) const
protected

Definition at line 8764 of file StandardModel/src/StandardModel.cpp.

8765{
8766 double s = 130. * 130.;
8767 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8768}

◆ getIntegrand_dsigmaBox_tau133()

const double StandardModel::getIntegrand_dsigmaBox_tau133 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_tau136()

const double StandardModel::getIntegrand_dsigmaBox_tau136 ( double  x) const
protected

Definition at line 8770 of file StandardModel/src/StandardModel.cpp.

8771{
8772 double s = 136. * 136.;
8773 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8774}

◆ getIntegrand_dsigmaBox_tau161()

const double StandardModel::getIntegrand_dsigmaBox_tau161 ( double  x) const
protected

Definition at line 8776 of file StandardModel/src/StandardModel.cpp.

8777{
8778 double s = 161. * 161.;
8779 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8780}

◆ getIntegrand_dsigmaBox_tau167()

const double StandardModel::getIntegrand_dsigmaBox_tau167 ( double  x) const
protected

◆ getIntegrand_dsigmaBox_tau172()

const double StandardModel::getIntegrand_dsigmaBox_tau172 ( double  x) const
protected

Definition at line 8782 of file StandardModel/src/StandardModel.cpp.

8783{
8784 double s = 172. * 172.;
8785 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8786}

◆ getIntegrand_dsigmaBox_tau183()

const double StandardModel::getIntegrand_dsigmaBox_tau183 ( double  x) const
protected

Definition at line 8788 of file StandardModel/src/StandardModel.cpp.

8789{
8790 double s = 183. * 183.;
8791 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8792}

◆ getIntegrand_dsigmaBox_tau189()

const double StandardModel::getIntegrand_dsigmaBox_tau189 ( double  x) const
protected

Definition at line 8794 of file StandardModel/src/StandardModel.cpp.

8795{
8796 double s = 189. * 189.;
8797 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8798}

◆ getIntegrand_dsigmaBox_tau192()

const double StandardModel::getIntegrand_dsigmaBox_tau192 ( double  x) const
protected

Definition at line 8800 of file StandardModel/src/StandardModel.cpp.

8801{
8802 double s = 192. * 192.;
8803 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8804}

◆ getIntegrand_dsigmaBox_tau196()

const double StandardModel::getIntegrand_dsigmaBox_tau196 ( double  x) const
protected

Definition at line 8806 of file StandardModel/src/StandardModel.cpp.

8807{
8808 double s = 196. * 196.;
8809 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8810}

◆ getIntegrand_dsigmaBox_tau200()

const double StandardModel::getIntegrand_dsigmaBox_tau200 ( double  x) const
protected

Definition at line 8812 of file StandardModel/src/StandardModel.cpp.

8813{
8814 double s = 200. * 200.;
8815 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8816}

◆ getIntegrand_dsigmaBox_tau202()

const double StandardModel::getIntegrand_dsigmaBox_tau202 ( double  x) const
protected

Definition at line 8818 of file StandardModel/src/StandardModel.cpp.

8819{
8820 double s = 202. * 202.;
8821 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8822}

◆ getIntegrand_dsigmaBox_tau205()

const double StandardModel::getIntegrand_dsigmaBox_tau205 ( double  x) const
protected

Definition at line 8824 of file StandardModel/src/StandardModel.cpp.

8825{
8826 double s = 205. * 205.;
8827 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8828}

◆ getIntegrand_dsigmaBox_tau207()

const double StandardModel::getIntegrand_dsigmaBox_tau207 ( double  x) const
protected

Definition at line 8830 of file StandardModel/src/StandardModel.cpp.

8831{
8832 double s = 207. * 207.;
8833 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8834}

◆ getIntegrand_dsigmaBox_up130()

const double StandardModel::getIntegrand_dsigmaBox_up130 ( double  x) const
protected

Definition at line 8853 of file StandardModel/src/StandardModel.cpp.

8854{
8855 double s = 130. * 130.;
8856 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8857}

◆ getIntegrand_dsigmaBox_up133()

const double StandardModel::getIntegrand_dsigmaBox_up133 ( double  x) const
protected

Definition at line 8859 of file StandardModel/src/StandardModel.cpp.

8860{
8861 double s = 133. * 133.;
8862 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8863}

◆ getIntegrand_dsigmaBox_up136()

const double StandardModel::getIntegrand_dsigmaBox_up136 ( double  x) const
protected

Definition at line 8865 of file StandardModel/src/StandardModel.cpp.

8866{
8867 double s = 136. * 136.;
8868 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8869}

◆ getIntegrand_dsigmaBox_up161()

const double StandardModel::getIntegrand_dsigmaBox_up161 ( double  x) const
protected

Definition at line 8871 of file StandardModel/src/StandardModel.cpp.

8872{
8873 double s = 161. * 161.;
8874 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8875}

◆ getIntegrand_dsigmaBox_up167()

const double StandardModel::getIntegrand_dsigmaBox_up167 ( double  x) const
protected

Definition at line 8877 of file StandardModel/src/StandardModel.cpp.

8878{
8879 double s = 167. * 167.;
8880 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8881}

◆ getIntegrand_dsigmaBox_up172()

const double StandardModel::getIntegrand_dsigmaBox_up172 ( double  x) const
protected

Definition at line 8883 of file StandardModel/src/StandardModel.cpp.

8884{
8885 double s = 172. * 172.;
8886 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8887}

◆ getIntegrand_dsigmaBox_up183()

const double StandardModel::getIntegrand_dsigmaBox_up183 ( double  x) const
protected

Definition at line 8889 of file StandardModel/src/StandardModel.cpp.

8890{
8891 double s = 183. * 183.;
8892 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8893}

◆ getIntegrand_dsigmaBox_up189()

const double StandardModel::getIntegrand_dsigmaBox_up189 ( double  x) const
protected

Definition at line 8895 of file StandardModel/src/StandardModel.cpp.

8896{
8897 double s = 189. * 189.;
8898 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8899}

◆ getIntegrand_dsigmaBox_up192()

const double StandardModel::getIntegrand_dsigmaBox_up192 ( double  x) const
protected

Definition at line 8901 of file StandardModel/src/StandardModel.cpp.

8902{
8903 double s = 192. * 192.;
8904 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8905}

◆ getIntegrand_dsigmaBox_up196()

const double StandardModel::getIntegrand_dsigmaBox_up196 ( double  x) const
protected

Definition at line 8907 of file StandardModel/src/StandardModel.cpp.

8908{
8909 double s = 196. * 196.;
8910 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8911}

◆ getIntegrand_dsigmaBox_up200()

const double StandardModel::getIntegrand_dsigmaBox_up200 ( double  x) const
protected

Definition at line 8913 of file StandardModel/src/StandardModel.cpp.

8914{
8915 double s = 200. * 200.;
8916 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8917}

◆ getIntegrand_dsigmaBox_up202()

const double StandardModel::getIntegrand_dsigmaBox_up202 ( double  x) const
protected

Definition at line 8919 of file StandardModel/src/StandardModel.cpp.

8920{
8921 double s = 202. * 202.;
8922 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8923}

◆ getIntegrand_dsigmaBox_up205()

const double StandardModel::getIntegrand_dsigmaBox_up205 ( double  x) const
protected

Definition at line 8925 of file StandardModel/src/StandardModel.cpp.

8926{
8927 double s = 205. * 205.;
8928 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8929}

◆ getIntegrand_dsigmaBox_up207()

const double StandardModel::getIntegrand_dsigmaBox_up207 ( double  x) const
protected

Definition at line 8931 of file StandardModel/src/StandardModel.cpp.

8932{
8933 double s = 207. * 207.;
8934 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8935}

◆ getIntegrand_sigmaWithISR_bottom130()

const double StandardModel::getIntegrand_sigmaWithISR_bottom130 ( double  x) const
protected

Definition at line 8594 of file StandardModel/src/StandardModel.cpp.

8595{
8596 double s = 130. * 130.;
8598}
const double Integrand_sigmaWithISR_q(double x, const QCD::quark q_flavor, const double s) const

◆ getIntegrand_sigmaWithISR_bottom133()

const double StandardModel::getIntegrand_sigmaWithISR_bottom133 ( double  x) const
protected

Definition at line 8600 of file StandardModel/src/StandardModel.cpp.

8601{
8602 double s = 133. * 133.;
8604}

◆ getIntegrand_sigmaWithISR_bottom136()

const double StandardModel::getIntegrand_sigmaWithISR_bottom136 ( double  x) const
protected

Definition at line 8606 of file StandardModel/src/StandardModel.cpp.

8607{
8608 double s = 136. * 136.;
8610}

◆ getIntegrand_sigmaWithISR_bottom161()

const double StandardModel::getIntegrand_sigmaWithISR_bottom161 ( double  x) const
protected

Definition at line 8612 of file StandardModel/src/StandardModel.cpp.

8613{
8614 double s = 161. * 161.;
8616}

◆ getIntegrand_sigmaWithISR_bottom167()

const double StandardModel::getIntegrand_sigmaWithISR_bottom167 ( double  x) const
protected

Definition at line 8618 of file StandardModel/src/StandardModel.cpp.

8619{
8620 double s = 167. * 167.;
8622}

◆ getIntegrand_sigmaWithISR_bottom172()

const double StandardModel::getIntegrand_sigmaWithISR_bottom172 ( double  x) const
protected

Definition at line 8624 of file StandardModel/src/StandardModel.cpp.

8625{
8626 double s = 172. * 172.;
8628}

◆ getIntegrand_sigmaWithISR_bottom183()

const double StandardModel::getIntegrand_sigmaWithISR_bottom183 ( double  x) const
protected

Definition at line 8630 of file StandardModel/src/StandardModel.cpp.

8631{
8632 double s = 183. * 183.;
8634}

◆ getIntegrand_sigmaWithISR_bottom189()

const double StandardModel::getIntegrand_sigmaWithISR_bottom189 ( double  x) const
protected

Definition at line 8636 of file StandardModel/src/StandardModel.cpp.

8637{
8638 double s = 189. * 189.;
8640}

◆ getIntegrand_sigmaWithISR_bottom192()

const double StandardModel::getIntegrand_sigmaWithISR_bottom192 ( double  x) const
protected

Definition at line 8642 of file StandardModel/src/StandardModel.cpp.

8643{
8644 double s = 192. * 192.;
8646}

◆ getIntegrand_sigmaWithISR_bottom196()

const double StandardModel::getIntegrand_sigmaWithISR_bottom196 ( double  x) const
protected

Definition at line 8648 of file StandardModel/src/StandardModel.cpp.

8649{
8650 double s = 196. * 196.;
8652}

◆ getIntegrand_sigmaWithISR_bottom200()

const double StandardModel::getIntegrand_sigmaWithISR_bottom200 ( double  x) const
protected

Definition at line 8654 of file StandardModel/src/StandardModel.cpp.

8655{
8656 double s = 200. * 200.;
8658}

◆ getIntegrand_sigmaWithISR_bottom202()

const double StandardModel::getIntegrand_sigmaWithISR_bottom202 ( double  x) const
protected

Definition at line 8660 of file StandardModel/src/StandardModel.cpp.

8661{
8662 double s = 202. * 202.;
8664}

◆ getIntegrand_sigmaWithISR_bottom205()

const double StandardModel::getIntegrand_sigmaWithISR_bottom205 ( double  x) const
protected

Definition at line 8666 of file StandardModel/src/StandardModel.cpp.

8667{
8668 double s = 205. * 205.;
8670}

◆ getIntegrand_sigmaWithISR_bottom207()

const double StandardModel::getIntegrand_sigmaWithISR_bottom207 ( double  x) const
protected

Definition at line 8672 of file StandardModel/src/StandardModel.cpp.

8673{
8674 double s = 207. * 207.;
8676}

◆ getIntegrand_sigmaWithISR_charm130()

const double StandardModel::getIntegrand_sigmaWithISR_charm130 ( double  x) const
protected

Definition at line 8418 of file StandardModel/src/StandardModel.cpp.

8419{
8420 double s = 130. * 130.;
8422}

◆ getIntegrand_sigmaWithISR_charm133()

const double StandardModel::getIntegrand_sigmaWithISR_charm133 ( double  x) const
protected

Definition at line 8424 of file StandardModel/src/StandardModel.cpp.

8425{
8426 double s = 133. * 133.;
8428}

◆ getIntegrand_sigmaWithISR_charm136()

const double StandardModel::getIntegrand_sigmaWithISR_charm136 ( double  x) const
protected

Definition at line 8430 of file StandardModel/src/StandardModel.cpp.

8431{
8432 double s = 136. * 136.;
8434}

◆ getIntegrand_sigmaWithISR_charm161()

const double StandardModel::getIntegrand_sigmaWithISR_charm161 ( double  x) const
protected

Definition at line 8436 of file StandardModel/src/StandardModel.cpp.

8437{
8438 double s = 161. * 161.;
8440}

◆ getIntegrand_sigmaWithISR_charm167()

const double StandardModel::getIntegrand_sigmaWithISR_charm167 ( double  x) const
protected

Definition at line 8442 of file StandardModel/src/StandardModel.cpp.

8443{
8444 double s = 167. * 167.;
8446}

◆ getIntegrand_sigmaWithISR_charm172()

const double StandardModel::getIntegrand_sigmaWithISR_charm172 ( double  x) const
protected

Definition at line 8448 of file StandardModel/src/StandardModel.cpp.

8449{
8450 double s = 172. * 172.;
8452}

◆ getIntegrand_sigmaWithISR_charm183()

const double StandardModel::getIntegrand_sigmaWithISR_charm183 ( double  x) const
protected

Definition at line 8454 of file StandardModel/src/StandardModel.cpp.

8455{
8456 double s = 183. * 183.;
8458}

◆ getIntegrand_sigmaWithISR_charm189()

const double StandardModel::getIntegrand_sigmaWithISR_charm189 ( double  x) const
protected

Definition at line 8460 of file StandardModel/src/StandardModel.cpp.

8461{
8462 double s = 189. * 189.;
8464}

◆ getIntegrand_sigmaWithISR_charm192()

const double StandardModel::getIntegrand_sigmaWithISR_charm192 ( double  x) const
protected

Definition at line 8466 of file StandardModel/src/StandardModel.cpp.

8467{
8468 double s = 192. * 192.;
8470}

◆ getIntegrand_sigmaWithISR_charm196()

const double StandardModel::getIntegrand_sigmaWithISR_charm196 ( double  x) const
protected

Definition at line 8472 of file StandardModel/src/StandardModel.cpp.

8473{
8474 double s = 196. * 196.;
8476}

◆ getIntegrand_sigmaWithISR_charm200()

const double StandardModel::getIntegrand_sigmaWithISR_charm200 ( double  x) const
protected

Definition at line 8478 of file StandardModel/src/StandardModel.cpp.

8479{
8480 double s = 200. * 200.;
8482}

◆ getIntegrand_sigmaWithISR_charm202()

const double StandardModel::getIntegrand_sigmaWithISR_charm202 ( double  x) const
protected

Definition at line 8484 of file StandardModel/src/StandardModel.cpp.

8485{
8486 double s = 202. * 202.;
8488}

◆ getIntegrand_sigmaWithISR_charm205()

const double StandardModel::getIntegrand_sigmaWithISR_charm205 ( double  x) const
protected

Definition at line 8490 of file StandardModel/src/StandardModel.cpp.

8491{
8492 double s = 205. * 205.;
8494}

◆ getIntegrand_sigmaWithISR_charm207()

const double StandardModel::getIntegrand_sigmaWithISR_charm207 ( double  x) const
protected

Definition at line 8496 of file StandardModel/src/StandardModel.cpp.

8497{
8498 double s = 207. * 207.;
8500}

◆ getIntegrand_sigmaWithISR_down130()

const double StandardModel::getIntegrand_sigmaWithISR_down130 ( double  x) const
protected

Definition at line 8329 of file StandardModel/src/StandardModel.cpp.

8330{
8331 double s = 130. * 130.;
8333}

◆ getIntegrand_sigmaWithISR_down133()

const double StandardModel::getIntegrand_sigmaWithISR_down133 ( double  x) const
protected

Definition at line 8335 of file StandardModel/src/StandardModel.cpp.

8336{
8337 double s = 133. * 133.;
8339}

◆ getIntegrand_sigmaWithISR_down136()

const double StandardModel::getIntegrand_sigmaWithISR_down136 ( double  x) const
protected

Definition at line 8342 of file StandardModel/src/StandardModel.cpp.

8343{
8344 double s = 136. * 136.;
8346}

◆ getIntegrand_sigmaWithISR_down161()

const double StandardModel::getIntegrand_sigmaWithISR_down161 ( double  x) const
protected

Definition at line 8348 of file StandardModel/src/StandardModel.cpp.

8349{
8350 double s = 161. * 161.;
8352}

◆ getIntegrand_sigmaWithISR_down167()

const double StandardModel::getIntegrand_sigmaWithISR_down167 ( double  x) const
protected

Definition at line 8354 of file StandardModel/src/StandardModel.cpp.

8355{
8356 double s = 167. * 167.;
8358}

◆ getIntegrand_sigmaWithISR_down172()

const double StandardModel::getIntegrand_sigmaWithISR_down172 ( double  x) const
protected

Definition at line 8360 of file StandardModel/src/StandardModel.cpp.

8361{
8362 double s = 172. * 172.;
8364}

◆ getIntegrand_sigmaWithISR_down183()

const double StandardModel::getIntegrand_sigmaWithISR_down183 ( double  x) const
protected

Definition at line 8366 of file StandardModel/src/StandardModel.cpp.

8367{
8368 double s = 183. * 183.;
8370}

◆ getIntegrand_sigmaWithISR_down189()

const double StandardModel::getIntegrand_sigmaWithISR_down189 ( double  x) const
protected

Definition at line 8372 of file StandardModel/src/StandardModel.cpp.

8373{
8374 double s = 189. * 189.;
8376}

◆ getIntegrand_sigmaWithISR_down192()

const double StandardModel::getIntegrand_sigmaWithISR_down192 ( double  x) const
protected

Definition at line 8378 of file StandardModel/src/StandardModel.cpp.

8379{
8380 double s = 192. * 192.;
8382}

◆ getIntegrand_sigmaWithISR_down196()

const double StandardModel::getIntegrand_sigmaWithISR_down196 ( double  x) const
protected

Definition at line 8384 of file StandardModel/src/StandardModel.cpp.

8385{
8386 double s = 196. * 196.;
8388}

◆ getIntegrand_sigmaWithISR_down200()

const double StandardModel::getIntegrand_sigmaWithISR_down200 ( double  x) const
protected

Definition at line 8390 of file StandardModel/src/StandardModel.cpp.

8391{
8392 double s = 200. * 200.;
8394}

◆ getIntegrand_sigmaWithISR_down202()

const double StandardModel::getIntegrand_sigmaWithISR_down202 ( double  x) const
protected

Definition at line 8396 of file StandardModel/src/StandardModel.cpp.

8397{
8398 double s = 202. * 202.;
8400}

◆ getIntegrand_sigmaWithISR_down205()

const double StandardModel::getIntegrand_sigmaWithISR_down205 ( double  x) const
protected

Definition at line 8402 of file StandardModel/src/StandardModel.cpp.

8403{
8404 double s = 205. * 205.;
8406}

◆ getIntegrand_sigmaWithISR_down207()

const double StandardModel::getIntegrand_sigmaWithISR_down207 ( double  x) const
protected

Definition at line 8408 of file StandardModel/src/StandardModel.cpp.

8409{
8410 double s = 207. * 207.;
8412}

◆ getIntegrand_sigmaWithISR_mu130()

const double StandardModel::getIntegrand_sigmaWithISR_mu130 ( double  x) const
protected

Definition at line 8073 of file StandardModel/src/StandardModel.cpp.

8074{
8075 double s = 130. * 130.;
8077}
const double Integrand_sigmaWithISR_l(double x, const QCD::lepton l_flavor, const double s) const

◆ getIntegrand_sigmaWithISR_mu136()

const double StandardModel::getIntegrand_sigmaWithISR_mu136 ( double  x) const
protected

Definition at line 8079 of file StandardModel/src/StandardModel.cpp.

8080{
8081 double s = 136. * 136.;
8083}

◆ getIntegrand_sigmaWithISR_mu161()

const double StandardModel::getIntegrand_sigmaWithISR_mu161 ( double  x) const
protected

Definition at line 8085 of file StandardModel/src/StandardModel.cpp.

8086{
8087 double s = 161. * 161.;
8089}

◆ getIntegrand_sigmaWithISR_mu172()

const double StandardModel::getIntegrand_sigmaWithISR_mu172 ( double  x) const
protected

Definition at line 8091 of file StandardModel/src/StandardModel.cpp.

8092{
8093 double s = 172. * 172.;
8095}

◆ getIntegrand_sigmaWithISR_mu183()

const double StandardModel::getIntegrand_sigmaWithISR_mu183 ( double  x) const
protected

Definition at line 8097 of file StandardModel/src/StandardModel.cpp.

8098{
8099 double s = 183. * 183.;
8101}

◆ getIntegrand_sigmaWithISR_mu189()

const double StandardModel::getIntegrand_sigmaWithISR_mu189 ( double  x) const
protected

Definition at line 8103 of file StandardModel/src/StandardModel.cpp.

8104{
8105 double s = 189. * 189.;
8107}

◆ getIntegrand_sigmaWithISR_mu192()

const double StandardModel::getIntegrand_sigmaWithISR_mu192 ( double  x) const
protected

Definition at line 8109 of file StandardModel/src/StandardModel.cpp.

8110{
8111 double s = 192. * 192.;
8113}

◆ getIntegrand_sigmaWithISR_mu196()

const double StandardModel::getIntegrand_sigmaWithISR_mu196 ( double  x) const
protected

Definition at line 8115 of file StandardModel/src/StandardModel.cpp.

8116{
8117 double s = 196. * 196.;
8119}

◆ getIntegrand_sigmaWithISR_mu200()

const double StandardModel::getIntegrand_sigmaWithISR_mu200 ( double  x) const
protected

Definition at line 8121 of file StandardModel/src/StandardModel.cpp.

8122{
8123 double s = 200. * 200.;
8125}

◆ getIntegrand_sigmaWithISR_mu202()

const double StandardModel::getIntegrand_sigmaWithISR_mu202 ( double  x) const
protected

Definition at line 8127 of file StandardModel/src/StandardModel.cpp.

8128{
8129 double s = 202. * 202.;
8131}

◆ getIntegrand_sigmaWithISR_mu205()

const double StandardModel::getIntegrand_sigmaWithISR_mu205 ( double  x) const
protected

Definition at line 8133 of file StandardModel/src/StandardModel.cpp.

8134{
8135 double s = 205. * 205.;
8137}

◆ getIntegrand_sigmaWithISR_mu207()

const double StandardModel::getIntegrand_sigmaWithISR_mu207 ( double  x) const
protected

Definition at line 8139 of file StandardModel/src/StandardModel.cpp.

8140{
8141 double s = 207. * 207.;
8143}

◆ getIntegrand_sigmaWithISR_strange130()

const double StandardModel::getIntegrand_sigmaWithISR_strange130 ( double  x) const
protected

Definition at line 8506 of file StandardModel/src/StandardModel.cpp.

8507{
8508 double s = 130. * 130.;
8510}

◆ getIntegrand_sigmaWithISR_strange133()

const double StandardModel::getIntegrand_sigmaWithISR_strange133 ( double  x) const
protected

Definition at line 8512 of file StandardModel/src/StandardModel.cpp.

8513{
8514 double s = 133. * 133.;
8516}

◆ getIntegrand_sigmaWithISR_strange136()

const double StandardModel::getIntegrand_sigmaWithISR_strange136 ( double  x) const
protected

Definition at line 8518 of file StandardModel/src/StandardModel.cpp.

8519{
8520 double s = 136. * 136.;
8522}

◆ getIntegrand_sigmaWithISR_strange161()

const double StandardModel::getIntegrand_sigmaWithISR_strange161 ( double  x) const
protected

Definition at line 8524 of file StandardModel/src/StandardModel.cpp.

8525{
8526 double s = 161. * 161.;
8528}

◆ getIntegrand_sigmaWithISR_strange167()

const double StandardModel::getIntegrand_sigmaWithISR_strange167 ( double  x) const
protected

Definition at line 8530 of file StandardModel/src/StandardModel.cpp.

8531{
8532 double s = 167. * 167.;
8534}

◆ getIntegrand_sigmaWithISR_strange172()

const double StandardModel::getIntegrand_sigmaWithISR_strange172 ( double  x) const
protected

Definition at line 8536 of file StandardModel/src/StandardModel.cpp.

8537{
8538 double s = 172. * 172.;
8540}

◆ getIntegrand_sigmaWithISR_strange183()

const double StandardModel::getIntegrand_sigmaWithISR_strange183 ( double  x) const
protected

Definition at line 8542 of file StandardModel/src/StandardModel.cpp.

8543{
8544 double s = 183. * 183.;
8546}

◆ getIntegrand_sigmaWithISR_strange189()

const double StandardModel::getIntegrand_sigmaWithISR_strange189 ( double  x) const
protected

Definition at line 8548 of file StandardModel/src/StandardModel.cpp.

8549{
8550 double s = 189. * 189.;
8552}

◆ getIntegrand_sigmaWithISR_strange192()

const double StandardModel::getIntegrand_sigmaWithISR_strange192 ( double  x) const
protected

Definition at line 8554 of file StandardModel/src/StandardModel.cpp.

8555{
8556 double s = 192. * 192.;
8558}

◆ getIntegrand_sigmaWithISR_strange196()

const double StandardModel::getIntegrand_sigmaWithISR_strange196 ( double  x) const
protected

Definition at line 8560 of file StandardModel/src/StandardModel.cpp.

8561{
8562 double s = 196. * 196.;
8564}

◆ getIntegrand_sigmaWithISR_strange200()

const double StandardModel::getIntegrand_sigmaWithISR_strange200 ( double  x) const
protected

Definition at line 8566 of file StandardModel/src/StandardModel.cpp.

8567{
8568 double s = 200. * 200.;
8570}

◆ getIntegrand_sigmaWithISR_strange202()

const double StandardModel::getIntegrand_sigmaWithISR_strange202 ( double  x) const
protected

Definition at line 8572 of file StandardModel/src/StandardModel.cpp.

8573{
8574 double s = 202. * 202.;
8576}

◆ getIntegrand_sigmaWithISR_strange205()

const double StandardModel::getIntegrand_sigmaWithISR_strange205 ( double  x) const
protected

Definition at line 8578 of file StandardModel/src/StandardModel.cpp.

8579{
8580 double s = 205. * 205.;
8582}

◆ getIntegrand_sigmaWithISR_strange207()

const double StandardModel::getIntegrand_sigmaWithISR_strange207 ( double  x) const
protected

Definition at line 8584 of file StandardModel/src/StandardModel.cpp.

8585{
8586 double s = 207. * 207.;
8588}

◆ getIntegrand_sigmaWithISR_tau130()

const double StandardModel::getIntegrand_sigmaWithISR_tau130 ( double  x) const
protected

Definition at line 8146 of file StandardModel/src/StandardModel.cpp.

8147{
8148 double s = 130. * 130.;
8150}

◆ getIntegrand_sigmaWithISR_tau136()

const double StandardModel::getIntegrand_sigmaWithISR_tau136 ( double  x) const
protected

Definition at line 8152 of file StandardModel/src/StandardModel.cpp.

8153{
8154 double s = 136. * 136.;
8156}

◆ getIntegrand_sigmaWithISR_tau161()

const double StandardModel::getIntegrand_sigmaWithISR_tau161 ( double  x) const
protected

Definition at line 8158 of file StandardModel/src/StandardModel.cpp.

8159{
8160 double s = 161. * 161.;
8162}

◆ getIntegrand_sigmaWithISR_tau172()

const double StandardModel::getIntegrand_sigmaWithISR_tau172 ( double  x) const
protected

Definition at line 8164 of file StandardModel/src/StandardModel.cpp.

8165{
8166 double s = 172. * 172.;
8168}

◆ getIntegrand_sigmaWithISR_tau183()

const double StandardModel::getIntegrand_sigmaWithISR_tau183 ( double  x) const
protected

Definition at line 8170 of file StandardModel/src/StandardModel.cpp.

8171{
8172 double s = 183. * 183.;
8174}

◆ getIntegrand_sigmaWithISR_tau189()

const double StandardModel::getIntegrand_sigmaWithISR_tau189 ( double  x) const
protected

Definition at line 8176 of file StandardModel/src/StandardModel.cpp.

8177{
8178 double s = 189. * 189.;
8180}

◆ getIntegrand_sigmaWithISR_tau192()

const double StandardModel::getIntegrand_sigmaWithISR_tau192 ( double  x) const
protected

Definition at line 8182 of file StandardModel/src/StandardModel.cpp.

8183{
8184 double s = 192. * 192.;
8186}

◆ getIntegrand_sigmaWithISR_tau196()

const double StandardModel::getIntegrand_sigmaWithISR_tau196 ( double  x) const
protected

Definition at line 8188 of file StandardModel/src/StandardModel.cpp.

8189{
8190 double s = 196. * 196.;
8192}

◆ getIntegrand_sigmaWithISR_tau200()

const double StandardModel::getIntegrand_sigmaWithISR_tau200 ( double  x) const
protected

Definition at line 8194 of file StandardModel/src/StandardModel.cpp.

8195{
8196 double s = 200. * 200.;
8198}

◆ getIntegrand_sigmaWithISR_tau202()

const double StandardModel::getIntegrand_sigmaWithISR_tau202 ( double  x) const
protected

Definition at line 8200 of file StandardModel/src/StandardModel.cpp.

8201{
8202 double s = 202. * 202.;
8204}

◆ getIntegrand_sigmaWithISR_tau205()

const double StandardModel::getIntegrand_sigmaWithISR_tau205 ( double  x) const
protected

Definition at line 8206 of file StandardModel/src/StandardModel.cpp.

8207{
8208 double s = 205. * 205.;
8210}

◆ getIntegrand_sigmaWithISR_tau207()

const double StandardModel::getIntegrand_sigmaWithISR_tau207 ( double  x) const
protected

Definition at line 8212 of file StandardModel/src/StandardModel.cpp.

8213{
8214 double s = 207. * 207.;
8216}

◆ getIntegrand_sigmaWithISR_up130()

const double StandardModel::getIntegrand_sigmaWithISR_up130 ( double  x) const
protected

Definition at line 8242 of file StandardModel/src/StandardModel.cpp.

8243{
8244 double s = 130. * 130.;
8245 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8246}

◆ getIntegrand_sigmaWithISR_up133()

const double StandardModel::getIntegrand_sigmaWithISR_up133 ( double  x) const
protected

Definition at line 8248 of file StandardModel/src/StandardModel.cpp.

8249{
8250 double s = 133. * 133.;
8251 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8252}

◆ getIntegrand_sigmaWithISR_up136()

const double StandardModel::getIntegrand_sigmaWithISR_up136 ( double  x) const
protected

Definition at line 8254 of file StandardModel/src/StandardModel.cpp.

8255{
8256 double s = 136. * 136.;
8257 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8258}

◆ getIntegrand_sigmaWithISR_up161()

const double StandardModel::getIntegrand_sigmaWithISR_up161 ( double  x) const
protected

Definition at line 8260 of file StandardModel/src/StandardModel.cpp.

8261{
8262 double s = 161. * 161.;
8263 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8264}

◆ getIntegrand_sigmaWithISR_up167()

const double StandardModel::getIntegrand_sigmaWithISR_up167 ( double  x) const
protected

Definition at line 8266 of file StandardModel/src/StandardModel.cpp.

8267{
8268 double s = 167. * 167.;
8269 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8270}

◆ getIntegrand_sigmaWithISR_up172()

const double StandardModel::getIntegrand_sigmaWithISR_up172 ( double  x) const
protected

Definition at line 8272 of file StandardModel/src/StandardModel.cpp.

8273{
8274 double s = 172. * 172.;
8275 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8276}

◆ getIntegrand_sigmaWithISR_up183()

const double StandardModel::getIntegrand_sigmaWithISR_up183 ( double  x) const
protected

Definition at line 8278 of file StandardModel/src/StandardModel.cpp.

8279{
8280 double s = 183. * 183.;
8281 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8282}

◆ getIntegrand_sigmaWithISR_up189()

const double StandardModel::getIntegrand_sigmaWithISR_up189 ( double  x) const
protected

Definition at line 8284 of file StandardModel/src/StandardModel.cpp.

8285{
8286 double s = 189. * 189.;
8287 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8288}

◆ getIntegrand_sigmaWithISR_up192()

const double StandardModel::getIntegrand_sigmaWithISR_up192 ( double  x) const
protected

Definition at line 8290 of file StandardModel/src/StandardModel.cpp.

8291{
8292 double s = 192. * 192.;
8293 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8294}

◆ getIntegrand_sigmaWithISR_up196()

const double StandardModel::getIntegrand_sigmaWithISR_up196 ( double  x) const
protected

Definition at line 8296 of file StandardModel/src/StandardModel.cpp.

8297{
8298 double s = 196. * 196.;
8299 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8300}

◆ getIntegrand_sigmaWithISR_up200()

const double StandardModel::getIntegrand_sigmaWithISR_up200 ( double  x) const
protected

Definition at line 8302 of file StandardModel/src/StandardModel.cpp.

8303{
8304 double s = 200. * 200.;
8305 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8306}

◆ getIntegrand_sigmaWithISR_up202()

const double StandardModel::getIntegrand_sigmaWithISR_up202 ( double  x) const
protected

Definition at line 8308 of file StandardModel/src/StandardModel.cpp.

8309{
8310 double s = 202. * 202.;
8311 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8312}

◆ getIntegrand_sigmaWithISR_up205()

const double StandardModel::getIntegrand_sigmaWithISR_up205 ( double  x) const
protected

Definition at line 8314 of file StandardModel/src/StandardModel.cpp.

8315{
8316 double s = 205. * 205.;
8317 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8318}

◆ getIntegrand_sigmaWithISR_up207()

const double StandardModel::getIntegrand_sigmaWithISR_up207 ( double  x) const
protected

Definition at line 8320 of file StandardModel/src/StandardModel.cpp.

8321{
8322 double s = 207. * 207.;
8323 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8324}

◆ getIterationNo()

const int StandardModel::getIterationNo ( ) const
inline

Definition at line 629 of file StandardModel.h.

630 {
631 return iterationNo;
632 }

◆ getLeptons()

const 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 756 of file StandardModel.h.

757 {
758 return leptons[p];
759 }

◆ 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 CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTLFV, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFTd6, NPSMEFTd6General, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 997 of file StandardModel.h.

998 {
999 return SMM.getObj();
1000 }

◆ getMHl()

virtual const double StandardModel::getMHl ( ) const
inlinevirtual

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

Returns
\(m_h\) in GeV

Reimplemented in SUSY.

Definition at line 821 of file StandardModel.h.

822 {
823 return mHl;
824 }

◆ getmq()

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

The MSbar running quark mass computed at NLO.

Parameters
qthe quark flavour
muthe scale at which the running mass is returned
Returns
\( m_q^\overline{\mathrm{MS}}(\mu)\)

Definition at line 3342 of file StandardModel.h.

3343{
3344 return m_q(q, mu, FULLNLO);
3345}

◆ getMuw()

const 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 983 of file StandardModel.h.

984 {
985 return muw;
986 }

◆ getMw()

const double StandardModel::getMw ( ) const
inline

A get method to access the input value of the mass of the \(W\) boson \(M_W\).

Returns
the \(W\)-boson mass \(M_W\)

Definition at line 774 of file StandardModel.h.

775 {
776 return Mw_inp;
777 }

◆ getMyApproximateFormulae()

EWSMApproximateFormulae * StandardModel::getMyApproximateFormulae ( ) const
inline

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

Returns
the pointer myApproximateFormulae

Definition at line 1024 of file StandardModel.h.

1025 {
1026 return myApproximateFormulae;
1027 }

◆ getMyEWSMcache()

EWSMcache * StandardModel::getMyEWSMcache ( ) const
inline

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

Returns
the pointer myEWSMcache

Definition at line 1006 of file StandardModel.h.

1007 {
1008 return myEWSMcache;
1009 }

◆ getMyLeptonFlavour()

LeptonFlavour * StandardModel::getMyLeptonFlavour ( ) const
inline

Definition at line 1070 of file StandardModel.h.

1071 {
1072 return myLeptonFlavour;
1073 }

◆ getMyOneLoopEW()

EWSMOneLoopEW * StandardModel::getMyOneLoopEW ( ) const
inline

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

Returns
the pointer myOneLoopEW

Definition at line 1015 of file StandardModel.h.

1016 {
1017 return myOneLoopEW;
1018 }

◆ getMyThreeLoopEW()

EWSMThreeLoopEW * StandardModel::getMyThreeLoopEW ( ) const
inline

Definition at line 1040 of file StandardModel.h.

1041 {
1042 return myThreeLoopEW;
1043 }

◆ getMyThreeLoopEW2QCD()

EWSMThreeLoopEW2QCD * StandardModel::getMyThreeLoopEW2QCD ( ) const
inline

Definition at line 1045 of file StandardModel.h.

1046 {
1047 return myThreeLoopEW2QCD;
1048 }

◆ getMyThreeLoopQCD()

EWSMThreeLoopQCD * StandardModel::getMyThreeLoopQCD ( ) const
inline

Definition at line 1050 of file StandardModel.h.

1051 {
1052 return myThreeLoopQCD;
1053 }

◆ getMyTwoFermionsLEP2()

EWSMTwoFermionsLEP2 * StandardModel::getMyTwoFermionsLEP2 ( ) const
inline

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

Returns
the pointer myTwoFermionsLEP2

Definition at line 1034 of file StandardModel.h.

1035 {
1036 return myTwoFermionsLEP2;
1037 }

◆ getMyTwoLoopEW()

EWSMTwoLoopEW * StandardModel::getMyTwoLoopEW ( ) const
inline

Definition at line 1055 of file StandardModel.h.

1056 {
1057 return myTwoLoopEW;
1058 }

◆ getMyTwoLoopQCD()

EWSMTwoLoopQCD * StandardModel::getMyTwoLoopQCD ( ) const
inline

Definition at line 1060 of file StandardModel.h.

1061 {
1062 return myTwoLoopQCD;
1063 }

◆ getMz()

const 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 765 of file StandardModel.h.

766 {
767 return Mz;
768 }

◆ getPhiBd()

virtual const 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 3143 of file StandardModel.h.

3144 {
3145 return 0.;
3146 }

◆ getPhiBs()

virtual const 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 3134 of file StandardModel.h.

3135 {
3136 return 0.;
3137 }

◆ getTrueSM()

virtual const StandardModel & StandardModel::getTrueSM ( ) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 988 of file StandardModel.h.

989 {
990 throw std::runtime_error("StandardModel::getTrueSM() must be overridden by the NP extension.");
991 }

◆ getUPMNS()

const 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 963 of file StandardModel.h.

964 {
965 return myPMNS.getPMNS();
966 }

◆ getVCKM()

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

A get method to retrieve the CKM matrix.

Returns
the CKM matrix

Definition at line 943 of file StandardModel.h.

944 {
945 return myCKM.getCKM();
946 }

◆ getYd()

const 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 3390 of file StandardModel.h.

3391 {
3392 return Yd;
3393 }

◆ getYe()

const 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 3410 of file StandardModel.h.

3411 {
3412 return Ye;
3413 }

◆ getYn()

const 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 973 of file StandardModel.h.

974 {
975 return Yn;
976 }

◆ getYu()

const 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 3370 of file StandardModel.h.

3371 {
3372 return Yu;
3373 }

◆ gLnuN2()

const double StandardModel::gLnuN2 ( ) const
virtual

The effective neutrino nucleon LH coupling: gLnuN2.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_L^2(\nu N)\)

Definition at line 3007 of file StandardModel/src/StandardModel.cpp.

3008{
3009 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3011
3012 /* SM contribution with the approximate formula */
3014
3015 } else {
3016 throw std::runtime_error("ERROR: StandardModel::gLnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3017 }
3018}
double LEgLnuN2Approx() const
The effective neutrino nucleon LH coupling: gLnuN2.

◆ gRnuN2()

const double StandardModel::gRnuN2 ( ) const
virtual

The effective neutrino nucleon RH coupling: gRnuN2.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_R^2(\nu N)\)

Definition at line 3021 of file StandardModel/src/StandardModel.cpp.

3022{
3023 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3025
3026 /* SM contribution with the approximate formula */
3028
3029 } else {
3030 throw std::runtime_error("ERROR: StandardModel::gRnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3031 }
3032}
double LEgRnuN2Approx() const
The effective neutrino nucleon RH coupling: gRnuN2.

◆ gV_f()

const 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 NPbase, and NPEpsilons.

Definition at line 1583 of file StandardModel/src/StandardModel.cpp.

1584{
1585 return ( gA_f(f)
1586 *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1587}

◆ gVnue()

const double StandardModel::gVnue ( ) const
virtual

The effective (muon) neutrino-electron vector coupling: gVnue.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(g_V^{\nu_\mu e}\)

Definition at line 3061 of file StandardModel/src/StandardModel.cpp.

3062{
3063 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3065
3066 /* SM contribution with the approximate formula */
3068
3069 } else {
3070 throw std::runtime_error("ERROR: StandardModel::gVnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3071 }
3072}
double LEgVnueApprox() const
The effective (muon) neutrino-electron vector coupling: gVnue.

◆ I_triangle_1()

gslpp::complex StandardModel::I_triangle_1 ( const double  tau,
const double  lambda 
) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4756, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the particle in the loop.

Returns
\(I_1(\tau,\lambda)\)

Definition at line 3284 of file StandardModel/src/StandardModel.cpp.

3284 {
3285 gslpp::complex tmp;
3286
3287 tmp = (tau * lambda * (f_triangle(tau) - f_triangle(lambda)) + 2.0 * tau * (g_triangle(tau) - g_triangle(lambda))) / (tau - lambda);
3288
3289 tmp = tau * lambda * (1.0 + tmp) / (2.0 * (tau - lambda));
3290
3291 return tmp;
3292}
gslpp::complex g_triangle(const double tau) const
Loop function entering in the calculation of the effective coupling.

◆ I_triangle_2()

gslpp::complex StandardModel::I_triangle_2 ( const double  tau,
const double  lambda 
) const

Loop function entering in the calculation of the effective \(HZ\gamma\) coupling.

Parameters
[in]

_form#4756, \(\lambda=4 M^2/m_Z^2\), with \(M\) the mass of the particle in the loop.

Returns
\(I_2(\tau,\lambda)\)

Definition at line 3294 of file StandardModel/src/StandardModel.cpp.

3294 {
3295 gslpp::complex tmp;
3296
3297 tmp = -0.5 * tau * lambda * (f_triangle(tau) - f_triangle(lambda)) / (tau - lambda);
3298
3299 return tmp;
3300}

◆ 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 FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 198 of file StandardModel/src/StandardModel.cpp.

199{
200 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
201 if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
202 throw std::runtime_error("ERROR: inappropriate parameter " + it->first
203 + " in model initialization");
204 else if (FlagFixMuwMut && it->first.compare("mut") == 0)
205 throw std::runtime_error("ERROR: cannot use " + it->first
206 + " when FlagFixMuwMut is true: use only muw");
207
208 std::map<std::string, double> myDPars(DPars);
209 myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
210 myDPars["MAls"] = myDPars.at("Mz");
211 if (FlagFixMuwMut)
212 myDPars["mut"] = myDPars.at("muw") * 163. / 80.4 ;
213 return (QCD::Init(myDPars));
214}
virtual bool Init(const std::map< std::string, double > &DPars)
Initializes the QCD parameters found in the argument.
Definition: QCD.cpp:120

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

< A pointer to an object of type EWSMTwoFermionsLEP2.

Reimplemented in FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 176 of file StandardModel/src/StandardModel.cpp.

177{
178 myEWSMcache = new EWSMcache(*this);
186 myLeptonFlavour = new LeptonFlavour(*this);
187 /* BEGIN: REMOVE FROM THE PACKAGE */
189 /* END: REMOVE FROM THE PACKAGE */
191 return (true);
192}
A class for approximate formulae of the EW precision observables.
A class for one-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for three-loop corrections to the EW precision observables.
A class for the form factors , and in the processes at LEP-II.
A class for two-loop corrections to the EW precision observables.
Definition: EWSMTwoLoopEW.h:57
A class for two-loop corrections to the EW precision observables.
A class for cache variables used in computing radiative corrections to the EW precision observables.
Definition: EWSMcache.h:40
The parent class in LeptonFlavour for calculating all the Wilson coefficients for various Lepton Flav...
Definition: LeptonFlavour.h:26
void setModelInitialized(bool ModelInitialized)
A set method to fix the failure or success of the initialization of the model.
Definition: Model.h:145

◆ Integrand_AFBnumeratorWithISR_l()

const double StandardModel::Integrand_AFBnumeratorWithISR_l ( double  x,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 9302 of file StandardModel/src/StandardModel.cpp.

9303{
9304 double sprime = (1.0 - x)*s;
9305 double Ncf = 1.0;
9306 double ml = getLeptons(l_flavor).getMass();
9307 double G3prime = myTwoFermionsLEP2->G_3prime_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9308 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9309
9310 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9311}
double G_3prime_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double H_ISR_FB(const double x, const double s) const

◆ Integrand_AFBnumeratorWithISR_q()

const double StandardModel::Integrand_AFBnumeratorWithISR_q ( double  x,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 9461 of file StandardModel/src/StandardModel.cpp.

9462{
9463 double sprime = (1.0 - x)*s;
9464 double Ncf = 3.0;
9465 double mq = m_q(q_flavor, sqrt(s));
9466 double G3prime = myTwoFermionsLEP2->G_3prime_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9467 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9468
9469 if (flagLEP2[QCDFSR])
9470 G3prime *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, sprime);
9471
9472 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9473}
double G_3prime_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const

◆ Integrand_dsigmaBox_l()

const double StandardModel::Integrand_dsigmaBox_l ( double  cosTheta,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8682 of file StandardModel/src/StandardModel.cpp.

8683{
8684 double ml = getLeptons(l_flavor).getMass();
8685 return ( myTwoFermionsLEP2->dsigma_l_box(l_flavor, ml, s, cosTheta, Mw(), Gamma_Z()) );
8686}
double dsigma_l_box(const QCD::lepton l, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const
An observable class for the -boson mass.
Definition: Mw.h:22

◆ Integrand_dsigmaBox_q()

const double StandardModel::Integrand_dsigmaBox_q ( double  cosTheta,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8841 of file StandardModel/src/StandardModel.cpp.

8842{
8843 double mq = m_q(q_flavor, sqrt(s));
8844 return ( myTwoFermionsLEP2->dsigma_q_box(q_flavor, mq, s, cosTheta, Mw(), Gamma_Z()) );
8845}
double dsigma_q_box(const QCD::quark q, const double mf, const double s, const double cosTheta, const double Mw, const double GammaZ) const

◆ Integrand_sigmaWithISR_l()

const double StandardModel::Integrand_sigmaWithISR_l ( double  x,
const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8058 of file StandardModel/src/StandardModel.cpp.

8059{
8060 double sprime = (1.0 - x)*s;
8061 double ml = getLeptons(l_flavor).getMass();
8062 double l_charge = getLeptons(l_flavor).getCharge();
8063 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),
8064 flagLEP2[Weak]);
8065 double H = myTwoFermionsLEP2->H_ISR(x, s);
8066
8067 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8068 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, l_charge);
8069
8070 return ( H*sigma );
8071}
double QED_FSR_forSigma(const double s, const double Qf) const
double sigma_l(const QCD::lepton l, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double H_ISR(const double x, const double s) const

◆ Integrand_sigmaWithISR_q()

const double StandardModel::Integrand_sigmaWithISR_q ( double  x,
const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8218 of file StandardModel/src/StandardModel.cpp.

8219{
8220 double sprime = (1.0 - x)*s;
8221 double mq = m_q(q_flavor, sqrt(s));
8222 double q_charge = getQuarks(q_flavor).getCharge();
8223 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),
8224 flagLEP2[Weak]);
8225 double H = myTwoFermionsLEP2->H_ISR(x, s);
8226
8227 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8228 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, q_charge);
8229
8230 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8231 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(sprime);
8232
8233 return ( H*sigma );
8234}
double sigma_q(const QCD::quark q, const double mf, const double s, const double Mw, const double GammaZ, const bool bWeak) const
double QCD_FSR_forSigma(const double s) const
const Particle & getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:536

◆ intMLL2eeeeus2()

const double StandardModel::intMLL2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3973 of file StandardModel/src/StandardModel.cpp.

3973 {
3974
3975 double intM2;
3976 double sw2cw2;
3977 double gLeSM;
3978 double GammaZSM;
3979 double Mz2, Mz4, s2;
3980
3981 sw2cw2 = s02() * c02();
3982 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3983 GammaZSM = Gamma_Z();
3984 Mz2 = Mz * Mz;
3985 Mz4 = Mz2 * Mz2;
3986 s2 = s * s;
3987
3988 intM2 = (gLeSM*gLeSM*gLeSM*gLeSM*s2 + 2.0*gLeSM*gLeSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
3989 ((2.0*(1.0 + (gLeSM*gLeSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
3990 (2.0*gLeSM*gLeSM* (-sw2cw2 + (gLeSM*gLeSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
3991 (2.0*(gLeSM*gLeSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
3992 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
3993 (gLeSM*gLeSM*gLeSM*gLeSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
3994
3995 return intM2;
3996}

◆ intMLR2eeeets2()

const double StandardModel::intMLR2eeeets2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3929 of file StandardModel/src/StandardModel.cpp.

3929 {
3930
3931 double intM2;
3932 double sw2cw2;
3933 double gLeSM,gReSM;
3934 double GammaZSM;
3935 double Mz2, s2;
3936 double propZSM2,propZSMRe,MeeLR2SM;
3937
3938 sw2cw2 = s02() * c02();
3939 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3940 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3941 GammaZSM = Gamma_Z();
3942 Mz2 = Mz * Mz;
3943 s2 = s * s;
3944
3945 propZSM2 = s2/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3946 propZSMRe = (s*(s - Mz2))/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3947
3948 MeeLR2SM = 1.0 + (gLeSM*gLeSM*gReSM*gReSM/(sw2cw2*sw2cw2))*propZSM2 + 2.0*(gLeSM*gReSM/sw2cw2)*propZSMRe;
3949
3950 intM2 = MeeLR2SM*(t1*t1*t1 - t0*t0*t0)/(3.0*s*s);
3951
3952 return intM2;
3953}

◆ intMLRtilde2eeeest2()

const double StandardModel::intMLRtilde2eeeest2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3955 of file StandardModel/src/StandardModel.cpp.

3955 {
3956
3957 double intM2;
3958 double sw2cw2;
3959 double gLeSM,gReSM;
3960 double Mz2;
3961
3962 sw2cw2 = s02() * c02();
3963 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3964 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3965 Mz2 = Mz * Mz;
3966
3967 intM2 = s*s*(((gLeSM*gLeSM*gReSM*gReSM)/sw2cw2/sw2cw2)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) - 1.0/t1 + 1.0/t0 +
3968 (2.0*gLeSM*gReSM*(-log(t1/t0) + log((-Mz2 + t1)/(-Mz2 + t0))))/(Mz2*sw2cw2));
3969
3970 return intM2;
3971}

◆ intMRR2eeeeus2()

const double StandardModel::intMRR2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

Definition at line 3998 of file StandardModel/src/StandardModel.cpp.

3998 {
3999
4000 double intM2;
4001 double sw2cw2;
4002 double gReSM;
4003 double GammaZSM;
4004 double Mz2, Mz4, s2;
4005
4006 sw2cw2 = s02() * c02();
4007 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
4008 GammaZSM = Gamma_Z();
4009 Mz2 = Mz * Mz;
4010 Mz4 = Mz2 * Mz2;
4011 s2 = s * s;
4012
4013 intM2 = (gReSM*gReSM*gReSM*gReSM*s2 + 2.0*gReSM*gReSM*s*(-Mz2 + s)*sw2cw2 + sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))/(3.0*s2*sw2cw2*sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))*(pow(s + t1,3.0) - pow(s + t0,3.0)) +
4014 ((2.0*(1.0 + (gReSM*gReSM*s*(-Mz2 + s))/(sw2cw2*(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM)))) )/s)*(2.0*s *(t1 - t0) + (t1*t1 - t0*t0)/2.0 + s2*log(t1/t0)) +
4015 (2.0*gReSM*gReSM* (-sw2cw2 + (gReSM*gReSM*(Mz2 - s)*s)/(Mz4 + s2 + Mz2*(-2.0*s + GammaZSM*GammaZSM))))/(s*sw2cw2*sw2cw2)* (-(1.0/2.0)*t1*(2.0*Mz2 + 4.0*s + t1) + (1.0/2.0)*t0*(2.0*Mz2 + 4.0*s + t0) - (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)) ) +
4016 (2.0*(gReSM*gReSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
4017 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
4018 (gReSM*gReSM*gReSM*gReSM /sw2cw2/sw2cw2)*((Mz2 + s)*(Mz2 + s)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) + t1 - t0 + 2.0*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0)));
4019
4020 return intM2;
4021}

◆ IsFlagNoApproximateGammaZ()

const 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 691 of file StandardModel.h.

692 {
694 }

◆ IsFlagWithoutNonUniversalVC()

const 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 678 of file StandardModel.h.

679 {
681 }

◆ isSMSuccess()

const bool StandardModel::isSMSuccess ( ) const
inline

A get method to retrieve the success status of the Standard Model update and matching.

Returns
a boolean that is true if the Standard Model update and matching were successful

Definition at line 3429 of file StandardModel.h.

3430 {
3431 return SMSuccess;
3432 }
bool SMSuccess
A boolean for the success of the Standard Model update and matching.

◆ kappaZ_f()

const 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 [Bardin:1999ak], [Bardin:1999yd] :

\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 NPbase, and NPEpsilons.

Definition at line 1659 of file StandardModel/src/StandardModel.cpp.

1660{
1661 if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1662
1664 if (useKappaZ_f_cache[f.getIndex()])
1665 return kappaZ_f_cache[f.getIndex()];
1666
1667 double myMw = Mw();
1668
1669 double ReKappaZf = 0.0, ImKappaZf = 0.0;
1670 if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1671
1672// Choose the correct formulae for the effective angle
1673 if ( f.is("BOTTOM") ){
1674 ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1675 } else if ( f.is("ELECTRON") || f.is("MU") || f.is("TAU") ) {
1676 ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1677 } else {
1678 ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1679 }
1680
1681 ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1682#ifdef WITHIMTWOLOOPQCD
1683 ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1684
1685 /* TEST */
1686 //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1687#endif
1688 } else {
1689 /* compute Delta rho */
1690 double DeltaRho[orders_EW_size];
1691 ComputeDeltaRho(myMw, DeltaRho);
1692
1693 /* compute delta kappa_rem^f */
1694 gslpp::complex deltaKappa_remf[orders_EW_size];
1695 deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1696 deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1697 deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1698 deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1699 deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1700 deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1701 if (flag_order[EW1])
1702 deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1703 if (flag_order[EW1QCD1])
1704#ifdef WITHIMTWOLOOPQCD
1705 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1706 myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1707#else
1708 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1709#endif
1710 if (flag_order[EW1QCD2])
1711 deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1712 if (flag_order[EW2])
1713 deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1714 if (flag_order[EW2QCD1])
1715 deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1716 if (flag_order[EW3])
1717 deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1718
1719 /* compute Delta rbar_rem */
1720 double DeltaRbar_rem = 0.0;
1721 if (flag_order[EW1])
1722 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1723
1724 /* Re[kappa_Z^f] with or without resummation */
1725 double deltaKappa_rem_f_real[orders_EW_size];
1726 for (int j = 0; j < orders_EW_size; ++j)
1727 deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1728
1729 ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1730
1731 /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1732 ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1733 *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1734
1735 /* Im[kappa_Z^f] without resummation */
1736 for (int j = 0; j < orders_EW_size; ++j)
1737 ImKappaZf += deltaKappa_remf[j].imag();
1738 }
1739
1740 kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1741 useKappaZ_f_cache[f.getIndex()] = true;
1742 return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1743}
double sin2thetaEff(const Particle p) const
The value of the effective weak mixing anlge for a given fermion.
double sin2thetaEff_b_full() const
with the full two-loop EW corrections.
double sin2thetaEff_l_full() const
with the full two-loop EW corrections.
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
double DeltaRbar_rem(const double Mw_i) const
.
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaKappa_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
void ComputeDeltaRho(const double Mw_i, double DeltaRho[orders_EW_size]) const
A method to collect computed via subclasses.
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 .

◆ LEP2AFBbottom()

const double StandardModel::LEP2AFBbottom ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 6168 of file StandardModel/src/StandardModel.cpp.

6169{
6170
6171 bSigmaForAFB = true;
6172 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6173 double relerr = 1.e-7;
6174 double abserr = 1.e-17;
6175
6176 if(s == 133.*133.){
6177 double AFB_noBox, sigma = 0.0;
6178 if (!flagLEP2[ISR])
6179 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6180 else {
6181 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133, &(*this), _1));
6182 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6183 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6184 }
6185 double numerator = average; // interval
6186
6187
6188 sigma = LEP2sigmaBottom(s);
6189
6190 AFB_noBox = numerator/sigma;
6191 }
6192 SMresult_cache = AFB_noBox;
6193
6194 if (flagLEP2[WeakBox]) {
6195 // numerator
6196 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6197 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6198 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6199 }
6200 double sigma_box_F = average; // interval
6201 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6202 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6203 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6204 }
6205 double sigma_box_B = average; // interval
6206
6207 // denominator
6208 if (!flagLEP2[ISR]) {
6209
6210 sigma = LEP2sigmaBottom(s);
6211 }
6212
6213 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6214 }
6215 } else if (s == 167.*167.){
6216 double AFB_noBox, sigma = 0.0;
6217 if (!flagLEP2[ISR])
6218 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6219 else {
6220 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167, &(*this), _1));
6221 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6222 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6223 }
6224 double numerator = average; // interval
6225
6226
6227 sigma = LEP2sigmaBottom(s);
6228
6229 AFB_noBox = numerator/sigma;
6230 }
6231 SMresult_cache = AFB_noBox;
6232
6233 if (flagLEP2[WeakBox]) {
6234 // numerator
6235 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6236 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6237 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6238 }
6239 double sigma_box_F = average; // interval
6240 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6241 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6242 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6243 }
6244 double sigma_box_B = average; // interval
6245
6246 // denominator
6247 if (!flagLEP2[ISR]) {
6248
6249 sigma = LEP2sigmaBottom(s);
6250 }
6251
6252 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6253 }
6254 } else if (s == 183.*183.) {
6255 double AFB_noBox, sigma = 0.0;
6256 if (!flagLEP2[ISR])
6257 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6258 else {
6259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183, &(*this), _1));
6260 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6262 }
6263 double numerator = average; // interval
6264
6265
6266 sigma = LEP2sigmaBottom(s);
6267
6268 AFB_noBox = numerator/sigma;
6269 }
6270 SMresult_cache = AFB_noBox;
6271
6272 if (flagLEP2[WeakBox]) {
6273 // numerator
6274 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6275 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6276 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6277 }
6278 double sigma_box_F = average; // interval
6279 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6280 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6281 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6282 }
6283 double sigma_box_B = average; // interval
6284
6285 // denominator
6286 if (!flagLEP2[ISR]) {
6287
6288 sigma = LEP2sigmaBottom(s);
6289 }
6290
6291 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6292 }
6293 } else if (s == 189.*189.) {
6294 double AFB_noBox, sigma = 0.0;
6295 if (!flagLEP2[ISR])
6296 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6297 else {
6298 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189, &(*this), _1));
6299 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6300 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6301 }
6302 double numerator = average; // interval
6303
6304
6305 sigma = LEP2sigmaBottom(s);
6306
6307 AFB_noBox = numerator/sigma;
6308 }
6309 SMresult_cache = AFB_noBox;
6310
6311 if (flagLEP2[WeakBox]) {
6312 // numerator
6313 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6314 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6315 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6316 }
6317 double sigma_box_F = average; // interval
6318 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6319 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6320 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6321 }
6322 double sigma_box_B = average; // interval
6323
6324 // denominator
6325 if (!flagLEP2[ISR]) {
6326
6327 sigma = LEP2sigmaBottom(s);
6328 }
6329
6330 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6331 }
6332 } else if (s == 192.*192.) {
6333 double AFB_noBox, sigma = 0.0;
6334 if (!flagLEP2[ISR])
6335 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6336 else {
6337 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192, &(*this), _1));
6338 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6339 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6340 }
6341 double numerator = average; // interval
6342
6343
6344 sigma = LEP2sigmaBottom(s);
6345
6346 AFB_noBox = numerator/sigma;
6347 }
6348 SMresult_cache = AFB_noBox;
6349
6350 if (flagLEP2[WeakBox]) {
6351 // numerator
6352 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6353 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6354 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6355 }
6356 double sigma_box_F = average; // interval
6357 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6358 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6359 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6360 }
6361 double sigma_box_B = average; // interval
6362
6363 // denominator
6364 if (!flagLEP2[ISR]) {
6365
6366 sigma = LEP2sigmaBottom(s);
6367 }
6368
6369 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6370 }
6371 } else if (s == 196.*196.) {
6372 double AFB_noBox, sigma = 0.0;
6373 if (!flagLEP2[ISR])
6374 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6375 else {
6376 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196, &(*this), _1));
6377 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6378 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6379 }
6380 double numerator = average; // interval
6381
6382
6383 sigma = LEP2sigmaBottom(s);
6384
6385 AFB_noBox = numerator/sigma;
6386 }
6387 SMresult_cache = AFB_noBox;
6388
6389 if (flagLEP2[WeakBox]) {
6390 // numerator
6391 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6392 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6393 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6394 }
6395 double sigma_box_F = average; // interval
6396 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6397 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6398 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6399 }
6400 double sigma_box_B = average; // interval
6401
6402 // denominator
6403 if (!flagLEP2[ISR]) {
6404
6405 sigma = LEP2sigmaBottom(s);
6406 }
6407
6408 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6409 }
6410 } else if (s == 200.*200.) {
6411 double AFB_noBox, sigma = 0.0;
6412 if (!flagLEP2[ISR])
6413 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6414 else {
6415 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200, &(*this), _1));
6416 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6417 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6418 }
6419 double numerator = average; // interval
6420
6421
6422 sigma = LEP2sigmaBottom(s);
6423
6424 AFB_noBox = numerator/sigma;
6425 }
6426 SMresult_cache = AFB_noBox;
6427
6428 if (flagLEP2[WeakBox]) {
6429 // numerator
6430 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6431 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6432 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6433 }
6434 double sigma_box_F = average; // interval
6435 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6436 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6437 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6438 }
6439 double sigma_box_B = average; // interval
6440
6441 // denominator
6442 if (!flagLEP2[ISR]) {
6443
6444 sigma = LEP2sigmaBottom(s);
6445 }
6446
6447 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6448 }
6449 } else if (s == 202.*202.) {
6450 double AFB_noBox, sigma = 0.0;
6451 if (!flagLEP2[ISR])
6452 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6453 else {
6454 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202, &(*this), _1));
6455 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6456 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6457 }
6458 double numerator = average; // interval
6459
6460
6461 sigma = LEP2sigmaBottom(s);
6462
6463 AFB_noBox = numerator/sigma;
6464 }
6465 SMresult_cache = AFB_noBox;
6466
6467 if (flagLEP2[WeakBox]) {
6468 // numerator
6469 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6470 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6471 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6472 }
6473 double sigma_box_F = average; // interval
6474 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6475 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6476 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6477 }
6478 double sigma_box_B = average; // interval
6479
6480 // denominator
6481 if (!flagLEP2[ISR]) {
6482
6483 sigma = LEP2sigmaBottom(s);
6484 }
6485
6486 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6487 }
6488 } else if (s == 205.*205.) {
6489 double AFB_noBox, sigma = 0.0;
6490 if (!flagLEP2[ISR])
6491 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6492 else {
6493 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205, &(*this), _1));
6494 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6495 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6496 }
6497 double numerator = average; // interval
6498
6499
6500 sigma = LEP2sigmaBottom(s);
6501
6502 AFB_noBox = numerator/sigma;
6503 }
6504 SMresult_cache = AFB_noBox;
6505
6506 if (flagLEP2[WeakBox]) {
6507 // numerator
6508 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6509 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6510 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6511 }
6512 double sigma_box_F = average; // interval
6513 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6514 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6515 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6516 }
6517 double sigma_box_B = average; // interval
6518
6519 // denominator
6520 if (!flagLEP2[ISR]) {
6521
6522 sigma = LEP2sigmaBottom(s);
6523 }
6524
6525 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6526 }
6527 } else if (s == 207.*207.) {
6528 double AFB_noBox, sigma = 0.0;
6529 if (!flagLEP2[ISR])
6530 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6531 else {
6532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207, &(*this), _1));
6533 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6535 }
6536 double numerator = average; // interval
6537
6538
6539 sigma = LEP2sigmaBottom(s);
6540
6541 AFB_noBox = numerator/sigma;
6542 }
6543 SMresult_cache = AFB_noBox;
6544
6545 if (flagLEP2[WeakBox]) {
6546 // numerator
6547 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6548 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6549 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6550 }
6551 double sigma_box_F = average; // interval
6552 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6553 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6554 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6555 }
6556 double sigma_box_B = average; // interval
6557
6558 // denominator
6559 if (!flagLEP2[ISR]) {
6560
6561 sigma = LEP2sigmaBottom(s);
6562 }
6563
6564 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6565 }
6566 } else {
6567 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBbottom!");
6568 }
6569
6570 double AFBbottom = SMresult_cache;
6571
6572 gsl_set_error_handler(old_handler);
6573 bSigmaForAFB = false;
6574 return AFBbottom;
6575
6576}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBbottom.h:39
const double getIntegrand_AFBnumeratorWithISR_bottom192(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom196(double x) const
gsl_function f_GSL
const double getIntegrand_dsigmaBox_bottom189(double x) const
const double getIntegrand_dsigmaBox_bottom207(double x) const
double SMresult_cache
const double getIntegrand_dsigmaBox_bottom202(double x) const
const double getIntegrand_dsigmaBox_bottom200(double x) const
const double getIntegrand_dsigmaBox_bottom205(double x) const
const double getIntegrand_dsigmaBox_bottom183(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom207(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom200(double x) const
const double getIntegrand_dsigmaBox_bottom196(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom205(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom189(double x) const
const double AFB_NoISR_q(const QCD::quark q_flavor, const double s) const
const double getIntegrand_dsigmaBox_bottom133(double x) const
const double getIntegrand_dsigmaBox_bottom167(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom202(double x) const
const double getIntegrand_dsigmaBox_bottom192(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom167(double x) const
const double getIntegrand_AFBnumeratorWithISR_bottom133(double x) const
virtual const double LEP2sigmaBottom(const double s) const
const double getIntegrand_AFBnumeratorWithISR_bottom183(double x) const

◆ LEP2AFBcharm()

const double StandardModel::LEP2AFBcharm ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 6579 of file StandardModel/src/StandardModel.cpp.

6580{
6581
6582 bSigmaForAFB = true;
6583 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6584 double relerr = 1.e-7;
6585 double abserr = 1.e-17;
6586
6587 if(s == 133.*133.){
6588 double AFB_noBox, sigma = 0.0;
6589 if (!flagLEP2[ISR])
6590 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6591 else {
6592 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm133, &(*this), _1));
6593 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6594 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6595 }
6596 double numerator = average; // interval
6597
6598
6599 sigma = LEP2sigmaCharm(s);
6600
6601 AFB_noBox = numerator/sigma;
6602 }
6603 SMresult_cache = AFB_noBox;
6604
6605 if (flagLEP2[WeakBox]) {
6606 // numerator
6607 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6608 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6609 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6610 }
6611 double sigma_box_F = average; // interval
6612 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6613 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6614 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6615 }
6616 double sigma_box_B = average; // interval
6617
6618 // denominator
6619 if (!flagLEP2[ISR]) {
6620
6621 sigma = LEP2sigmaCharm(s);
6622 }
6623
6624 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6625 }
6626 } else if (s == 167.*167.){
6627 double AFB_noBox, sigma = 0.0;
6628 if (!flagLEP2[ISR])
6629 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6630 else {
6631 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm167, &(*this), _1));
6632 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6633 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6634 }
6635 double numerator = average; // interval
6636
6637
6638 sigma = LEP2sigmaCharm(s);
6639
6640 AFB_noBox = numerator/sigma;
6641 }
6642 SMresult_cache = AFB_noBox;
6643
6644 if (flagLEP2[WeakBox]) {
6645 // numerator
6646 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6647 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6648 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6649 }
6650 double sigma_box_F = average; // interval
6651 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6652 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6653 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6654 }
6655 double sigma_box_B = average; // interval
6656
6657 // denominator
6658 if (!flagLEP2[ISR]) {
6659
6660 sigma = LEP2sigmaCharm(s);
6661 }
6662
6663 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6664 }
6665 } else if (s == 183.*183.) {
6666 double AFB_noBox, sigma = 0.0;
6667 if (!flagLEP2[ISR])
6668 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6669 else {
6670 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm183, &(*this), _1));
6671 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6672 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6673 }
6674 double numerator = average; // interval
6675
6676
6677 sigma = LEP2sigmaCharm(s);
6678
6679 AFB_noBox = numerator/sigma;
6680 }
6681 SMresult_cache = AFB_noBox;
6682
6683 if (flagLEP2[WeakBox]) {
6684 // numerator
6685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6686 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6688 }
6689 double sigma_box_F = average; // interval
6690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6691 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6693 }
6694 double sigma_box_B = average; // interval
6695
6696 // denominator
6697 if (!flagLEP2[ISR]) {
6698
6699 sigma = LEP2sigmaCharm(s);
6700 }
6701
6702 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6703 }
6704 } else if (s == 189.*189.) {
6705 double AFB_noBox, sigma = 0.0;
6706 if (!flagLEP2[ISR])
6707 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6708 else {
6709 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm189, &(*this), _1));
6710 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6711 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6712 }
6713 double numerator = average; // interval
6714
6715
6716 sigma = LEP2sigmaCharm(s);
6717
6718 AFB_noBox = numerator/sigma;
6719 }
6720 SMresult_cache = AFB_noBox;
6721
6722 if (flagLEP2[WeakBox]) {
6723 // numerator
6724 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6725 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6726 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6727 }
6728 double sigma_box_F = average; // interval
6729 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6730 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6731 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6732 }
6733 double sigma_box_B = average; // interval
6734
6735 // denominator
6736 if (!flagLEP2[ISR]) {
6737
6738 sigma = LEP2sigmaCharm(s);
6739 }
6740
6741 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6742 }
6743 } else if (s == 192.*192.) {
6744 double AFB_noBox, sigma = 0.0;
6745 if (!flagLEP2[ISR])
6746 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6747 else {
6748 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm192, &(*this), _1));
6749 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6750 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6751 }
6752 double numerator = average; // interval
6753
6754
6755 sigma = LEP2sigmaCharm(s);
6756
6757 AFB_noBox = numerator/sigma;
6758 }
6759 SMresult_cache = AFB_noBox;
6760
6761 if (flagLEP2[WeakBox]) {
6762 // numerator
6763 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6764 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6765 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6766 }
6767 double sigma_box_F = average; // interval
6768 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6769 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6770 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6771 }
6772 double sigma_box_B = average; // interval
6773
6774 // denominator
6775 if (!flagLEP2[ISR]) {
6776
6777 sigma = LEP2sigmaCharm(s);
6778 }
6779
6780 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6781 }
6782 } else if (s == 196.*196.) {
6783 double AFB_noBox, sigma = 0.0;
6784 if (!flagLEP2[ISR])
6785 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6786 else {
6787 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm196, &(*this), _1));
6788 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6789 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6790 }
6791 double numerator = average; // interval
6792
6793
6794 sigma = LEP2sigmaCharm(s);
6795
6796 AFB_noBox = numerator/sigma;
6797 }
6798 SMresult_cache = AFB_noBox;
6799
6800 if (flagLEP2[WeakBox]) {
6801 // numerator
6802 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6803 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6804 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6805 }
6806 double sigma_box_F = average; // interval
6807 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6808 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6809 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6810 }
6811 double sigma_box_B = average; // interval
6812
6813 // denominator
6814 if (!flagLEP2[ISR]) {
6815
6816 sigma = LEP2sigmaCharm(s);
6817 }
6818
6819 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6820 }
6821 } else if (s == 200.*200.) {
6822 double AFB_noBox, sigma = 0.0;
6823 if (!flagLEP2[ISR])
6824 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6825 else {
6826 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm200, &(*this), _1));
6827 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6828 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6829 }
6830 double numerator = average; // interval
6831
6832
6833 sigma = LEP2sigmaCharm(s);
6834
6835 AFB_noBox = numerator/sigma;
6836 }
6837 SMresult_cache = AFB_noBox;
6838
6839 if (flagLEP2[WeakBox]) {
6840 // numerator
6841 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6842 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6843 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6844 }
6845 double sigma_box_F = average; // interval
6846 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6847 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6848 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6849 }
6850 double sigma_box_B = average; // interval
6851
6852 // denominator
6853 if (!flagLEP2[ISR]) {
6854
6855 sigma = LEP2sigmaCharm(s);
6856 }
6857
6858 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6859 }
6860 } else if (s == 202.*202.) {
6861 double AFB_noBox, sigma = 0.0;
6862 if (!flagLEP2[ISR])
6863 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6864 else {
6865 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm202, &(*this), _1));
6866 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6867 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6868 }
6869 double numerator = average; // interval
6870
6871
6872 sigma = LEP2sigmaCharm(s);
6873
6874 AFB_noBox = numerator/sigma;
6875 }
6876 SMresult_cache = AFB_noBox;
6877
6878 if (flagLEP2[WeakBox]) {
6879 // numerator
6880 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6881 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6882 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6883 }
6884 double sigma_box_F = average; // interval
6885 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6886 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6887 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6888 }
6889 double sigma_box_B = average; // interval
6890
6891 // denominator
6892 if (!flagLEP2[ISR]) {
6893
6894 sigma = LEP2sigmaCharm(s);
6895 }
6896
6897 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6898 }
6899 } else if (s == 205.*205.) {
6900 double AFB_noBox, sigma = 0.0;
6901 if (!flagLEP2[ISR])
6902 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6903 else {
6904 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6905 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6906 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6907 }
6908 double numerator = average; // interval
6909
6910
6911 sigma = LEP2sigmaCharm(s);
6912
6913 AFB_noBox = numerator/sigma;
6914 }
6915 SMresult_cache = AFB_noBox;
6916
6917 if (flagLEP2[WeakBox]) {
6918 // numerator
6919 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6920 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6921 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6922 }
6923 double sigma_box_F = average; // interval
6924 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6925 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6926 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6927 }
6928 double sigma_box_B = average; // interval
6929
6930 // denominator
6931 if (!flagLEP2[ISR]) {
6932
6933 sigma = LEP2sigmaCharm(s);
6934 }
6935
6936 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6937 }
6938 } else if (s == 207.*207.) {
6939 double AFB_noBox, sigma = 0.0;
6940 if (!flagLEP2[ISR])
6941 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6942 else {
6943 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6944 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6945 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6946 }
6947 double numerator = average; // interval
6948
6949
6950 sigma = LEP2sigmaCharm(s);
6951
6952 AFB_noBox = numerator/sigma;
6953 }
6954 SMresult_cache = AFB_noBox;
6955
6956 if (flagLEP2[WeakBox]) {
6957 // numerator
6958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6959 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6961 }
6962 double sigma_box_F = average; // interval
6963 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6964 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6965 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6966 }
6967 double sigma_box_B = average; // interval
6968
6969 // denominator
6970 if (!flagLEP2[ISR]) {
6971
6972 sigma = LEP2sigmaCharm(s);
6973 }
6974
6975 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6976 }
6977 } else {
6978 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBcharm!");
6979 }
6980
6981 double AFBcharm = SMresult_cache;
6982
6983 gsl_set_error_handler(old_handler);
6984 bSigmaForAFB = false;
6985 return AFBcharm;
6986
6987}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBcharm.h:32
virtual const double LEP2sigmaCharm(const double s) const
const double getIntegrand_AFBnumeratorWithISR_charm133(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm183(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm205(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm200(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm202(double x) const
const double getIntegrand_dsigmaBox_charm167(double x) const
const double getIntegrand_dsigmaBox_charm205(double x) const
const double getIntegrand_dsigmaBox_charm183(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm189(double x) const
const double getIntegrand_dsigmaBox_charm196(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm196(double x) const
const double getIntegrand_dsigmaBox_charm133(double x) const
const double getIntegrand_dsigmaBox_charm192(double x) const
const double getIntegrand_dsigmaBox_charm189(double x) const
const double getIntegrand_dsigmaBox_charm207(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm167(double x) const
const double getIntegrand_dsigmaBox_charm200(double x) const
const double getIntegrand_dsigmaBox_charm202(double x) const
const double getIntegrand_AFBnumeratorWithISR_charm192(double x) const

◆ LEP2AFBe()

const double StandardModel::LEP2AFBe ( const double  s) const
virtual

Definition at line 6989 of file StandardModel/src/StandardModel.cpp.

6990{
6991 return 0.;
6992}

◆ LEP2AFBmu()

const double StandardModel::LEP2AFBmu ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 6994 of file StandardModel/src/StandardModel.cpp.

6995{
6996
6997 bSigmaForAFB = true;
6998 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6999 double relerr = 1.e-7;
7000 double abserr = 1.e-17;
7001
7002 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7004
7005 /* SM contribution with the approximate formula */
7007
7008 } else {
7009
7010 if(s == 130.*130.){
7011 double AFB_noBox, sigma = 0.0;
7012 if (!flagLEP2[ISR])
7013 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7014 else {
7015 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu130, &(*this), _1));
7016 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7017 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7018 }
7019 double numerator = average; // interval
7020
7021
7022 sigma = LEP2sigmaMu(s);
7023
7024 AFB_noBox = numerator/sigma;
7025 }
7026 SMresult_cache = AFB_noBox;
7027
7028 if (flagLEP2[WeakBox]) {
7029 // numerator
7030 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7031 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7032 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7033 }
7034 double sigma_box_F = average; // interval
7035 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7036 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7037 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7038 }
7039 double sigma_box_B = average; // interval
7040
7041 // denominator
7042 if (!flagLEP2[ISR]) {
7043
7044 sigma = LEP2sigmaMu(s);
7045 }
7046
7047 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7048 }
7049 } else if (s == 136.*136.){
7050 double AFB_noBox, sigma = 0.0;
7051 if (!flagLEP2[ISR])
7052 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7053 else {
7054 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu136, &(*this), _1));
7055 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7056 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7057 }
7058 double numerator = average; // interval
7059
7060
7061 sigma = LEP2sigmaMu(s);
7062
7063 AFB_noBox = numerator/sigma;
7064 }
7065 SMresult_cache = AFB_noBox;
7066
7067 if (flagLEP2[WeakBox]) {
7068 // numerator
7069 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7070 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7071 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7072 }
7073 double sigma_box_F = average; // interval
7074 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7075 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7076 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7077 }
7078 double sigma_box_B = average; // interval
7079
7080 // denominator
7081 if (!flagLEP2[ISR]) {
7082
7083 sigma = LEP2sigmaMu(s);
7084 }
7085
7086 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7087 }
7088 } else if (s == 161.*161.){
7089 double AFB_noBox, sigma = 0.0;
7090 if (!flagLEP2[ISR])
7091 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7092 else {
7093 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu161, &(*this), _1));
7094 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7095 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7096 }
7097 double numerator = average; // interval
7098
7099
7100 sigma = LEP2sigmaMu(s);
7101
7102 AFB_noBox = numerator/sigma;
7103 }
7104 SMresult_cache = AFB_noBox;
7105
7106 if (flagLEP2[WeakBox]) {
7107 // numerator
7108 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7109 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7110 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7111 }
7112 double sigma_box_F = average; // interval
7113 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7114 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7115 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7116 }
7117 double sigma_box_B = average; // interval
7118
7119 // denominator
7120 if (!flagLEP2[ISR]) {
7121
7122 sigma = LEP2sigmaMu(s);
7123 }
7124
7125 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7126 }
7127 } else if (s == 172.*172.){
7128 double AFB_noBox, sigma = 0.0;
7129 if (!flagLEP2[ISR])
7130 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7131 else {
7132 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu172, &(*this), _1));
7133 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7134 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7135 }
7136 double numerator = average; // interval
7137
7138
7139 sigma = LEP2sigmaMu(s);
7140
7141 AFB_noBox = numerator/sigma;
7142 }
7143 SMresult_cache = AFB_noBox;
7144
7145 if (flagLEP2[WeakBox]) {
7146 // numerator
7147 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7148 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7149 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7150 }
7151 double sigma_box_F = average; // interval
7152 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7153 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7154 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7155 }
7156 double sigma_box_B = average; // interval
7157
7158 // denominator
7159 if (!flagLEP2[ISR]) {
7160
7161 sigma = LEP2sigmaMu(s);
7162 }
7163
7164 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7165 }
7166 } else if (s == 183.*183.) {
7167 double AFB_noBox, sigma = 0.0;
7168 if (!flagLEP2[ISR])
7169 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7170 else {
7171 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu183, &(*this), _1));
7172 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7173 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7174 }
7175 double numerator = average; // interval
7176
7177
7178 sigma = LEP2sigmaMu(s);
7179
7180 AFB_noBox = numerator/sigma;
7181 }
7182 SMresult_cache = AFB_noBox;
7183
7184 if (flagLEP2[WeakBox]) {
7185 // numerator
7186 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7187 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7188 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7189 }
7190 double sigma_box_F = average; // interval
7191 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7192 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7193 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7194 }
7195 double sigma_box_B = average; // interval
7196
7197 // denominator
7198 if (!flagLEP2[ISR]) {
7199
7200 sigma = LEP2sigmaMu(s);
7201 }
7202
7203 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7204 }
7205 } else if (s == 189.*189.) {
7206 double AFB_noBox, sigma = 0.0;
7207 if (!flagLEP2[ISR])
7208 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7209 else {
7210 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu189, &(*this), _1));
7211 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7212 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7213 }
7214 double numerator = average; // interval
7215
7216
7217 sigma = LEP2sigmaMu(s);
7218
7219 AFB_noBox = numerator/sigma;
7220 }
7221 SMresult_cache = AFB_noBox;
7222
7223 if (flagLEP2[WeakBox]) {
7224 // numerator
7225 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7226 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7227 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7228 }
7229 double sigma_box_F = average; // interval
7230 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7231 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7232 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7233 }
7234 double sigma_box_B = average; // interval
7235
7236 // denominator
7237 if (!flagLEP2[ISR]) {
7238
7239 sigma = LEP2sigmaMu(s);
7240 }
7241
7242 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7243 }
7244 } else if (s == 192.*192.) {
7245 double AFB_noBox, sigma = 0.0;
7246 if (!flagLEP2[ISR])
7247 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7248 else {
7249 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu192, &(*this), _1));
7250 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7251 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7252 }
7253 double numerator = average; // interval
7254
7255
7256 sigma = LEP2sigmaMu(s);
7257
7258 AFB_noBox = numerator/sigma;
7259 }
7260 SMresult_cache = AFB_noBox;
7261
7262 if (flagLEP2[WeakBox]) {
7263 // numerator
7264 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7265 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7266 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7267 }
7268 double sigma_box_F = average; // interval
7269 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7270 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7271 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7272 }
7273 double sigma_box_B = average; // interval
7274
7275 // denominator
7276 if (!flagLEP2[ISR]) {
7277
7278 sigma = LEP2sigmaMu(s);
7279 }
7280
7281 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7282 }
7283 } else if (s == 196.*196.) {
7284 double AFB_noBox, sigma = 0.0;
7285 if (!flagLEP2[ISR])
7286 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7287 else {
7288 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu196, &(*this), _1));
7289 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7290 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7291 }
7292 double numerator = average; // interval
7293
7294
7295 sigma = LEP2sigmaMu(s);
7296
7297 AFB_noBox = numerator/sigma;
7298 }
7299 SMresult_cache = AFB_noBox;
7300
7301 if (flagLEP2[WeakBox]) {
7302 // numerator
7303 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7304 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7305 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7306 }
7307 double sigma_box_F = average; // interval
7308 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7309 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7310 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7311 }
7312 double sigma_box_B = average; // interval
7313
7314 // denominator
7315 if (!flagLEP2[ISR]) {
7316
7317 sigma = LEP2sigmaMu(s);
7318 }
7319
7320 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7321 }
7322 } else if (s == 200.*200.) {
7323 double AFB_noBox, sigma = 0.0;
7324 if (!flagLEP2[ISR])
7325 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7326 else {
7327 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu200, &(*this), _1));
7328 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7329 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7330 }
7331 double numerator = average; // interval
7332
7333
7334 sigma = LEP2sigmaMu(s);
7335
7336 AFB_noBox = numerator/sigma;
7337 }
7338 SMresult_cache = AFB_noBox;
7339
7340 if (flagLEP2[WeakBox]) {
7341 // numerator
7342 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7343 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7344 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7345 }
7346 double sigma_box_F = average; // interval
7347 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7348 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7349 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7350 }
7351 double sigma_box_B = average; // interval
7352
7353 // denominator
7354 if (!flagLEP2[ISR]) {
7355
7356 sigma = LEP2sigmaMu(s);
7357 }
7358
7359 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7360 }
7361 } else if (s == 202.*202.) {
7362 double AFB_noBox, sigma = 0.0;
7363 if (!flagLEP2[ISR])
7364 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7365 else {
7366 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu202, &(*this), _1));
7367 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7368 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7369 }
7370 double numerator = average; // interval
7371
7372
7373 sigma = LEP2sigmaMu(s);
7374
7375 AFB_noBox = numerator/sigma;
7376 }
7377 SMresult_cache = AFB_noBox;
7378
7379 if (flagLEP2[WeakBox]) {
7380 // numerator
7381 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7382 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7383 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7384 }
7385 double sigma_box_F = average; // interval
7386 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7387 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7388 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7389 }
7390 double sigma_box_B = average; // interval
7391
7392 // denominator
7393 if (!flagLEP2[ISR]) {
7394
7395 sigma = LEP2sigmaMu(s);
7396 }
7397
7398 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7399 }
7400 } else if (s == 205.*205.) {
7401 double AFB_noBox, sigma = 0.0;
7402 if (!flagLEP2[ISR])
7403 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7404 else {
7405 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu205, &(*this), _1));
7406 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7407 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7408 }
7409 double numerator = average; // interval
7410
7411
7412 sigma = LEP2sigmaMu(s);
7413
7414 AFB_noBox = numerator/sigma;
7415 }
7416 SMresult_cache = AFB_noBox;
7417
7418 if (flagLEP2[WeakBox]) {
7419 // numerator
7420 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7421 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7422 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7423 }
7424 double sigma_box_F = average; // interval
7425 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7426 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7427 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7428 }
7429 double sigma_box_B = average; // interval
7430
7431 // denominator
7432 if (!flagLEP2[ISR]) {
7433
7434 sigma = LEP2sigmaMu(s);
7435 }
7436
7437 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7438 }
7439 } else if (s == 207.*207.) {
7440 double AFB_noBox, sigma = 0.0;
7441 if (!flagLEP2[ISR])
7442 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7443 else {
7444 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu207, &(*this), _1));
7445 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7446 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7447 }
7448 double numerator = average; // interval
7449
7450
7451 sigma = LEP2sigmaMu(s);
7452
7453 AFB_noBox = numerator/sigma;
7454 }
7455 SMresult_cache = AFB_noBox;
7456
7457 if (flagLEP2[WeakBox]) {
7458 // numerator
7459 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7460 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7461 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7462 }
7463 double sigma_box_F = average; // interval
7464 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7465 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7466 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7467 }
7468 double sigma_box_B = average; // interval
7469
7470 // denominator
7471 if (!flagLEP2[ISR]) {
7472
7473 sigma = LEP2sigmaMu(s);
7474 }
7475
7476 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7477 }
7478 } else {
7479 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::AFBmu!");
7480 }
7481
7482 double AFBmu = SMresult_cache;
7483
7484 gsl_set_error_handler(old_handler);
7485 bSigmaForAFB = false;
7486 return AFBmu;
7487 }
7488}
double LEP2AFBmuApprox(const double s) const
The forward-backward asymmetry at LEP2.
const double getIntegrand_dsigmaBox_mu200(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu192(double x) const
const double getIntegrand_dsigmaBox_mu207(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu207(double x) const
const double getIntegrand_dsigmaBox_mu136(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu196(double x) const
const double getIntegrand_dsigmaBox_mu189(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu136(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu130(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu172(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu202(double x) const
const double getIntegrand_dsigmaBox_mu161(double x) const
const double getIntegrand_dsigmaBox_mu183(double x) const
const double getIntegrand_dsigmaBox_mu172(double x) const
const double getIntegrand_dsigmaBox_mu192(double x) const
const double getIntegrand_dsigmaBox_mu196(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu205(double x) const
const double getIntegrand_dsigmaBox_mu202(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu189(double x) const
virtual const double LEP2sigmaMu(const double s) const
const double getIntegrand_dsigmaBox_mu205(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu200(double x) const
const double AFB_NoISR_l(const QCD::lepton l_flavor, const double s) const
const double getIntegrand_AFBnumeratorWithISR_mu161(double x) const
const double getIntegrand_dsigmaBox_mu130(double x) const
const double getIntegrand_AFBnumeratorWithISR_mu183(double x) const

◆ LEP2AFBtau()

const double StandardModel::LEP2AFBtau ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 7491 of file StandardModel/src/StandardModel.cpp.

7492{
7493
7494 bSigmaForAFB = true;
7495 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
7496 double relerr = 1.e-7;
7497 double abserr = 1.e-17;
7498
7499 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7501
7502 /* SM contribution with the approximate formula */
7504
7505 } else {
7506
7507 if(s == 130.*130.){
7508 double AFB_noBox, sigma = 0.0;
7509 if (!flagLEP2[ISR])
7510 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7511 else {
7512 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau130, &(*this), _1));
7513 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7514 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7515 }
7516 double numerator = average; // interval
7517
7518
7519 sigma = LEP2sigmaTau(s);
7520
7521 AFB_noBox = numerator/sigma;
7522 }
7523 SMresult_cache = AFB_noBox;
7524
7525 if (flagLEP2[WeakBox]) {
7526 // numerator
7527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7528 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7530 }
7531 double sigma_box_F = average; // interval
7532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7533 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7535 }
7536 double sigma_box_B = average; // interval
7537
7538 // denominator
7539 if (!flagLEP2[ISR]) {
7540
7541 sigma = LEP2sigmaTau(s);
7542 }
7543
7544 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7545 }
7546 } else if (s == 136.*136.){
7547 double AFB_noBox, sigma = 0.0;
7548 if (!flagLEP2[ISR])
7549 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7550 else {
7551 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau136, &(*this), _1));
7552 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7553 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7554 }
7555 double numerator = average; // interval
7556
7557
7558 sigma = LEP2sigmaTau(s);
7559
7560 AFB_noBox = numerator/sigma;
7561 }
7562 SMresult_cache = AFB_noBox;
7563
7564 if (flagLEP2[WeakBox]) {
7565 // numerator
7566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7567 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7569 }
7570 double sigma_box_F = average; // interval
7571 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7572 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7573 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7574 }
7575 double sigma_box_B = average; // interval
7576
7577 // denominator
7578 if (!flagLEP2[ISR]) {
7579
7580 sigma = LEP2sigmaTau(s);
7581 }
7582
7583 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7584 }
7585 } else if (s == 161.*161.){
7586 double AFB_noBox, sigma = 0.0;
7587 if (!flagLEP2[ISR])
7588 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7589 else {
7590 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau161, &(*this), _1));
7591 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7592 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7593 }
7594 double numerator = average; // interval
7595
7596
7597 sigma = LEP2sigmaTau(s);
7598
7599 AFB_noBox = numerator/sigma;
7600 }
7601 SMresult_cache = AFB_noBox;
7602
7603 if (flagLEP2[WeakBox]) {
7604 // numerator
7605 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7606 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7607 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7608 }
7609 double sigma_box_F = average; // interval
7610 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7611 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7612 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7613 }
7614 double sigma_box_B = average; // interval
7615
7616 // denominator
7617 if (!flagLEP2[ISR]) {
7618
7619 sigma = LEP2sigmaTau(s);
7620 }
7621
7622 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7623 }
7624 } else if (s == 172.*172.){
7625 double AFB_noBox, sigma = 0.0;
7626 if (!flagLEP2[ISR])
7627 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7628 else {
7629 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau172, &(*this), _1));
7630 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7631 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7632 }
7633 double numerator = average; // interval
7634
7635
7636 sigma = LEP2sigmaTau(s);
7637
7638 AFB_noBox = numerator/sigma;
7639 }
7640 SMresult_cache = AFB_noBox;
7641
7642 if (flagLEP2[WeakBox]) {
7643 // numerator
7644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7645 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7647 }
7648 double sigma_box_F = average; // interval
7649 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7650 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7651 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7652 }
7653 double sigma_box_B = average; // interval
7654
7655 // denominator
7656 if (!flagLEP2[ISR]) {
7657
7658 sigma = LEP2sigmaTau(s);
7659 }
7660
7661 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7662 }
7663 } else if (s == 183.*183.) {
7664 double AFB_noBox, sigma = 0.0;
7665 if (!flagLEP2[ISR])
7666 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7667 else {
7668 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau183, &(*this), _1));
7669 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7670 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7671 }
7672 double numerator = average; // interval
7673
7674
7675 sigma = LEP2sigmaTau(s);
7676
7677 AFB_noBox = numerator/sigma;
7678 }
7679 SMresult_cache = AFB_noBox;
7680
7681 if (flagLEP2[WeakBox]) {
7682 // numerator
7683 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7684 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7685 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7686 }
7687 double sigma_box_F = average; // interval
7688 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7689 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7690 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7691 }
7692 double sigma_box_B = average; // interval
7693
7694 // denominator
7695 if (!flagLEP2[ISR]) {
7696
7697 sigma = LEP2sigmaTau(s);
7698 }
7699
7700 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7701 }
7702 } else if (s == 189.*189.) {
7703 double AFB_noBox, sigma = 0.0;
7704 if (!flagLEP2[ISR])
7705 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7706 else {
7707 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau189, &(*this), _1));
7708 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7709 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7710 }
7711 double numerator = average; // interval
7712
7713
7714 sigma = LEP2sigmaTau(s);
7715
7716 AFB_noBox = numerator/sigma;
7717 }
7718 SMresult_cache = AFB_noBox;
7719
7720 if (flagLEP2[WeakBox]) {
7721 // numerator
7722 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7723 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7724 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7725 }
7726 double sigma_box_F = average; // interval
7727 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7728 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7729 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7730 }
7731 double sigma_box_B = average; // interval
7732
7733 // denominator
7734 if (!flagLEP2[ISR]) {
7735
7736 sigma = LEP2sigmaTau(s);
7737 }
7738
7739 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7740 }
7741 } else if (s == 192.*192.) {
7742 double AFB_noBox, sigma = 0.0;
7743 if (!flagLEP2[ISR])
7744 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7745 else {
7746 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau192, &(*this), _1));
7747 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7748 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7749 }
7750 double numerator = average; // interval
7751
7752
7753 sigma = LEP2sigmaTau(s);
7754
7755 AFB_noBox = numerator/sigma;
7756 }
7757 SMresult_cache = AFB_noBox;
7758
7759 if (flagLEP2[WeakBox]) {
7760 // numerator
7761 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7762 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7763 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7764 }
7765 double sigma_box_F = average; // interval
7766 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7767 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7768 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7769 }
7770 double sigma_box_B = average; // interval
7771
7772 // denominator
7773 if (!flagLEP2[ISR]) {
7774
7775 sigma = LEP2sigmaTau(s);
7776 }
7777
7778 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7779 }
7780 } else if (s == 196.*196.) {
7781 double AFB_noBox, sigma = 0.0;
7782 if (!flagLEP2[ISR])
7783 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7784 else {
7785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau196, &(*this), _1));
7786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7788 }
7789 double numerator = average; // interval
7790
7791
7792 sigma = LEP2sigmaTau(s);
7793
7794 AFB_noBox = numerator/sigma;
7795 }
7796 SMresult_cache = AFB_noBox;
7797
7798 if (flagLEP2[WeakBox]) {
7799 // numerator
7800 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7801 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7802 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7803 }
7804 double sigma_box_F = average; // interval
7805 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7806 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7807 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7808 }
7809 double sigma_box_B = average; // interval
7810
7811 // denominator
7812 if (!flagLEP2[ISR]) {
7813
7814 sigma = LEP2sigmaTau(s);
7815 }
7816
7817 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7818 }
7819 } else if (s == 200.*200.) {
7820 double AFB_noBox, sigma = 0.0;
7821 if (!flagLEP2[ISR])
7822 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7823 else {
7824 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau200, &(*this), _1));
7825 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7826 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7827 }
7828 double numerator = average; // interval
7829
7830
7831 sigma = LEP2sigmaTau(s);
7832
7833 AFB_noBox = numerator/sigma;
7834 }
7835 SMresult_cache = AFB_noBox;
7836
7837 if (flagLEP2[WeakBox]) {
7838 // numerator
7839 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7840 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7841 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7842 }
7843 double sigma_box_F = average; // interval
7844 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7845 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7846 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7847 }
7848 double sigma_box_B = average; // interval
7849
7850 // denominator
7851 if (!flagLEP2[ISR]) {
7852
7853 sigma = LEP2sigmaTau(s);
7854 }
7855
7856 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7857 }
7858 } else if (s == 202.*202.) {
7859 double AFB_noBox, sigma = 0.0;
7860 if (!flagLEP2[ISR])
7861 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7862 else {
7863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau202, &(*this), _1));
7864 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7865 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7866 }
7867 double numerator = average; // interval
7868
7869
7870 sigma = LEP2sigmaTau(s);
7871
7872 AFB_noBox = numerator/sigma;
7873 }
7874 SMresult_cache = AFB_noBox;
7875
7876 if (flagLEP2[WeakBox]) {
7877 // numerator
7878 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7879 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7880 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7881 }
7882 double sigma_box_F = average; // interval
7883 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7884 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7885 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7886 }
7887 double sigma_box_B = average; // interval
7888
7889 // denominator
7890 if (!flagLEP2[ISR]) {
7891
7892 sigma = LEP2sigmaTau(s);
7893 }
7894
7895 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7896 }
7897 } else if (s == 205.*205.) {
7898 double AFB_noBox, sigma = 0.0;
7899 if (!flagLEP2[ISR])
7900 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7901 else {
7902 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau205, &(*this), _1));
7903 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7904 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7905 }
7906 double numerator = average; // interval
7907
7908
7909 sigma = LEP2sigmaTau(s);
7910
7911 AFB_noBox = numerator/sigma;
7912 }
7913 SMresult_cache = AFB_noBox;
7914
7915 if (flagLEP2[WeakBox]) {
7916 // numerator
7917 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7918 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7919 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7920 }
7921 double sigma_box_F = average; // interval
7922 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7923 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7924 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7925 }
7926 double sigma_box_B = average; // interval
7927
7928 // denominator
7929 if (!flagLEP2[ISR]) {
7930
7931 sigma = LEP2sigmaTau(s);
7932 }
7933
7934 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7935 }
7936 } else if (s == 207.*207.) {
7937 double AFB_noBox, sigma = 0.0;
7938 if (!flagLEP2[ISR])
7939 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7940 else {
7941 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau207, &(*this), _1));
7942 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7943 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7944 }
7945 double numerator = average; // interval
7946
7947
7948 sigma = LEP2sigmaTau(s);
7949
7950 AFB_noBox = numerator/sigma;
7951 }
7952 SMresult_cache = AFB_noBox;
7953
7954 if (flagLEP2[WeakBox]) {
7955 // numerator
7956 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7957 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7958 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7959 }
7960 double sigma_box_F = average; // interval
7961 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7962 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7963 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7964 }
7965 double sigma_box_B = average; // interval
7966
7967 // denominator
7968 if (!flagLEP2[ISR]) {
7969
7970 sigma = LEP2sigmaTau(s);
7971 }
7972
7973 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7974 }
7975 } else {
7976 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBtau!");
7977 }
7978
7979 double AFBtau = SMresult_cache;
7980
7981 gsl_set_error_handler(old_handler);
7982 bSigmaForAFB = false;
7983 return AFBtau;
7984 }
7985}
An observable class for the forward-backward asymmetry in at the pole.
Definition: AFBlepton.h:160
double LEP2AFBtauApprox(const double s) const
The forward-backward asymmetry at LEP2.
const double getIntegrand_AFBnumeratorWithISR_tau130(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau200(double x) const
const double getIntegrand_dsigmaBox_tau136(double x) const
virtual const double LEP2sigmaTau(const double s) const
const double getIntegrand_AFBnumeratorWithISR_tau172(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau192(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau196(double x) const
const double getIntegrand_dsigmaBox_tau183(double x) const
const double getIntegrand_dsigmaBox_tau196(double x) const
const double getIntegrand_dsigmaBox_tau192(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau136(double x) const
const double getIntegrand_dsigmaBox_tau189(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau183(double x) const
const double getIntegrand_dsigmaBox_tau202(double x) const
const double getIntegrand_dsigmaBox_tau172(double x) const
const double getIntegrand_dsigmaBox_tau200(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau202(double x) const
const double getIntegrand_dsigmaBox_tau161(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau207(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau205(double x) const
const double getIntegrand_dsigmaBox_tau207(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau189(double x) const
const double getIntegrand_AFBnumeratorWithISR_tau161(double x) const
const double getIntegrand_dsigmaBox_tau130(double x) const
const double getIntegrand_dsigmaBox_tau205(double x) const

◆ LEP2dsigmadcosBinE()

const double StandardModel::LEP2dsigmadcosBinE ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Definition at line 9657 of file StandardModel/src/StandardModel.cpp.

9658{
9659 return LEP2dsigmadcosE(s, cos);
9660}
virtual const double LEP2dsigmadcosE(const double s, const double cos) const

◆ LEP2dsigmadcosBinMu()

const double StandardModel::LEP2dsigmadcosBinMu ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Definition at line 9662 of file StandardModel/src/StandardModel.cpp.

9663{
9664 return LEP2dsigmadcosMu(s, cos);
9665}
virtual const double LEP2dsigmadcosMu(const double s, const double cos) const

◆ LEP2dsigmadcosBinTau()

const double StandardModel::LEP2dsigmadcosBinTau ( const double  s,
const double  cos,
const double  cosmin,
const double  cosmax 
) const
virtual

Definition at line 9667 of file StandardModel/src/StandardModel.cpp.

9668{
9669 return LEP2dsigmadcosTau(s, cos);
9670}
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const

◆ LEP2dsigmadcosE()

const double StandardModel::LEP2dsigmadcosE ( const double  s,
const double  cos 
) const
virtual

Definition at line 9615 of file StandardModel/src/StandardModel.cpp.

9616{
9617 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9619
9620 /* SM contribution with the approximate formula */
9622
9623 } else {
9624 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosE only implemented via semi-analytical approx");
9625 }
9626}
double LEP2dsigmadcosEApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2dsigmadcosMu()

const double StandardModel::LEP2dsigmadcosMu ( const double  s,
const double  cos 
) const
virtual

Definition at line 9628 of file StandardModel/src/StandardModel.cpp.

9629{
9630 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9632
9633 /* SM contribution with the approximate formula */
9635
9636 } else {
9637 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosMu only implemented via semi-analytical approx");
9638 }
9639}
double LEP2dsigmadcosMuApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2dsigmadcosTau()

const double StandardModel::LEP2dsigmadcosTau ( const double  s,
const double  cos 
) const
virtual

Definition at line 9641 of file StandardModel/src/StandardModel.cpp.

9642{
9643 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9645
9646 /* SM contribution with the approximate formula */
9648
9649 } else {
9650 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosTau only implemented via semi-analytical approx");
9651 }
9652}
double LEP2dsigmadcosTauApprox(const double s, const double cos) const
The differential cross section at LEP2.

◆ LEP2Rbottom()

const double StandardModel::LEP2Rbottom ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 7988 of file StandardModel/src/StandardModel.cpp.

7989{
7990
7991 double sigma_b = LEP2sigmaBottom(s);
7992 double sigma_had = LEP2sigmaHadron(s);
7993 SMresult_cache = sigma_b / sigma_had;
7994 double R_bottom = SMresult_cache;
7995
7996 return R_bottom;
7997}
virtual const double LEP2sigmaHadron(const double s) const

◆ LEP2Rcharm()

const double StandardModel::LEP2Rcharm ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 8000 of file StandardModel/src/StandardModel.cpp.

8001{
8002
8003 double sigma_c = LEP2sigmaCharm(s);
8004 double sigma_had = LEP2sigmaHadron(s);
8005 SMresult_cache = sigma_c / sigma_had;
8006 double R_charm = SMresult_cache;
8007
8008 return R_charm;
8009}

◆ LEP2sigmaBottom()

const double StandardModel::LEP2sigmaBottom ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 4825 of file StandardModel/src/StandardModel.cpp.

4826{
4827 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4828 double relerr = 1.e-8;
4829 double abserr = 1.e-20;
4830
4831 if(s == 133.*133.){
4832
4833 if (!flagLEP2[ISR]){
4835 } else {
4836 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
4837 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4838 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4839 }
4841 }
4842
4843 if (flagLEP2[WeakBox]) {
4844 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
4845 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4846 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4847 }
4848 double sigma_box = average;
4849 SMresult_cache += sigma_box;
4850 }
4851 } else if (s == 167.*167.){
4852 if (!flagLEP2[ISR])
4854 else {
4855 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
4856 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4857 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4858 }
4860 }
4861
4862 if (flagLEP2[WeakBox]) {
4863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
4864 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4865 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4866 }
4867 double sigma_box = average;
4868 SMresult_cache += sigma_box;
4869 }
4870 } else if (s == 183.*183.) {
4871 if (!flagLEP2[ISR])
4873 else {
4874 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
4875 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4876 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4877 }
4879 }
4880
4881 if (flagLEP2[WeakBox]) {
4882 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
4883 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4884 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4885 }
4886 double sigma_box = average;
4887 SMresult_cache += sigma_box;
4888 }
4889 } else if (s == 189.*189.) {
4890 if (!flagLEP2[ISR])
4892 else {
4893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
4894 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4895 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4896 }
4898 }
4899
4900 if (flagLEP2[WeakBox]) {
4901 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
4902 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4903 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4904 }
4905 double sigma_box = average;
4906 SMresult_cache += sigma_box;
4907 }
4908 } else if (s == 192.*192.) {
4909 if (!flagLEP2[ISR])
4911 else {
4912 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
4913 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4914 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4915 }
4917 }
4918
4919 if (flagLEP2[WeakBox]) {
4920 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
4921 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4922 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4923 }
4924 double sigma_box = average;
4925 SMresult_cache += sigma_box;
4926 }
4927 } else if (s == 196.*196.) {
4928 if (!flagLEP2[ISR])
4930 else {
4931 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
4932 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4933 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4934 }
4936 }
4937
4938 if (flagLEP2[WeakBox]) {
4939 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
4940 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4941 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4942 }
4943 double sigma_box = average;
4944 SMresult_cache += sigma_box;
4945 }
4946 } else if (s == 200.*200.) {
4947 if (!flagLEP2[ISR])
4949 else {
4950 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
4951 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4952 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4953 }
4955 }
4956
4957 if (flagLEP2[WeakBox]) {
4958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
4959 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4961 }
4962 double sigma_box = average;
4963 SMresult_cache += sigma_box;
4964 }
4965 } else if (s == 202.*202.) {
4966 if (!flagLEP2[ISR])
4968 else {
4969 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
4970 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4971 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4972 }
4974 }
4975
4976 if (flagLEP2[WeakBox]) {
4977 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
4978 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4979 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4980 }
4981 double sigma_box = average;
4982 SMresult_cache += sigma_box;
4983 }
4984 } else if (s == 205.*205.) {
4985 if (!flagLEP2[ISR])
4987 else {
4988 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
4989 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4990 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4991 }
4993 }
4994
4995 if (flagLEP2[WeakBox]) {
4996 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
4997 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4998 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4999 }
5000 double sigma_box = average;
5001 SMresult_cache += sigma_box;
5002 }
5003 } else if (s == 207.*207.) {
5004 if (!flagLEP2[ISR])
5006 else {
5007 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
5008 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5009 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5010 }
5012 }
5013
5014 if (flagLEP2[WeakBox]) {
5015 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
5016 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5017 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5018 }
5019 double sigma_box = average;
5020 SMresult_cache += sigma_box;
5021 }
5022 } else {
5023 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaBottom!");
5024 }
5025
5026
5027 double sigma_mu = SMresult_cache;
5028
5029 gsl_set_error_handler(old_handler);
5030
5031 return sigma_mu;
5032
5033}
const double getIntegrand_sigmaWithISR_bottom200(double x) const
const double getIntegrand_sigmaWithISR_bottom207(double x) const
const double getIntegrand_sigmaWithISR_bottom192(double x) const
const double sigma_NoISR_q(const QCD::quark q_flavor, const double s) const
const double getIntegrand_sigmaWithISR_bottom196(double x) const
const double getIntegrand_sigmaWithISR_bottom205(double x) const
const double getIntegrand_sigmaWithISR_bottom133(double x) const
const double getIntegrand_sigmaWithISR_bottom202(double x) const
const double getIntegrand_sigmaWithISR_bottom167(double x) const
const double getIntegrand_sigmaWithISR_bottom183(double x) const
const double getIntegrand_sigmaWithISR_bottom189(double x) const

◆ LEP2sigmaCharm()

const double StandardModel::LEP2sigmaCharm ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 4614 of file StandardModel/src/StandardModel.cpp.

4615{
4616 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4617 double relerr = 1.e-8;
4618 double abserr = 1.e-20;
4619
4620 if(s == 133.*133.){
4621
4622 if (!flagLEP2[ISR]){
4624 } else {
4625 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
4626 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4627 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4628 }
4630 }
4631
4632 if (flagLEP2[WeakBox]) {
4633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
4634 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4636 }
4637 double sigma_box = average;
4638 SMresult_cache += sigma_box;
4639 }
4640 } else if (s == 167.*167.){
4641 if (!flagLEP2[ISR])
4643 else {
4644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
4645 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4647 }
4649 }
4650
4651 if (flagLEP2[WeakBox]) {
4652 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
4653 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4654 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4655 }
4656 double sigma_box = average;
4657 SMresult_cache += sigma_box;
4658 }
4659 } else if (s == 183.*183.) {
4660 if (!flagLEP2[ISR])
4662 else {
4663 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
4664 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4665 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4666 }
4668 }
4669
4670 if (flagLEP2[WeakBox]) {
4671 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
4672 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4673 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4674 }
4675 double sigma_box = average;
4676 SMresult_cache += sigma_box;
4677 }
4678 } else if (s == 189.*189.) {
4679 if (!flagLEP2[ISR])
4681 else {
4682 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
4683 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4684 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4685 }
4687 }
4688
4689 if (flagLEP2[WeakBox]) {
4690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
4691 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4693 }
4694 double sigma_box = average;
4695 SMresult_cache += sigma_box;
4696 }
4697 } else if (s == 192.*192.) {
4698 if (!flagLEP2[ISR])
4700 else {
4701 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
4702 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4703 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4704 }
4706 }
4707
4708 if (flagLEP2[WeakBox]) {
4709 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
4710 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4711 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4712 }
4713 double sigma_box = average;
4714 SMresult_cache += sigma_box;
4715 }
4716 } else if (s == 196.*196.) {
4717 if (!flagLEP2[ISR])
4719 else {
4720 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
4721 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4722 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4723 }
4725 }
4726
4727 if (flagLEP2[WeakBox]) {
4728 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
4729 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4730 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4731 }
4732 double sigma_box = average;
4733 SMresult_cache += sigma_box;
4734 }
4735 } else if (s == 200.*200.) {
4736 if (!flagLEP2[ISR])
4738 else {
4739 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
4740 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4741 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4742 }
4744 }
4745
4746 if (flagLEP2[WeakBox]) {
4747 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
4748 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4749 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4750 }
4751 double sigma_box = average;
4752 SMresult_cache += sigma_box;
4753 }
4754 } else if (s == 202.*202.) {
4755 if (!flagLEP2[ISR])
4757 else {
4758 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
4759 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4760 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4761 }
4763 }
4764
4765 if (flagLEP2[WeakBox]) {
4766 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
4767 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4768 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4769 }
4770 double sigma_box = average;
4771 SMresult_cache += sigma_box;
4772 }
4773 } else if (s == 205.*205.) {
4774 if (!flagLEP2[ISR])
4776 else {
4777 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
4778 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4779 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4780 }
4782 }
4783
4784 if (flagLEP2[WeakBox]) {
4785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
4786 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4788 }
4789 double sigma_box = average;
4790 SMresult_cache += sigma_box;
4791 }
4792 } else if (s == 207.*207.) {
4793 if (!flagLEP2[ISR])
4795 else {
4796 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
4797 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4798 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4799 }
4801 }
4802
4803 if (flagLEP2[WeakBox]) {
4804 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
4805 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4806 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4807 }
4808 double sigma_box = average;
4809 SMresult_cache += sigma_box;
4810 }
4811 } else {
4812 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaCharm!");
4813 }
4814
4815
4816 double sigma_mu = SMresult_cache;
4817
4818 gsl_set_error_handler(old_handler);
4819
4820 return sigma_mu;
4821
4822}
const double getIntegrand_sigmaWithISR_charm192(double x) const
const double getIntegrand_sigmaWithISR_charm183(double x) const
const double getIntegrand_sigmaWithISR_charm205(double x) const
const double getIntegrand_sigmaWithISR_charm207(double x) const
const double getIntegrand_sigmaWithISR_charm202(double x) const
const double getIntegrand_sigmaWithISR_charm200(double x) const
const double getIntegrand_sigmaWithISR_charm133(double x) const
const double getIntegrand_sigmaWithISR_charm167(double x) const
const double getIntegrand_sigmaWithISR_charm196(double x) const
const double getIntegrand_sigmaWithISR_charm189(double x) const

◆ LEP2sigmaE()

const double StandardModel::LEP2sigmaE ( const double  s) const
virtual

Definition at line 4094 of file StandardModel/src/StandardModel.cpp.

4095{
4096 return 0.;
4097}

◆ LEP2sigmaHadron()

const double StandardModel::LEP2sigmaHadron ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 5036 of file StandardModel/src/StandardModel.cpp.

5037{
5038 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
5039 double relerr = 1.e-8;
5040 double abserr = 1.e-20;
5041
5042 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
5044
5045 /* SM contribution with the approximate formula */
5047
5048 } else {
5049
5050 if(s == 130.*130.){
5051
5052 if (!flagLEP2[ISR]){
5058 } else {
5059
5060 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up130, &(*this), _1));
5061 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5062 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5063 }
5065
5066 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down130, &(*this), _1));
5067 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5068 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5069 }
5071
5072 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm130, &(*this), _1));
5073 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5074 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5075 }
5077
5078 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange130, &(*this), _1));
5079 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5080 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5081 }
5083
5084 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom130, &(*this), _1));
5085 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5086 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5087 }
5089
5090 }
5091
5092 if (flagLEP2[WeakBox]) {
5093 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up130, &(*this), _1));
5094 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5095 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5096 }
5097 double sigma_box = average;
5098
5099 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down130, &(*this), _1));
5100 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5101 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5102 }
5103 sigma_box += average;
5104
5105 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm130, &(*this), _1));
5106 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5107 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5108 }
5109 sigma_box += average;
5110
5111 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange130, &(*this), _1));
5112 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5113 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5114 }
5115 sigma_box += average;
5116
5117 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom130, &(*this), _1));
5118 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5119 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5120 }
5121 sigma_box += average;
5122 SMresult_cache += sigma_box;
5123 }
5124 } else if (s == 133.*133.) {
5125 if (!flagLEP2[ISR]){
5131 } else {
5132
5133 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up133, &(*this), _1));
5134 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5135 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5136 }
5138
5139 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down133, &(*this), _1));
5140 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5141 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5142 }
5144
5145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
5146 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5148 }
5150
5151 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange133, &(*this), _1));
5152 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5153 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5154 }
5156
5157 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
5158 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5159 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5160 }
5162 }
5163
5164 if (flagLEP2[WeakBox]) {
5165 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up133, &(*this), _1));
5166 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5167 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5168 }
5169 double sigma_box = average;
5170
5171 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down133, &(*this), _1));
5172 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5173 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5174 }
5175 sigma_box += average;
5176
5177 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
5178 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5179 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5180 }
5181 sigma_box += average;
5182
5183 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange133, &(*this), _1));
5184 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5185 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5186 }
5187 sigma_box += average;
5188
5189 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
5190 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5191 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5192 }
5193 sigma_box += average;
5194 SMresult_cache += sigma_box;
5195 }
5196 } else if (s == 136.*136.) {
5197 if (!flagLEP2[ISR]){
5203 } else {
5204
5205 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up136, &(*this), _1));
5206 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5207 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5208 }
5210
5211 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down136, &(*this), _1));
5212 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5213 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5214 }
5216
5217 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm136, &(*this), _1));
5218 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5219 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5220 }
5222
5223 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange136, &(*this), _1));
5224 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5225 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5226 }
5228
5229 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom136, &(*this), _1));
5230 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5231 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5232 }
5234 }
5235
5236 if (flagLEP2[WeakBox]) {
5237 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up136, &(*this), _1));
5238 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5239 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5240 }
5241 double sigma_box = average;
5242
5243 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down136, &(*this), _1));
5244 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5245 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5246 }
5247 sigma_box += average;
5248
5249 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm136, &(*this), _1));
5250 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5251 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5252 }
5253 sigma_box += average;
5254
5255 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange136, &(*this), _1));
5256 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5257 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5258 }
5259 sigma_box += average;
5260
5261 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom136, &(*this), _1));
5262 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5263 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5264 }
5265 sigma_box += average;
5266 SMresult_cache += sigma_box;
5267 }
5268 } else if (s == 161.*161.){
5269 if (!flagLEP2[ISR]){
5275 } else {
5276
5277 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up161, &(*this), _1));
5278 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5279 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5280 }
5282
5283 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down161, &(*this), _1));
5284 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5285 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5286 }
5288
5289 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm161, &(*this), _1));
5290 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-12, 1.e-6, 100, w_GSL1, &average, &error) != 0){
5291 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5292 }
5294
5295 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange161, &(*this), _1));
5296 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 200, w_GSL1, &average, &error) != 0){
5297 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5298 }
5300
5301 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom161, &(*this), _1));
5302 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5303 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5304 }
5306 }
5307
5308 if (flagLEP2[WeakBox]) {
5309 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up161, &(*this), _1));
5310 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5311 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5312 }
5313 double sigma_box = average;
5314
5315 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down161, &(*this), _1));
5316 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5317 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5318 }
5319 sigma_box += average;
5320
5321 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm161, &(*this), _1));
5322 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5323 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5324 }
5325 sigma_box += average;
5326
5327 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange161, &(*this), _1));
5328 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5329 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5330 }
5331 sigma_box += average;
5332
5333 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom161, &(*this), _1));
5334 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5335 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5336 }
5337 sigma_box += average;
5338 SMresult_cache += sigma_box;
5339 }
5340 } else if (s == 167.*167.) {
5341 if (!flagLEP2[ISR]){
5347 } else {
5348
5349 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up167, &(*this), _1));
5350 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5351 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5352 }
5353
5355
5356 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down167, &(*this), _1));
5357 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5358 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5359 }
5361
5362 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
5363 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5364 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5365 }
5367
5368 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange167, &(*this), _1));
5369 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5370 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5371 }
5373
5374 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
5375 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5376 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5377 }
5379 }
5380
5381 if (flagLEP2[WeakBox]) {
5382 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up167, &(*this), _1));
5383 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5384 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5385 }
5386 double sigma_box = average;
5387
5388 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down167, &(*this), _1));
5389 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5390 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5391 }
5392 sigma_box += average;
5393
5394 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
5395 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5396 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5397 }
5398 sigma_box += average;
5399
5400 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange167, &(*this), _1));
5401 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5402 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5403 }
5404 sigma_box += average;
5405
5406 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
5407 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5408 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5409 }
5410 sigma_box += average;
5411 SMresult_cache += sigma_box;
5412 }
5413 } else if (s == 172.*172.) {
5414 if (!flagLEP2[ISR]){
5420 } else {
5421
5422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up172, &(*this), _1));
5423 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5425 }
5427
5428 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down172, &(*this), _1));
5429 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5430 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5431 }
5433
5434 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm172, &(*this), _1));
5435 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5436 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5437 }
5439
5440 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange172, &(*this), _1));
5441 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5442 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5443 }
5445
5446 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom172, &(*this), _1));
5447 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5448 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5449 }
5451 }
5452
5453 if (flagLEP2[WeakBox]) {
5454 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up172, &(*this), _1));
5455 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5456 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5457 }
5458 double sigma_box = average;
5459
5460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down172, &(*this), _1));
5461 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5463 }
5464 sigma_box += average;
5465
5466 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm172, &(*this), _1));
5467 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5468 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5469 }
5470 sigma_box += average;
5471
5472 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange172, &(*this), _1));
5473 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5474 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5475 }
5476 sigma_box += average;
5477
5478 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom172, &(*this), _1));
5479 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5480 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5481 }
5482 sigma_box += average;
5483 SMresult_cache += sigma_box;
5484 }
5485 } else if (s == 183.*183.) {
5486 if (!flagLEP2[ISR]){
5492 } else {
5493
5494 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up183, &(*this), _1));
5495 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5496 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5497 }
5499
5500 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down183, &(*this), _1));
5501 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5502 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5503 }
5505
5506 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
5507 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5508 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5509 }
5511
5512 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange183, &(*this), _1));
5513 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5514 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5515 }
5517
5518 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
5519 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5520 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5521 }
5523 }
5524
5525 if (flagLEP2[WeakBox]) {
5526 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up183, &(*this), _1));
5527 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5528 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5529 }
5530 double sigma_box = average;
5531
5532 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down183, &(*this), _1));
5533 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5534 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5535 }
5536 sigma_box += average;
5537
5538 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
5539 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5540 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5541 }
5542 sigma_box += average;
5543
5544 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange183, &(*this), _1));
5545 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5546 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5547 }
5548 sigma_box += average;
5549
5550 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
5551 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5552 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5553 }
5554 sigma_box += average;
5555 SMresult_cache += sigma_box;
5556 }
5557 } else if (s == 189.*189.) {
5558 if (!flagLEP2[ISR]){
5564 } else {
5565
5566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up189, &(*this), _1));
5567 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5569 }
5571
5572 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down189, &(*this), _1));
5573 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5574 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5575 }
5577
5578 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
5579 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5580 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5581 }
5583
5584 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange189, &(*this), _1));
5585 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5586 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5587 }
5589
5590 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
5591 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5592 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5593 }
5595 }
5596
5597 if (flagLEP2[WeakBox]) {
5598 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up189, &(*this), _1));
5599 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5600 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5601 }
5602 double sigma_box = average;
5603
5604 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down189, &(*this), _1));
5605 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5606 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5607 }
5608 sigma_box += average;
5609
5610 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
5611 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5612 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5613 }
5614 sigma_box += average;
5615
5616 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange189, &(*this), _1));
5617 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5618 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5619 }
5620 sigma_box += average;
5621
5622 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
5623 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5624 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5625 }
5626 sigma_box += average;
5627 SMresult_cache += sigma_box;
5628 }
5629 } else if (s == 192.*192.) {
5630 if (!flagLEP2[ISR]){
5636 } else {
5637
5638 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up192, &(*this), _1));
5639 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5640 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5641 }
5643
5644 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down192, &(*this), _1));
5645 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5646 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5647 }
5649
5650 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
5651
5652 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5653 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5654 }
5656
5657 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange192, &(*this), _1));
5658
5659 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5660 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5661 }
5663
5664 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
5665 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5666 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5667 }
5669 }
5670
5671 if (flagLEP2[WeakBox]) {
5672 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up192, &(*this), _1));
5673 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5674 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5675 }
5676 double sigma_box = average;
5677
5678 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down192, &(*this), _1));
5679 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5680 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5681 }
5682 sigma_box += average;
5683
5684 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
5685 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5686 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5687 }
5688 sigma_box += average;
5689
5690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange192, &(*this), _1));
5691 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5693 }
5694 sigma_box += average;
5695
5696 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
5697 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5698 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5699 }
5700 sigma_box += average;
5701 SMresult_cache += sigma_box;
5702 }
5703 } else if (s == 196.*196.) {
5704 if (!flagLEP2[ISR]){
5710 } else {
5711
5712 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up196, &(*this), _1));
5713 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5714 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5715 }
5717
5718 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down196, &(*this), _1));
5719 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5720 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5721 }
5723
5724 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
5725 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5726 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5727 }
5729
5730 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange196, &(*this), _1));
5731
5732 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5733 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5734 }
5736
5737 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
5738 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5739 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5740 }
5742 }
5743
5744 if (flagLEP2[WeakBox]) {
5745 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up196, &(*this), _1));
5746 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5747 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5748 }
5749 double sigma_box = average;
5750
5751 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down196, &(*this), _1));
5752 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5753 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5754 }
5755 sigma_box += average;
5756
5757 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
5758 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5759 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5760 }
5761 sigma_box += average;
5762
5763 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange196, &(*this), _1));
5764 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5765 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5766 }
5767 sigma_box += average;
5768
5769 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
5770 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5771 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5772 }
5773 sigma_box += average;
5774 SMresult_cache += sigma_box;
5775 }
5776 } else if (s == 200.*200.) {
5777 if (!flagLEP2[ISR]){
5783 } else {
5784
5785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up200, &(*this), _1));
5786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5788 }
5790
5791 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down200, &(*this), _1));
5792 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5793 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5794 }
5796
5797 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
5798 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5799 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5800 }
5802
5803 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange200, &(*this), _1));
5804 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5805 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5806 }
5808
5809 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
5810 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5811 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5812 }
5814 }
5815
5816 if (flagLEP2[WeakBox]) {
5817 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up200, &(*this), _1));
5818 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5819 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5820 }
5821 double sigma_box = average;
5822
5823 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down200, &(*this), _1));
5824 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5825 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5826 }
5827 sigma_box += average;
5828
5829 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
5830 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5831 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5832 }
5833 sigma_box += average;
5834
5835 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange200, &(*this), _1));
5836 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5837 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5838 }
5839 sigma_box += average;
5840
5841 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
5842 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5843 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5844 }
5845 sigma_box += average;
5846 SMresult_cache += sigma_box;
5847 }
5848 } else if (s == 202.*202.) {
5849 if (!flagLEP2[ISR]){
5855 } else {
5856
5857 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up202, &(*this), _1));
5858
5859
5860
5861 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5862 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5863 }
5865
5866 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down202, &(*this), _1));
5867
5868
5869
5870 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5871 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5872 }
5874
5875 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
5876
5877
5878
5879 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5880 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5881 }
5883
5884 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange202, &(*this), _1));
5885
5886
5887
5888 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5889 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5890 }
5892
5893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
5894
5895
5896
5897 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5898 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5899 }
5901 }
5902
5903 if (flagLEP2[WeakBox]) {
5904 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up202, &(*this), _1));
5905
5906
5907
5908 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5909 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5910 }
5911 double sigma_box = average;
5912
5913 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down202, &(*this), _1));
5914
5915
5916
5917 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5918 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5919 }
5920 sigma_box += average;
5921
5922 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
5923
5924
5925
5926 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5927 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5928 }
5929 sigma_box += average;
5930
5931 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange202, &(*this), _1));
5932
5933
5934
5935 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5936 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5937 }
5938 sigma_box += average;
5939
5940 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
5941
5942
5943
5944 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5945 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5946 }
5947 sigma_box += average;
5948 SMresult_cache += sigma_box;
5949 }
5950 } else if (s == 205.*205.) {
5951 if (!flagLEP2[ISR]){
5957 } else {
5958
5959 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up205, &(*this), _1));
5960
5961
5962
5963 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5964 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5965 }
5967
5968 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down205, &(*this), _1));
5969
5970
5971
5972 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5973 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5974 }
5976
5977 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
5978
5979
5980
5981 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5982 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5983 }
5985
5986 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange205, &(*this), _1));
5987
5988
5989
5990 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5991 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5992 }
5994
5995 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
5996
5997
5998
5999 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6000 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6001 }
6003 }
6004
6005 if (flagLEP2[WeakBox]) {
6006 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up205, &(*this), _1));
6007
6008
6009
6010 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6011 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6012 }
6013 double sigma_box = average;
6014
6015 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down205, &(*this), _1));
6016
6017
6018
6019 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6020 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6021 }
6022 sigma_box += average;
6023
6024 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6025
6026
6027
6028 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6029 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6030 }
6031 sigma_box += average;
6032
6033 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange205, &(*this), _1));
6034
6035
6036
6037 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6038 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6039 }
6040 sigma_box += average;
6041
6042 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6043
6044
6045
6046 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6047 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6048 }
6049 sigma_box += average;
6050 SMresult_cache += sigma_box;
6051 }
6052 } else if (s == 207.*207.) {
6053 if (!flagLEP2[ISR]){
6059 } else {
6060
6061 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up207, &(*this), _1));
6062
6063
6064
6065 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6066 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6067 }
6069
6070 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down207, &(*this), _1));
6071
6072
6073
6074 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6075 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6076 }
6078
6079 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
6080
6081
6082
6083 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6084 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6085 }
6087
6088 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange207, &(*this), _1));
6089
6090
6091
6092 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6093 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6094 }
6096
6097 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
6098
6099
6100
6101 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6103 }
6105 }
6106
6107 if (flagLEP2[WeakBox]) {
6108 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up207, &(*this), _1));
6109
6110
6111
6112 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6113 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6114 }
6115 double sigma_box = average;
6116
6117 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down207, &(*this), _1));
6118
6119
6120
6121 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6122 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6123 }
6124 sigma_box += average;
6125
6126 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6127
6128
6129
6130 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6131 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6132 }
6133 sigma_box += average;
6134
6135 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange207, &(*this), _1));
6136
6137
6138
6139 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6140 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6141 }
6142 sigma_box += average;
6143
6144 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6145
6146
6147
6148 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6149 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6150 }
6151 sigma_box += average;
6152 SMresult_cache += sigma_box;
6153 }
6154 } else {
6155 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaHadron!");
6156 }
6157
6158 double sigma_had = SMresult_cache;
6159
6160 gsl_set_error_handler(old_handler);
6161
6162 return sigma_had;
6163
6164 }
6165}
double LEP2sigmaHadronApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_down183(double x) const
const double getIntegrand_dsigmaBox_strange167(double x) const
const double getIntegrand_sigmaWithISR_strange167(double x) const
const double getIntegrand_sigmaWithISR_strange189(double x) const
const double getIntegrand_sigmaWithISR_strange161(double x) const
const double getIntegrand_dsigmaBox_up130(double x) const
const double getIntegrand_dsigmaBox_down207(double x) const
const double getIntegrand_dsigmaBox_down200(double x) const
const double getIntegrand_dsigmaBox_strange172(double x) const
const double getIntegrand_dsigmaBox_up202(double x) const
const double getIntegrand_sigmaWithISR_down192(double x) const
const double getIntegrand_dsigmaBox_strange130(double x) const
const double getIntegrand_sigmaWithISR_strange136(double x) const
const double getIntegrand_sigmaWithISR_down207(double x) const
const double getIntegrand_dsigmaBox_down136(double x) const
const double getIntegrand_dsigmaBox_strange189(double x) const
const double getIntegrand_sigmaWithISR_up183(double x) const
const double getIntegrand_sigmaWithISR_strange183(double x) const
const double getIntegrand_dsigmaBox_down183(double x) const
const double getIntegrand_dsigmaBox_charm130(double x) const
const double getIntegrand_sigmaWithISR_strange200(double x) const
const double getIntegrand_sigmaWithISR_up167(double x) const
const double getIntegrand_sigmaWithISR_strange207(double x) const
const double getIntegrand_dsigmaBox_down161(double x) const
const double getIntegrand_dsigmaBox_strange207(double x) const
const double getIntegrand_sigmaWithISR_down202(double x) const
const double getIntegrand_dsigmaBox_charm161(double x) const
const double getIntegrand_dsigmaBox_up192(double x) const
const double getIntegrand_sigmaWithISR_strange202(double x) const
const double getIntegrand_dsigmaBox_down202(double x) const
const double getIntegrand_dsigmaBox_up200(double x) const
const double getIntegrand_sigmaWithISR_bottom136(double x) const
const double getIntegrand_sigmaWithISR_bottom130(double x) const
const double getIntegrand_sigmaWithISR_charm161(double x) const
const double getIntegrand_sigmaWithISR_charm172(double x) const
const double getIntegrand_dsigmaBox_up167(double x) const
const double getIntegrand_dsigmaBox_strange200(double x) const
const double getIntegrand_dsigmaBox_strange196(double x) const
const double getIntegrand_dsigmaBox_up207(double x) const
const double getIntegrand_sigmaWithISR_down200(double x) const
const double getIntegrand_sigmaWithISR_charm130(double x) const
const double getIntegrand_sigmaWithISR_down196(double x) const
const double getIntegrand_sigmaWithISR_bottom172(double x) const
const double getIntegrand_sigmaWithISR_up133(double x) const
const double getIntegrand_dsigmaBox_down189(double x) const
const double getIntegrand_sigmaWithISR_up172(double x) const
const double getIntegrand_dsigmaBox_up161(double x) const
const double getIntegrand_sigmaWithISR_strange205(double x) const
const double getIntegrand_dsigmaBox_bottom172(double x) const
const double getIntegrand_dsigmaBox_down133(double x) const
const double getIntegrand_dsigmaBox_down167(double x) const
const double getIntegrand_sigmaWithISR_strange133(double x) const
const double getIntegrand_sigmaWithISR_down130(double x) const
const double getIntegrand_sigmaWithISR_strange192(double x) const
const double getIntegrand_dsigmaBox_bottom130(double x) const
const double getIntegrand_sigmaWithISR_strange130(double x) const
const double getIntegrand_dsigmaBox_strange161(double x) const
const double getIntegrand_sigmaWithISR_down136(double x) const
const double getIntegrand_sigmaWithISR_up192(double x) const
const double getIntegrand_dsigmaBox_strange205(double x) const
const double getIntegrand_sigmaWithISR_up200(double x) const
const double getIntegrand_dsigmaBox_up183(double x) const
const double getIntegrand_dsigmaBox_strange183(double x) const
const double getIntegrand_dsigmaBox_up133(double x) const
const double getIntegrand_sigmaWithISR_strange172(double x) const
const double getIntegrand_dsigmaBox_strange202(double x) const
const double getIntegrand_sigmaWithISR_up189(double x) const
const double getIntegrand_dsigmaBox_down172(double x) const
const double getIntegrand_dsigmaBox_strange136(double x) const
const double getIntegrand_sigmaWithISR_up136(double x) const
const double getIntegrand_sigmaWithISR_strange196(double x) const
const double getIntegrand_dsigmaBox_up205(double x) const
const double getIntegrand_sigmaWithISR_up202(double x) const
const double getIntegrand_sigmaWithISR_down167(double x) const
const double getIntegrand_sigmaWithISR_down133(double x) const
const double getIntegrand_sigmaWithISR_charm136(double x) const
const double getIntegrand_dsigmaBox_down130(double x) const
const double getIntegrand_dsigmaBox_strange192(double x) const
const double getIntegrand_sigmaWithISR_down189(double x) const
const double getIntegrand_dsigmaBox_bottom161(double x) const
const double getIntegrand_sigmaWithISR_up207(double x) const
const double getIntegrand_dsigmaBox_charm172(double x) const
const double getIntegrand_dsigmaBox_charm136(double x) const
const double getIntegrand_sigmaWithISR_up205(double x) const
const double getIntegrand_dsigmaBox_down196(double x) const
const double getIntegrand_sigmaWithISR_up161(double x) const
const double getIntegrand_sigmaWithISR_down172(double x) const
const double getIntegrand_dsigmaBox_strange133(double x) const
const double getIntegrand_sigmaWithISR_up196(double x) const
const double getIntegrand_dsigmaBox_up196(double x) const
const double getIntegrand_sigmaWithISR_bottom161(double x) const
const double getIntegrand_dsigmaBox_up189(double x) const
const double getIntegrand_dsigmaBox_up136(double x) const
const double getIntegrand_sigmaWithISR_down205(double x) const
const double getIntegrand_dsigmaBox_up172(double x) const
const double getIntegrand_sigmaWithISR_up130(double x) const
const double getIntegrand_dsigmaBox_down205(double x) const
const double getIntegrand_dsigmaBox_down192(double x) const
const double getIntegrand_sigmaWithISR_down161(double x) const
const double getIntegrand_dsigmaBox_bottom136(double x) const

◆ LEP2sigmaMu()

const double StandardModel::LEP2sigmaMu ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 4099 of file StandardModel/src/StandardModel.cpp.

4100{
4101 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4102 double relerr = 1.e-8;
4103 double abserr = 1.e-20;
4104
4105 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4107
4108 /* SM contribution with the approximate formula */
4110
4111 } else {
4112
4113 if(s == 130.*130.){
4114
4115 if (!flagLEP2[ISR]){
4117 } else {
4118 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu130, &(*this), _1));
4119 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4120 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4121 }
4123 }
4124
4125 if (flagLEP2[WeakBox]) {
4126 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
4127 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4128 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4129 }
4130 double sigma_box = average;
4131 SMresult_cache += sigma_box;
4132 }
4133 } else if (s == 136.*136.) {
4134 if (!flagLEP2[ISR]){
4136 } else {
4137 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu136, &(*this), _1));
4138 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4139 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4140 }
4142 }
4143
4144 if (flagLEP2[WeakBox]) {
4145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
4146 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4148 }
4149 double sigma_box = average;
4150 SMresult_cache += sigma_box;
4151 }
4152 } else if (s == 161.*161.){
4153 if (!flagLEP2[ISR])
4155 else {
4156 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu161, &(*this), _1));
4157 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4158 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4159 }
4161 }
4162
4163 if (flagLEP2[WeakBox]) {
4164 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
4165 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4166 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4167 }
4168 double sigma_box = average;
4169 SMresult_cache += sigma_box;
4170 }
4171 } else if (s == 172.*172.) {
4172 if (!flagLEP2[ISR])
4174 else {
4175 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu172, &(*this), _1));
4176 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4177 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4178 }
4180 }
4181
4182 if (flagLEP2[WeakBox]) {
4183 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
4184 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4185 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4186 }
4187 double sigma_box = average;
4188 SMresult_cache += sigma_box;
4189 }
4190 } else if (s == 183.*183.) {
4191 if (!flagLEP2[ISR])
4193 else {
4194 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu183, &(*this), _1));
4195 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4196 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4197 }
4199 }
4200
4201 if (flagLEP2[WeakBox]) {
4202 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
4203 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4204 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4205 }
4206 double sigma_box = average;
4207 SMresult_cache += sigma_box;
4208 }
4209 } else if (s == 189.*189.) {
4210 if (!flagLEP2[ISR])
4212 else {
4213 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu189, &(*this), _1));
4214 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4215 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4216 }
4218 }
4219
4220 if (flagLEP2[WeakBox]) {
4221 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
4222 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4223 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4224 }
4225 double sigma_box = average;
4226 SMresult_cache += sigma_box;
4227 }
4228 } else if (s == 192.*192.) {
4229 if (!flagLEP2[ISR])
4231 else {
4232 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu192, &(*this), _1));
4233 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4234 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4235 }
4237 }
4238
4239 if (flagLEP2[WeakBox]) {
4240 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
4241 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4242 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4243 }
4244 double sigma_box = average;
4245 SMresult_cache += sigma_box;
4246 }
4247 } else if (s == 196.*196.) {
4248 if (!flagLEP2[ISR])
4250 else {
4251 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu196, &(*this), _1));
4252 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4253 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4254 }
4256 }
4257
4258 if (flagLEP2[WeakBox]) {
4259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
4260 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4262 }
4263 double sigma_box = average;
4264 SMresult_cache += sigma_box;
4265 }
4266 } else if (s == 200.*200.) {
4267 if (!flagLEP2[ISR])
4269 else {
4270 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu200, &(*this), _1));
4271 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4272 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4273 }
4275 }
4276
4277 if (flagLEP2[WeakBox]) {
4278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
4279 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4281 }
4282 double sigma_box = average;
4283 SMresult_cache += sigma_box;
4284 }
4285 } else if (s == 202.*202.) {
4286 if (!flagLEP2[ISR])
4288 else {
4289 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu202, &(*this), _1));
4290 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4291 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4292 }
4294 }
4295
4296 if (flagLEP2[WeakBox]) {
4297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
4298 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4300 }
4301 double sigma_box = average;
4302 SMresult_cache += sigma_box;
4303 }
4304 } else if (s == 205.*205.) {
4305 if (!flagLEP2[ISR])
4307 else {
4308 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu205, &(*this), _1));
4309 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4310 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4311 }
4313 }
4314
4315 if (flagLEP2[WeakBox]) {
4316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
4317 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4319 }
4320 double sigma_box = average;
4321 SMresult_cache += sigma_box;
4322 }
4323 } else if (s == 207.*207.) {
4324 if (!flagLEP2[ISR])
4326 else {
4327 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu207, &(*this), _1));
4328 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4329 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4330 }
4332 }
4333
4334 if (flagLEP2[WeakBox]) {
4335 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
4336 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4337 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4338 }
4339 double sigma_box = average;
4340 SMresult_cache += sigma_box;
4341 }
4342 } else {
4343 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBmu!");
4344 }
4345
4346 double sigma_mu = SMresult_cache;
4347
4348 gsl_set_error_handler(old_handler);
4349
4350 return sigma_mu;
4351
4352 }
4353}
double LEP2sigmaMuApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_mu207(double x) const
const double getIntegrand_sigmaWithISR_mu172(double x) const
const double getIntegrand_sigmaWithISR_mu136(double x) const
const double getIntegrand_sigmaWithISR_mu161(double x) const
const double sigma_NoISR_l(const QCD::lepton l_flavor, const double s) const
const double getIntegrand_sigmaWithISR_mu130(double x) const
const double getIntegrand_sigmaWithISR_mu202(double x) const
const double getIntegrand_sigmaWithISR_mu205(double x) const
const double getIntegrand_sigmaWithISR_mu189(double x) const
const double getIntegrand_sigmaWithISR_mu196(double x) const
const double getIntegrand_sigmaWithISR_mu200(double x) const
const double getIntegrand_sigmaWithISR_mu183(double x) const
const double getIntegrand_sigmaWithISR_mu192(double x) const

◆ LEP2sigmaTau()

const double StandardModel::LEP2sigmaTau ( const double  s) const
virtual

Reimplemented in NPSTUVWXY.

Definition at line 4356 of file StandardModel/src/StandardModel.cpp.

4357{
4358
4359 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4360 double relerr = 1.e-7;
4361 double abserr = 1.e-17;
4362
4363 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4365
4366 /* SM contribution with the approximate formula */
4368
4369 } else {
4370
4371 if(s == 130.*130.){
4372
4373 if (!flagLEP2[ISR]){
4375 } else {
4376 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau130, &(*this), _1));
4377 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4378 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4379 }
4381 }
4382
4383 if (flagLEP2[WeakBox]) {
4384 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
4385 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4386 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4387 }
4388 double sigma_box = average;
4389 SMresult_cache += sigma_box;
4390 }
4391 } else if (s == 136.*136.) {
4392 if (!flagLEP2[ISR]){
4394 } else {
4395 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau136, &(*this), _1));
4396 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4397 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4398 }
4400 }
4401
4402 if (flagLEP2[WeakBox]) {
4403 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
4404 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4405 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4406 }
4407 double sigma_box = average;
4408 SMresult_cache += sigma_box;
4409 }
4410 } else if (s == 161.*161.){
4411 if (!flagLEP2[ISR])
4413 else {
4414 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau161, &(*this), _1));
4415 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4416 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4417 }
4419 }
4420
4421 if (flagLEP2[WeakBox]) {
4422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
4423 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4425 }
4426 double sigma_box = average;
4427 SMresult_cache += sigma_box;
4428 }
4429 } else if (s == 172.*172.) {
4430 if (!flagLEP2[ISR])
4432 else {
4433 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau172, &(*this), _1));
4434 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4435 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4436 }
4438 }
4439
4440 if (flagLEP2[WeakBox]) {
4441 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
4442 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4443 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4444 }
4445 double sigma_box = average;
4446 SMresult_cache += sigma_box;
4447 }
4448 } else if (s == 183.*183.) {
4449 if (!flagLEP2[ISR])
4451 else {
4452 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau183, &(*this), _1));
4453 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4454 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4455 }
4457 }
4458
4459 if (flagLEP2[WeakBox]) {
4460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
4461 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4463 }
4464 double sigma_box = average;
4465 SMresult_cache += sigma_box;
4466 }
4467 } else if (s == 189.*189.) {
4468 if (!flagLEP2[ISR])
4470 else {
4471 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau189, &(*this), _1));
4472 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4473 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4474 }
4476 }
4477
4478 if (flagLEP2[WeakBox]) {
4479 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
4480 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4481 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4482 }
4483 double sigma_box = average;
4484 SMresult_cache += sigma_box;
4485 }
4486 } else if (s == 192.*192.) {
4487 if (!flagLEP2[ISR])
4489 else {
4490 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau192, &(*this), _1));
4491 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4492 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4493 }
4495 }
4496
4497 if (flagLEP2[WeakBox]) {
4498 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
4499 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4500 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4501 }
4502 double sigma_box = average;
4503 SMresult_cache += sigma_box;
4504 }
4505 } else if (s == 196.*196.) {
4506 if (!flagLEP2[ISR])
4508 else {
4509 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau196, &(*this), _1));
4510 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4511 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4512 }
4514 }
4515
4516 if (flagLEP2[WeakBox]) {
4517 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
4518 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4519 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4520 }
4521 double sigma_box = average;
4522 SMresult_cache += sigma_box;
4523 }
4524 } else if (s == 200.*200.) {
4525 if (!flagLEP2[ISR])
4527 else {
4528 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau200, &(*this), _1));
4529 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4530 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4531 }
4533 }
4534
4535 if (flagLEP2[WeakBox]) {
4536 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
4537 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4538 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4539 }
4540 double sigma_box = average;
4541 SMresult_cache += sigma_box;
4542 }
4543 } else if (s == 202.*202.) {
4544 if (!flagLEP2[ISR])
4546 else {
4547 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau202, &(*this), _1));
4548 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4549 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4550 }
4552 }
4553
4554 if (flagLEP2[WeakBox]) {
4555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
4556 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4558 }
4559 double sigma_box = average;
4560 SMresult_cache += sigma_box;
4561 }
4562 } else if (s == 205.*205.) {
4563 if (!flagLEP2[ISR])
4565 else {
4566 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau205, &(*this), _1));
4567 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4568 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4569 }
4571 }
4572
4573 if (flagLEP2[WeakBox]) {
4574 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
4575 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4576 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4577 }
4578 double sigma_box = average;
4579 SMresult_cache += sigma_box;
4580 }
4581 } else if (s == 207.*207.) {
4582 if (!flagLEP2[ISR])
4584 else {
4585 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau207, &(*this), _1));
4586 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4587 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4588 }
4590 }
4591
4592 if (flagLEP2[WeakBox]) {
4593 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
4594 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4595 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4596 }
4597 double sigma_box = average;
4598 SMresult_cache += sigma_box;
4599 }
4600 } else {
4601 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaTau!");
4602 }
4603
4604 double sigma_tau = SMresult_cache;
4605
4606 gsl_set_error_handler(old_handler);
4607
4608 return sigma_tau;
4609
4610 }
4611}
double LEP2sigmaTauApprox(const double s) const
The cross section at LEP2.
const double getIntegrand_sigmaWithISR_tau207(double x) const
const double getIntegrand_sigmaWithISR_tau205(double x) const
const double getIntegrand_sigmaWithISR_tau196(double x) const
const double getIntegrand_sigmaWithISR_tau161(double x) const
const double getIntegrand_sigmaWithISR_tau183(double x) const
const double getIntegrand_sigmaWithISR_tau130(double x) const
const double getIntegrand_sigmaWithISR_tau200(double x) const
const double getIntegrand_sigmaWithISR_tau189(double x) const
const double getIntegrand_sigmaWithISR_tau192(double x) const
const double getIntegrand_sigmaWithISR_tau136(double x) const
const double getIntegrand_sigmaWithISR_tau202(double x) const
const double getIntegrand_sigmaWithISR_tau172(double x) const

◆ m_q()

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

Definition at line 3565 of file StandardModel.h.

3566 {
3567 switch(q) {
3568 case QCD::UP:
3569 case QCD::DOWN:
3570 case QCD::STRANGE:
3571 return Mrun(mu, getQuarks(q).getMass_scale(),
3572 getQuarks(q).getMass(), q, order);
3573 case QCD::CHARM:
3574 case QCD::BOTTOM:
3575 case QCD::TOP:
3576 return Mrun(mu, getQuarks(q).getMass(), q, order);
3577 default:
3578 throw std::runtime_error("Error in StandardModel::m_q()");
3579 }
3580 }

◆ MLL2eeff()

const double StandardModel::MLL2eeff ( const Particle  f,
const double  s,
const double  t 
) const

Definition at line 3812 of file StandardModel/src/StandardModel.cpp.

3812 {
3813
3814 // Definitions
3815 double Qf, geLSM, gfLSM, is2c2, GZ, Mz2s;
3816
3817 double MLL2SM;
3818
3819 // -------------------------------------------
3820
3821 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3822
3823 is2c2 = 1. / s02() / c02();
3824
3825 GZ = Gamma_Z();
3826
3827 Mz2s = Mz * Mz - s;
3828
3829 if (f.is("ELECTRON")) {
3830 Qf = leptons[ELECTRON].getCharge();
3831 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3832 } else if (f.is("MU")) {
3833 Qf = leptons[MU].getCharge();
3834 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3835 } else if (f.is("TAU")) {
3836 Qf = leptons[TAU].getCharge();
3837 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3838 } else if (f.is("UP")) {
3839 Qf = quarks[UP].getCharge();
3840 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3841 } else if (f.is("CHARM")) {
3842 Qf = quarks[CHARM].getCharge();
3843 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3844 } else if (f.is("DOWN")) {
3845 Qf = quarks[DOWN].getCharge();
3846 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3847 } else if (f.is("STRANGE")) {
3848 Qf = quarks[STRANGE].getCharge();
3849 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3850 } else if (f.is("BOTTOM")) {
3851 Qf = quarks[BOTTOM].getCharge();
3852 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3853 } else
3854 throw std::runtime_error("StandardModel::MLL2eeff: wrong argument");
3855
3856 // LL SM squared amplitude
3857 MLL2SM = Qf * Qf
3858 + (is2c2 * is2c2 * (geLSM * geLSM * gfLSM * gfLSM) * s * s
3859 + 2.0 * Qf * is2c2 * (geLSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3860
3861 return MLL2SM;
3862
3863}

◆ MLR2eeff()

const double StandardModel::MLR2eeff ( const Particle  f,
const double  s 
) const

Definition at line 3709 of file StandardModel/src/StandardModel.cpp.

3709 {
3710
3711 // Definitions
3712 double Qf, geLSM, gfRSM, is2c2, GZ, Mz2s;
3713
3714 double MLR2SM;
3715
3716 // -------------------------------------------
3717
3718 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3719
3720 is2c2 = 1. / s02() / c02();
3721
3722 GZ = Gamma_Z();
3723
3724 Mz2s = Mz * Mz - s;
3725
3726 if (f.is("ELECTRON")) {
3727 Qf = leptons[ELECTRON].getCharge();
3728 gfRSM = - Qf * s02();
3729 } else if (f.is("MU")) {
3730 Qf = leptons[MU].getCharge();
3731 gfRSM = - Qf * s02();
3732 } else if (f.is("TAU")) {
3733 Qf = leptons[TAU].getCharge();
3734 gfRSM = - Qf * s02();
3735 } else if (f.is("UP")) {
3736 Qf = quarks[UP].getCharge();
3737 gfRSM = - Qf * s02();
3738 } else if (f.is("CHARM")) {
3739 Qf = quarks[CHARM].getCharge();
3740 gfRSM = - Qf * s02();
3741 } else if (f.is("DOWN")) {
3742 Qf = quarks[DOWN].getCharge();
3743 gfRSM = - Qf * s02();
3744 } else if (f.is("STRANGE")) {
3745 Qf = quarks[STRANGE].getCharge();
3746 gfRSM = - Qf * s02();
3747 } else if (f.is("BOTTOM")) {
3748 Qf = quarks[BOTTOM].getCharge();
3749 gfRSM = - Qf * s02();
3750 } else
3751 throw std::runtime_error("StandardModel::MLR2eeff: wrong argument");
3752
3753 // LR, RL, LL and RR SM squared amplitudes
3754 MLR2SM = Qf * Qf
3755 + (is2c2 * is2c2 * (geLSM * geLSM * gfRSM * gfRSM) * s * s
3756 + 2.0 * Qf * is2c2 * (geLSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3757
3758 return MLR2SM;
3759}

◆ MRL2eeff()

const double StandardModel::MRL2eeff ( const Particle  f,
const double  s 
) const

Definition at line 3760 of file StandardModel/src/StandardModel.cpp.

3760 {
3761
3762 // Definitions
3763 double Qf, geRSM, gfLSM, is2c2, GZ, Mz2s;
3764
3765 double MRL2SM;
3766
3767 // -------------------------------------------
3768
3769 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3770
3771 is2c2 = 1. / s02() / c02();
3772
3773 GZ = Gamma_Z();
3774
3775 Mz2s = Mz * Mz - s;
3776
3777 if (f.is("ELECTRON")) {
3778 Qf = leptons[ELECTRON].getCharge();
3779 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3780 } else if (f.is("MU")) {
3781 Qf = leptons[MU].getCharge();
3782 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3783 } else if (f.is("TAU")) {
3784 Qf = leptons[TAU].getCharge();
3785 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3786 } else if (f.is("UP")) {
3787 Qf = quarks[UP].getCharge();
3788 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3789 } else if (f.is("CHARM")) {
3790 Qf = quarks[CHARM].getCharge();
3791 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3792 } else if (f.is("DOWN")) {
3793 Qf = quarks[DOWN].getCharge();
3794 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3795 } else if (f.is("STRANGE")) {
3796 Qf = quarks[STRANGE].getCharge();
3797 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3798 } else if (f.is("BOTTOM")) {
3799 Qf = quarks[BOTTOM].getCharge();
3800 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3801 } else
3802 throw std::runtime_error("StandardModel::MRL2eeff: wrong argument");
3803
3804 // RL SM squared amplitude
3805 MRL2SM = Qf * Qf
3806 + (is2c2 * is2c2 * (geRSM * geRSM * gfLSM * gfLSM) * s * s
3807 + 2.0 * Qf * is2c2 * (geRSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3808
3809 return MRL2SM;
3810}

◆ MRR2eeff()

const double StandardModel::MRR2eeff ( const Particle  f,
const double  s,
const double  t 
) const

Definition at line 3864 of file StandardModel/src/StandardModel.cpp.

3864 {
3865
3866 // Definitions
3867 double Qf, geRSM, gfRSM, is2c2, GZ, Mz2s;
3868
3869 double MRR2SM;
3870
3871 // -------------------------------------------
3872
3873 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3874
3875 is2c2 = 1. / s02() / c02();
3876
3877 GZ = Gamma_Z();
3878
3879 Mz2s = Mz * Mz - s;
3880
3881 if (f.is("ELECTRON")) {
3882 Qf = leptons[ELECTRON].getCharge();
3883 gfRSM = - Qf * s02();
3884 } else if (f.is("MU")) {
3885 Qf = leptons[MU].getCharge();
3886 gfRSM = - Qf * s02();
3887 } else if (f.is("TAU")) {
3888 Qf = leptons[TAU].getCharge();
3889 gfRSM = - Qf * s02();
3890 } else if (f.is("UP")) {
3891 Qf = quarks[UP].getCharge();
3892 gfRSM = - Qf * s02();
3893 } else if (f.is("CHARM")) {
3894 Qf = quarks[CHARM].getCharge();
3895 gfRSM = - Qf * s02();
3896 } else if (f.is("DOWN")) {
3897 Qf = quarks[DOWN].getCharge();
3898 gfRSM = - Qf * s02();
3899 } else if (f.is("STRANGE")) {
3900 Qf = quarks[STRANGE].getCharge();
3901 gfRSM = - Qf * s02();
3902 } else if (f.is("BOTTOM")) {
3903 Qf = quarks[BOTTOM].getCharge();
3904 gfRSM = - Qf * s02();
3905 } else
3906 throw std::runtime_error("StandardModel::MRR2eeff: wrong argument");
3907
3908 // RR SM squared amplitude
3909 MRR2SM = Qf * Qf
3910 + (is2c2 * is2c2 * (geRSM * geRSM * gfRSM * gfRSM) * s * s
3911 + 2.0 * Qf * is2c2 * (geRSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3912
3913 return MRR2SM;
3914}

◆ Mw()

const 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 GeorgiMachacek, NPbase, NPEpsilons, NPEpsilons_pureNP, NPSMEFTd6, NPSMEFTd6General, NPZbbbar, SUSY, and THDMW.

Definition at line 1025 of file StandardModel/src/StandardModel.cpp.

1026{
1027 /* Debug */
1028 //std::cout << std::boolalpha
1029 // << checkScheme(schemeMw_cache,schemeMw,false)
1030 // << " [cache:" << schemeMw_cache
1031 // << " current:" << schemeMw << "]" << std::endl;
1032
1033 if (FlagMWinput)
1034 return Mw_inp;
1035
1037 if (useMw_cache)
1038 return Mw_cache;
1039
1040 double Mw;
1041 if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
1043 else {
1044 //std::cout << std::setprecision(12)
1045 // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
1046
1047 double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
1048 ComputeDeltaRho(Mw_tree(), DeltaRho);
1049 ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
1050 Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
1051
1052 /* Mw from iterations */
1053 double Mw_org = Mw_tree();
1054 while (fabs(Mw - Mw_org) > Mw_error) {
1055 Mw_org = Mw;
1056 ComputeDeltaRho(Mw, DeltaRho);
1057 ComputeDeltaR_rem(Mw, DeltaR_rem);
1058 Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
1059 /* TEST */
1060 //int prec_def = std::cout.precision();
1061 //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
1062 // << " Mw_new = " << Mw << std::endl;
1063 //std::cout.precision(prec_def);
1064 }
1065 }
1066
1067// Mw = 80.426; // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
1068// Mw = 80.379; // FOR HEFFDF1 TEST: VALUE IN 2007.04191
1069 Mw_cache = Mw;
1070 useMw_cache = true;
1071 return Mw;
1072}
double Mw() const
The -boson mass with the full two-loop EW corrections.
static const double Mw_error
The target accuracy of the iterative calculation of the -boson mass in units of GeV.
void ComputeDeltaR_rem(const double Mw_i, double DeltaR_rem[orders_EW_size]) const
A method to collect computed via subclasses.
const double Mw_tree() const
The tree-level mass of the boson, .
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 .

◆ Mw_tree()

const double StandardModel::Mw_tree ( ) const

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

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

Definition at line 1003 of file StandardModel/src/StandardModel.cpp.

1004{
1005 if (FlagMWinput){
1006 return Mw_inp;
1007 } else
1008 return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
1009}

◆ MwbarFromMw()

const 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 [Bardin:1988xt] 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 1210 of file StandardModel/src/StandardModel.cpp.

1211{
1212 double AlsMw = Als(Mw, FULLNLO);
1213 double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1214 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1215
1216 return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1217}

◆ MwFromMwbar()

const 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 [Bardin:1988xt], 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 1219 of file StandardModel/src/StandardModel.cpp.

1220{
1221 double AlsMw = Als(Mwbar, FULLNNLO);
1222 double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1223 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1224
1225 return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1226}

◆ 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 [Bardin:1988xt] 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 1193 of file StandardModel/src/StandardModel.cpp.

1194{
1195 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1196 double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1197 double Gz = 6.0 * G0; // neutrinos
1198 Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1199 Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1200 * (1.0 + AlsMz / M_PI); // u and c
1201 Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1202 * (1.0 + AlsMz / M_PI); // d, s and b
1203
1204 //Gz = 2.4952; // experimental data
1205 //std::cout << "Gz=" << Gz << std::endl; // for test
1206
1207 return ( Mz - Gz * Gz / 2.0 / Mz);
1208}

◆ N_nu()

const 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 1562 of file StandardModel/src/StandardModel.cpp.

1563{
1564 double Nnu = 0.0;
1565 double Gl = 0.0;
1566 double Rl = 0.0;
1567
1568 // Don't assume lepton universality: average over lepton flavours
1570 Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1571
1572 Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1573
1574 Nnu = (Gl/Gamma_inv()) * Nnu;
1575
1576 return Nnu;
1577
1578}
virtual const double sigma0_had() const
The hadronic cross section for at the -pole, .
virtual const double R0_f(const Particle f) const
The ratio .

◆ 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 FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, HiggsChiral, HiggsKigen, NPd6SILH, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, NPSMEFTd6MFV, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPZbbbar, NPZbbbarLinearized, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 243 of file StandardModel/src/StandardModel.cpp.

244{
245 if (!QCD::PostUpdate()) return (false);
246
247 SMSuccess = true;
248 /* Set the CKM and PMNS matrices if not already set in the derived classes */
249 if(requireCKM)
250 computeCKM();
251
252 /* Compute the 5-quark contribution to the running of alpha*/
253 dAl5hMz = Dalpha5hMz();
254
255 /* Set the Yukawa matrices */
256 if (!isModelSUSY()) {
258 }
259
260 /* Check whether the parameters for the EWPO are updated or not */
261 if (!checkSMparamsForEWPO()) {
263 useDeltaAlpha_cache = false;
264 useMw_cache = false;
265 useGammaW_cache = false;
266 for (int i = 0; i < 12; ++i) {
267 useRhoZ_f_cache[i] = false;
268 useKappaZ_f_cache[i] = false;
269 }
270 }
272 /* Necessary for updating StandardModel parameters in StandardModelMatching */
273 if (!isModelSUSY()) SMM.getObj().updateSMParameters();
274
275 iterationNo++;
276
277 return (true);
278}
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:379
bool isModelSUSY() const
Definition: Model.h:182
virtual bool PostUpdate()
The post-update method for QCD.
Definition: QCD.cpp:158
virtual void computeCKM()
The method to compute the CKM matrix.
virtual void computeYukawas()
The method to compute the Yukawas matrix.
virtual const double Dalpha5hMz() const
The 5-quark contribution to the running of the em constant to the pole. .
bool checkSMparamsForEWPO()
A method to check whether the parameters relevant to the EWPO are updated.

◆ 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 FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPSMEFTd6General, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 216 of file StandardModel/src/StandardModel.cpp.

217{
218 requireCKM = false;
219 requireYe = false;
220 requireYn = false;
221
222 if (!QCD::PreUpdate()) return (false);
223
224 return (true);
225}
virtual bool PreUpdate()
The pre-update method for QCD.
Definition: QCD.cpp:130

◆ Qwemoller()

const double StandardModel::Qwemoller ( const double  q2,
const double  y 
) const
virtual

The computation of the electron's weak charge.

Parameters
[in]q2the \(Q^2\) at which the weak charge is measured
[in]y
Returns
\(Q_{w}(e)\)

Definition at line 2671 of file StandardModel/src/StandardModel.cpp.

2672{
2673 // Weak charge
2674 double Qwe;
2675
2676 // definitions
2677 double MwSM,f1,fy,f2,af2;
2678 const double mpion=134.9766e-3;
2679
2680 // -----------------------------------------------------------------
2681
2682 double dalfos, dalfms, alfams;
2683 double rhoNC, kappa0, s2MSbar,c2MSbar;
2684 double xi;
2685 double leptk0,quarkk0;
2686 double elm=leptons[ELECTRON].getMass(), mum=leptons[MU].getMass(), taum=leptons[TAU].getMass();
2687
2688 // -----------------------------------------------------------------
2689
2690 // w mass
2691 MwSM=Mw();
2692
2693 // xi factor
2694 xi=mHl*mHl/Mz/Mz;
2695
2696 // -----------------------------------------------------------------
2697
2698 // universal corrections
2699 // ---------------------
2700
2701 // obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2702 // -----------------------------------------------
2703
2704 // on-shell value of delta alpha(mz)
2705 dalfos=1.0-ale/alphaMz();
2706 // msbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2707 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2708 // msbar value of alfa(mz)
2709 alfams=ale/(1.0-dalfms);
2710
2711 // ms bar weinberg's angle from the effective leptonic angle
2712 // (formula from PDG, Erler & Langacker ew review)
2713 // ---------------------------------------------------------
2714 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2715 c2MSbar=1.0-s2MSbar;
2716
2717 // rho parameter (expansion in alfams)
2718 // -------------
2719
2720 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2721
2722 // kappa at zero momentum (expansion in alfa)
2723 // ----------------------
2724
2725 // lepton contribution to kappa0
2726 leptk0=((-0.5)*(-1)-2.0*s2MSbar)*2.0*(log(elm/Mz)+log(mum/Mz)+log(taum/Mz))/3.0;
2727
2728 // quark contribution to kappa0 (updated from hep-ph/0302149)
2729 quarkk0=-6.802;
2730
2731 kappa0=1.0-ale/(2.0*M_PI*s2MSbar)*(leptk0+quarkk0-(7.0*c2MSbar/2.0+1.0/12.0)*log(c2MSbar)+(7.0/9.0-s2MSbar/3.0));
2732
2733 // -----------------------------------------------------------------
2734
2735 // f1(y,q2) (expansion in alfa)
2736 // --------
2737
2738 // f(y)
2739 fy=-2.0*log(y*(1.0-y))/3.0+1.0/pow((1.0-y+y*y),2)*(-2.0*(1.0-y)*(3.0-3.0*y+4.0*y*y*y- 3.0*y*y*y*y)*log(1.0-y)-2.0*y*(1.0+3.0*y-6.0*y*y+8.0*y*y*y-3.0*y*y*y*y)*log(y)+ (1.0-y)*(2.0-2.0*y-7.0*y*y+10.0*y*y*y-8.0*y*y*y*y+3.0*y*y*y*y*y)*log(1.0-y)*log(1.0-y)- y*(2.0-3.0*y-5.0*y*y+8.0*y*y*y-7.0*y*y*y*y+3.0*y*y*y*y*y)*log(y)*log(y)+ (2.0-4.0*y+11.0*y*y*y-13.0*y*y*y*y+9.0*y*y*y*y*y-3.0*y*y*y*y*y*y)*(M_PI*M_PI-2.0*log(1.0-y)*log(y)));
2740
2741 f1=-ale/(4.0*M_PI)*(1.0-4.0*kappa0*s2MSbar)*(22.0*log(y*Mz*Mz/q2)/3.0+85.0/9.0+fy);
2742
2743 // note that i have used 1-4*kappa*s2MSbar instead of 1-4*s2MSbar or an average as suggested in the
2744 // reference
2745
2746
2747 // f2(y,q2) (expansion in alfa)
2748 // --------
2749 // (y=1/2 approximattion using a pion loop calculation)
2750
2751 // af2
2752 af2=sqrt(1.0+4.0*mpion*mpion/q2);
2753 f2=ale/(4.0*M_PI)*(af2*af2*af2/3.0*log((af2+1.0)/(af2-1.0))-2.0/9.0-2.0*af2*af2/3.0);
2754
2755
2756 // electron's weak charge
2757 // ----------------------
2758 Qwe=-rhoNC*(1.0-4.0*kappa0*s2MSbar+alfams/(4.0*M_PI*s2MSbar)+f1+f2- 3.0*alfams*(1.0-4.0*kappa0*s2MSbar)*(1.0+(1.0-4.0*kappa0*s2MSbar)*(1.0-4.0*kappa0*s2MSbar))/(32.0*M_PI*s2MSbar*c2MSbar));
2759
2760 // again, i have used 1-4*kappa*s2MSbar even in the loop contributions
2761
2762 return Qwe;
2763}
A class for , relevant for mesons mixing in the Standard Model.
Definition: xi.h:23

◆ Qwn()

const double StandardModel::Qwn ( ) const
virtual

The computation of the neutron weak charge: Qwn.

Follows J.Erler,A.Kurylov,M.J.Ramsey-Musolf hep-ph/0302149.

Returns
\(Q_{W}(n)\)

Definition at line 2895 of file StandardModel/src/StandardModel.cpp.

2896{
2897 // Definitions
2898 double qwneutron;
2899
2900 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxnww,boxnzz,boxnaz;
2901 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2902 const double lambda=775.49e-3;
2903 const double caz=1.5;
2904
2905 // lepton masses
2906 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2907
2908 // -----------------------------------------------------------------
2909 double dalfos, dalfms, alfams;
2910 double rhoNC, s2MSbar,c2MSbar;
2911 double xi;
2912 double elm=leptons[ELECTRON].getMass();
2913 // -----------------------------------------------------------------
2914
2915 // W mass
2916 MwSM=Mw();
2917
2918 // xi factor
2919 xi=mHl*mHl/Mz/Mz;
2920
2921 // alfa/pi
2922 alfapi=ale/M_PI;
2923
2924 // alfa_s(Mw)
2925 asMw = Als(MwSM, FULLNLO);
2926
2927 // -----------------------------------------------------------------
2928
2929 // Universal corrections
2930 // ---------------------
2931
2932 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2933 // -----------------------------------------------
2934
2935 // on-shell value of delta alpha(mz)
2936 dalfos=1.0-ale/alphaMz();
2937 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2938 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2939 // MSbar value of alfa(mz)
2940 alfams=ale/(1.0-dalfms);
2941
2942 // MS bar weinberg's angle from the effective leptonic angle
2943 // (formula from PDG, Erler & Langacker ew review)
2944 // ---------------------------------------------------------
2945 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2946 c2MSbar=1.0-s2MSbar;
2947
2948 // rho parameter (expansion in alfams)
2949 // -------------
2950
2951 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2952
2953 // -----------------------------------------------------------------
2954
2955 // sin2w_ms(0) eq.14
2956 // -----------------
2957
2958 // hadronic contribution
2959 dkappa5h=7.9e-3;
2960
2961 s2MSbar0=0.0;
2962
2963 for (int i = 0; i < 3; ++i) {
2964 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2965 }
2966
2967 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2968
2969 // -----------------------------------------------------------------
2970
2971 // external leg corrections
2972
2973 deltae=-0.5*alfapi;
2974
2975 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2976
2977 // -----------------------------------------------------------------
2978
2979 // boxes
2980 // -----
2981
2982 boxnww=alfams*(-2.0+4.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2983
2984 // pure zz and az boxes from prd 17 3055 app.a
2985
2986 boxnzz=alfams*(9.0/4.0-13.0*s2MSbar+34.0*s2MSbar*s2MSbar-32.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2987
2988 // i assumme the same caz as in the proton enters for the neutron
2989 boxnaz=alfams*(4.0-16.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2990
2991 // -----------------------------------------------------------------
2992
2993 // weak charges
2994 // ------------
2995
2996 qwneutron=-(rhoNC+deltae)*(1.0+deltaep)+boxnww+boxnzz+boxnaz;
2997
2998 return qwneutron;
2999
3000}
An observable class for the relative deviation from the SM of the EM coupling .

◆ Qwp()

const double StandardModel::Qwp ( ) const
virtual

The computation of the proton weak charge: Qwp.

Follows J.Erler,A.Kurylov,M.J.Ramsey-Musolf hep-ph/0302149.

Returns
\(Q_{W}(p)\)

Definition at line 2787 of file StandardModel/src/StandardModel.cpp.

2788{
2789 // Definitions
2790 double qwproton;
2791
2792 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxpww,boxpzz,boxpaz;
2793 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2794 const double lambda=775.49e-3;
2795 const double caz=1.5;
2796
2797 // lepton masses
2798 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2799
2800 // -----------------------------------------------------------------
2801 double dalfos, dalfms, alfams;
2802 double rhoNC, s2MSbar,c2MSbar;
2803 double xi;
2804 double elm=leptons[ELECTRON].getMass();
2805 // -----------------------------------------------------------------
2806
2807 // W mass
2808 MwSM=Mw();
2809
2810 // xi factor
2811 xi=mHl*mHl/Mz/Mz;
2812
2813 // alfa/pi
2814 alfapi=ale/M_PI;
2815
2816 // alfa_s(Mw)
2817 asMw = Als(MwSM, FULLNLO);
2818
2819 // -----------------------------------------------------------------
2820
2821 // Universal corrections
2822 // ---------------------
2823
2824 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2825 // -----------------------------------------------
2826
2827 // on-shell value of delta alpha(mz)
2828 dalfos=1.0-ale/alphaMz();
2829 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2830 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2831 // MSbar value of alfa(mz)
2832 alfams=ale/(1.0-dalfms);
2833
2834 // MS bar weinberg's angle from the effective leptonic angle
2835 // (formula from PDG, Erler & Langacker ew review)
2836 // ---------------------------------------------------------
2837 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2838 c2MSbar=1.0-s2MSbar;
2839
2840 // rho parameter (expansion in alfams)
2841 // -------------
2842
2843 rhoNC=1.0+alfams/(4.0*M_PI)*(3.0/(4.0*s2MSbar*s2MSbar)*log(c2MSbar)-7.0/(4.0*s2MSbar)+3.0*mtpole*mtpole/(4.0*s2MSbar*MwSM*MwSM) + 3.0*xi/(4.0*s2MSbar)*(log(c2MSbar/xi)/(c2MSbar-xi)+(1.0/c2MSbar)*log(xi)/(1.0-xi)));
2844
2845 // -----------------------------------------------------------------
2846
2847 // sin2w_ms(0) eq.14
2848 // -----------------
2849
2850 // hadronic contribution
2851 dkappa5h=7.9e-3;
2852
2853 s2MSbar0=0.0;
2854
2855 for (int i = 0; i < 3; ++i) {
2856 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2857 }
2858
2859 s2MSbar0=s2MSbar+dkappa5h+alfapi*((s2MSbar0*(1.0+0.75*alfapi)+135.0*alfapi/32.0)*(1.0-4.0*s2MSbar)/12.0- (7.0*c2MSbar/4.0+1.0/24.0)*2.0*log(Mz/MwSM)+s2MSbar/6.0-7.0/18.0);
2860
2861 // -----------------------------------------------------------------
2862
2863 // external leg corrections
2864
2865 deltae=-0.5*alfapi;
2866
2867 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2868
2869 // -----------------------------------------------------------------
2870
2871 // boxes
2872 // -----
2873
2874 boxpww=alfams*(2.0+5.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2875
2876 // pure zz and az boxes from prd 17 3055 app.a
2877
2878 boxpzz=alfams*(9.0/4.0-14.0*s2MSbar+38.0*s2MSbar*s2MSbar-40.0*s2MSbar*s2MSbar*s2MSbar)*(1.0-AlsMz/M_PI)/(4.0*M_PI*s2MSbar*c2MSbar);
2879
2880 boxpaz=5.0*alfams*(1.0-4.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2881
2882 // i assumme the same caz as in the proton enters for the neutron
2883 // -----------------------------------------------------------------
2884
2885 // weak charges
2886 // ------------
2887
2888 qwproton=(rhoNC+deltae)*(1.0-4.0*s2MSbar0+deltaep)+boxpww+boxpzz+boxpaz;
2889
2890 return qwproton;
2891
2892}

◆ R0_f()

const 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 NPbase, NPSMEFTd6General, NPZbbbar, and NPEpsilons.

Definition at line 1485 of file StandardModel/src/StandardModel.cpp.

1486{
1487
1488 if (f.is("ELECTRON")) {
1490 /* SM contribution with the approximate formula */
1491 return (myApproximateFormulae->X_full("R0_electron"));
1492 else
1493 return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1494 } else if (f.is("MU")) {
1496 /* SM contribution with the approximate formula */
1497 return (myApproximateFormulae->X_full("R0_muon"));
1498 else
1499 return (Gamma_had() / GammaZ(leptons[MU]));
1500 } else if (f.is("TAU")) {
1502 /* SM contribution with the approximate formula */
1503 return (myApproximateFormulae->X_full("R0_tau"));
1504 else
1505 return (Gamma_had() / GammaZ(leptons[TAU]));
1506 } else if (f.is("NEUTRINO_1")) {
1508 /* SM contribution with the approximate formula */
1509 return (myApproximateFormulae->X_full("R0_neutrino"));
1510 else
1511 return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1512 } else if (f.is("NEUTRINO_2")) {
1514 /* SM contribution with the approximate formula */
1515 return (myApproximateFormulae->X_full("R0_neutrino"));
1516 else
1517 return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1518 } else if (f.is("NEUTRINO_3")) {
1520 /* SM contribution with the approximate formula */
1521 return (myApproximateFormulae->X_full("R0_neutrino"));
1522 else
1523 return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1524 } else if (f.is("UP")) {
1526 /* SM contribution with the approximate formula */
1527 return (myApproximateFormulae->X_full("R0_up"));
1528 else
1529 return (GammaZ(quarks[UP]) / Gamma_had());
1530
1531 } else if (f.is("STRANGE")) {
1533 /* SM contribution with the approximate formula */
1534 return (myApproximateFormulae->X_full("R0_strange"));
1535 else
1536 return (GammaZ(quarks[STRANGE]) / Gamma_had());
1537
1538 } else if (f.is("CHARM")) {
1540 /* SM contribution with the approximate formula */
1541 return (myApproximateFormulae->X_full("R0_charm"));
1542 else
1543 return (GammaZ(quarks[CHARM]) / Gamma_had());
1544
1545 } else if (f.is("BOTTOM")) {
1547 /* SM contribution with the approximate formula */
1548 return (myApproximateFormulae->X_full("R0_bottom"));
1549 else
1550 return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1551
1552 } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1553
1554}

◆ R_inv()

const 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 1556 of file StandardModel/src/StandardModel.cpp.

1557{
1558 return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1559
1560}

◆ 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 [Chetyrkin:1994js], [Bardin:1999ak], [Bardin:1999yd], [Baikov:2012er] and references therein.

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

Definition at line 2277 of file StandardModel/src/StandardModel.cpp.

2278{
2279 if (q == QCD::TOP) return 0.0;
2280
2281 double mcMz, mbMz;
2284 //mcMz = 0.56381685; /* for debug */
2285 //mbMz = 2.8194352; /* for debug */
2286
2287 double MtPole = mtpole;
2288
2289 /* z-component of isospin */
2290 double I3q = quarks[q].getIsospin();
2291 /* electric charge squared */
2292 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2293
2294 /* s = Mz^2 */
2295 double s = Mz * Mz;
2296
2297 /* products of the charm and bottom masses at Mz */
2298 double mcMz2 = mcMz*mcMz;
2299 double mbMz2 = mbMz*mbMz;
2300 double mqMz2, mqdash4;
2301 switch (q) {
2302 case QCD::CHARM:
2303 mqMz2 = mcMz*mcMz;
2304 mqdash4 = mbMz2*mbMz2;
2305 break;
2306 case QCD::BOTTOM:
2307 mqMz2 = mbMz*mbMz;
2308 mqdash4 = mcMz2*mcMz2;
2309 break;
2310 default:
2311 mqMz2 = 0.0;
2312 mqdash4 = 0.0;
2313 break;
2314 }
2315
2316 /* Logarithms */
2317 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2318 double log_t = log(MtPole * MtPole / s); // the pole mass
2319 double log_c = log(mcMz2 / s);
2320 double log_b = log(mbMz2 / s);
2321 double log_q;
2322 switch (q) {
2323 case QCD::CHARM:
2324 case QCD::BOTTOM:
2325 log_q = log(mqMz2 / s);
2326 break;
2327 default:
2328 log_q = 0.0;
2329 break;
2330 }
2331
2332 /* the active number of flavour */
2333 double nf = 5.0;
2334
2335 /* zeta functions */
2336 double zeta2 = getMyEWSMcache()->getZeta2();
2337 double zeta3 = getMyEWSMcache()->getZeta3();
2338 double zeta4 = getMyEWSMcache()->getZeta4();
2339 double zeta5 = getMyEWSMcache()->getZeta5();
2340
2341 /* massless non-singlet corrections */
2342 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2343 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2344 + 275.0 / 6.0 * zeta5
2345 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2346 - 25.0 / 9.0 * zeta5) * nf
2347 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2348 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2349 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2350 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2351 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2352
2353 /* quadratic massive corrections */
2354 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2355 double C20A = -6.0;
2356 double C21A = -22.0;
2357 double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2358 + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2359 double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2360 - 127.0 * zeta5
2361 + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2362 + 5.0 * zeta4 + 55.0 * zeta5) * nf
2363 + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2364
2365 /* quartic massive corrections */
2366 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2367 double C40A = 6.0;
2368 double C41A = 10.0;
2369 double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2370 + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2371 double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2372
2373 /* power suppressed top-mass correction */
2374 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2375 double xt = s / MtPole / MtPole; // the pole mass
2376 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2377
2378 /* singlet axial-vector corrections */
2379 double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2380 double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2381 + 23.0 / 12.0 * log_t*log_t;
2382 double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2383 + 3.6736 * (-log_t * log_t * log_t);
2384
2385 /* rescaled strong coupling constant */
2386 double AlsMzPi = AlsMz / M_PI;
2387 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2388 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2389 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2390
2391 /* electromagnetic coupling at Mz */
2392 double alpMz = alphaMz();
2393
2394 /* radiator function to the axial-vector current */
2395 double RAf;
2396 RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2397 + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2398 + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2399 + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2400 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2401 + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2402 + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2403 //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2404 - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2405 * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2406 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2407 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2408 + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2409 + (C42A + C42AL * log_q) * AlsMzPi2)
2410 - 12.0 * mqdash4 / s / s*AlsMzPi2;
2411 return RAf;
2412}
double getZeta4() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:155
double getZeta5() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:164
double getZeta3() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:146
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
double getZeta2() const
A get method to access the value of the zeta function .
Definition: EWSMcache.h:137
double zeta2
computed with the GSL.
Definition: QCD.h:1032
EWSMcache * getMyEWSMcache() const
A get method to retrieve the member pointer of type EWSMcache.

◆ 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 [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), 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 2042 of file StandardModel/src/StandardModel.cpp.

2045{
2046 if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2047 || (deltaKappa_rem[EW2QCD1] != 0.0)
2048 || (deltaKappa_rem[EW3] != 0.0))
2049 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2050
2051 if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2052 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2053
2054 double Mw_TMP = Mw();
2055 double cW2_TMP = cW2();
2056 double sW2_TMP = sW2();
2057
2058 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2059 double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2060 // conversion: alpha(0) --> G_F
2061 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2062 * sW2_TMP * cW2_TMP / M_PI / ale;
2063 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2064 + f_AlphaToGF * DeltaRho[EW1QCD1]
2065 + f_AlphaToGF * DeltaRho[EW1QCD2]
2066 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2067 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2068 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2069 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2070 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2071 deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2072 + deltaKappa_rem[EW1QCD1]
2073 + deltaKappa_rem[EW1QCD2]);
2074 deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2075
2076 /* Real parts */
2077 double kappaZ;
2078 if (!bool_Zbb) {
2079 if (FlagKappaZ.compare("OMSI") == 0) {
2080 kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2081 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2082 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2083 kappaZ = (1.0 + deltaKappa_rem_G)
2084 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2085 + deltaKappa_rem_G2;
2086 } else if (FlagKappaZ.compare("NORESUM") == 0
2087 || FlagKappaZ.compare("OMSII") == 0) {
2088 kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2089 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2090 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2091 + deltaKappa_rem_G2;
2092 } else
2093 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2094 } else {
2095 /* Z to bb */
2096 double OnePlusTaub = 1.0 + taub();
2097 double kappaZbL;
2098 deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2099 * pow(mtpole / Mw_TMP, 2.0);
2100 if (FlagKappaZ.compare("NORESUM") == 0) {
2101 kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2102 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2103 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2104 + deltaKappa_rem_G2) / OnePlusTaub;
2105 } else if (FlagKappaZ.compare("OMSI") == 0) {
2106 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2107 kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2108 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2109 || FlagKappaZ.compare("OMSII") == 0) {
2110 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2111 kappaZ = kappaZbL + deltaKappa_rem_G;
2112 } else
2113 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2114 }
2115
2116 return kappaZ;
2117}
double taub() const
Top-mass corrections to the vertex, denoted by .

◆ 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 [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), 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 1876 of file StandardModel/src/StandardModel.cpp.

1878{
1879 if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1880 || (DeltaR_rem[EW2QCD1] != 0.0)
1881 || (DeltaR_rem[EW3] != 0.0))
1882 throw std::runtime_error("Error in StandardModel::resumMw()");
1883
1884 if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1885 throw std::runtime_error("Error in StandardModel::resumMw()");
1886
1887 double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1888 double sW2_TMP = 1.0 - cW2_TMP;
1889
1890 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1891 if (FlagMw.compare("NORESUM") == 0) {
1892 for (int j = 0; j < orders_EW_size; ++j) {
1893 DeltaRho_sum += DeltaRho[(orders_EW) j];
1894 }
1895 } else {
1896 // conversion: alpha(0) --> G_F
1897 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1898 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1899 + f_AlphaToGF * DeltaRho[EW1QCD1]
1900 + f_AlphaToGF * DeltaRho[EW1QCD2]
1901 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1902 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1903 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1904 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1905 }
1906
1907 double R;
1908 double DeltaR_rem_sum = 0.0;
1909 double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1910 if (FlagMw.compare("NORESUM") == 0) {
1911 for (int j = 0; j < orders_EW_size; ++j)
1912 DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1913
1914 // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1915 DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1916
1917 // Full EW two-loop contribution without reducible corrections
1918 DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1919
1920 // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1921 DeltaRho_sum -= DeltaRho[EW2];
1922 DeltaR_rem_sum -= DeltaR_rem[EW2];
1923
1924 // R = 1 + Delta r, including the full EW two-loop contribution
1925 R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1926 + DeltaR_rem_sum;
1927 R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1928 + DeltaR_EW2_rem;
1929 } else if (FlagMw.compare("OMSI") == 0) {
1930 // R = 1/(1 - Delta r)
1931 R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1932 / (1.0 - DeltaAlphaL5q()
1933 - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1934 } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1935 // R = 1/(1 - Delta r)
1936 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1937 *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1938 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1939 } else if (FlagMw.compare("OMSII") == 0) {
1940 // R = 1/(1 - Delta r)
1941 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1942 - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1943 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1944 } else
1945 throw std::runtime_error("Error in StandardModel::resumMw()");
1946
1947 if (FlagMw.compare("NORESUM") == 0) {
1948 /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1949
1950 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1951 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1952 double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1953
1954 return MwFromMwbar(Mwbar);
1955 } else {
1956 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1957 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1958
1959 return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1960 }
1961}
double DeltaR_TwoLoopEW_rem(const double Mw_i) const
.
const 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...
orders_EW
An enumerated type representing perturbative orders of radiative corrections to EW precision observab...

◆ 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 [Bardin:1999yd] (see also [Degrassi:1996mg], [Degrassi:1996ps], [Degrassi:1999jd], [Bardin:1999ak]), 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 1963 of file StandardModel/src/StandardModel.cpp.

1966{
1967 if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1968 || (deltaRho_rem[EW1QCD2] != 0.0)
1969 || (deltaRho_rem[EW2QCD1] != 0.0)
1970 || (deltaRho_rem[EW3] != 0.0))
1971 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1972
1973 if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1974 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1975
1976 double Mw_TMP = Mw();
1977 double cW2_TMP = cW2();
1978 double sW2_TMP = sW2();
1979
1980 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1981 double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1982 // conversion: alpha(0) --> G_F
1983 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1984 * sW2_TMP * cW2_TMP / M_PI / ale;
1985 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1986 + f_AlphaToGF * DeltaRho[EW1QCD1]
1987 + f_AlphaToGF * DeltaRho[EW1QCD2]
1988 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1989 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1990 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1991 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1992 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1993 deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1994 + deltaRho_rem[EW1QCD1]);
1995 deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1996
1997 /* Real parts */
1998 double rhoZ;
1999 if (!bool_Zbb) {
2000 if (FlagRhoZ.compare("OMSI") == 0) {
2001 rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
2002 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2003 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2004 rhoZ = (1.0 + deltaRho_rem_G)
2005 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2006 + deltaRho_rem_G2;
2007 } else if (FlagRhoZ.compare("NORESUM") == 0
2008 || FlagRhoZ.compare("OMSII") == 0) {
2009 rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2010 + DeltaRho_G * DeltaRho_G
2011 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
2012 } else
2013 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2014 } else {
2015 /* Z to bb */
2016 double OnePlusTaub = 1.0 + taub();
2017 double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
2018 double rhoZbL;
2019 deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
2020 * pow(mtpole / Mw_TMP, 2.0);
2021 if (FlagRhoZ.compare("NORESUM") == 0) {
2022 rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2023 + DeltaRho_G * DeltaRho_G
2024 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
2025 * OnePlusTaub2;
2026 } else if (FlagRhoZ.compare("OMSI") == 0) {
2027 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2028 rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
2029 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2030 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2031 rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
2032 } else if (FlagRhoZ.compare("OMSII") == 0) {
2033 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2034 rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
2035 } else
2036 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2037 }
2038
2039 return rhoZ;
2040}

◆ rho_GammaW()

const 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 1240 of file StandardModel/src/StandardModel.cpp.

1241{
1242 double rhoW = 0.0;
1243 if (flag_order[EW1])
1244 rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1245 return rhoW;
1246}
double rho_GammaW(const Particle fi, const Particle fj, const double Mw_i) const
EW radiative corrections to the width of , denoted as .

◆ rhoZ_f()

const 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 NPbase, and NPEpsilons.

Definition at line 1594 of file StandardModel/src/StandardModel.cpp.

1595{
1596 if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1597 if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1598 throw std::runtime_error("No approximate formula is available for rhoZ^f");
1599 else {
1600
1602 if (useRhoZ_f_cache[f.getIndex()])
1603 return rhoZ_f_cache[f.getIndex()];
1604
1605 double myMw = Mw();
1606
1607 /* compute Delta rho */
1608 double DeltaRho[orders_EW_size];
1609 ComputeDeltaRho(myMw, DeltaRho);
1610
1611 /* compute delta rho_rem^f */
1612 gslpp::complex deltaRho_remf[orders_EW_size];
1613 deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1614 deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1615 deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1616 deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1617 deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1618 deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1619 if (flag_order[EW1])
1620 deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1621 if (flag_order[EW1QCD1])
1622#ifdef WITHIMTWOLOOPQCD
1623 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1624 myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1625#else
1626 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1627#endif
1628 if (flag_order[EW1QCD2])
1629 deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1630 if (flag_order[EW2])
1631 deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1632 if (flag_order[EW2QCD1])
1633 deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1634 if (flag_order[EW3])
1635 deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1636
1637 /* compute Delta rbar_rem */
1638 double DeltaRbar_rem = 0.0;
1639 if (flag_order[EW1])
1640 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1641
1642 /* Re[rho_Z^f] with or without resummation */
1643 double deltaRho_rem_f_real[orders_EW_size];
1644 for (int j = 0; j < orders_EW_size; ++j)
1645 deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1646 double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1647
1648 /* Im[rho_Z^f] without resummation */
1649 double ImRhoZf = 0.0;
1650 for (int j = 0; j < orders_EW_size; ++j)
1651 ImRhoZf += deltaRho_remf[j].imag();
1652
1653 rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1654 useRhoZ_f_cache[f.getIndex()] = true;
1655 return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1656 }
1657}
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
gslpp::complex deltaRho_rem_f(const Particle f, const double Mw_i) const
Remainder contribution of to the effective couplings , denoted as .
std::string getName() const
Definition: Particle.h:147
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 .

◆ Ruc()

const double StandardModel::Ruc ( ) const
virtual

Reimplemented in NPbase.

Definition at line 1323 of file StandardModel/src/StandardModel.cpp.

1324{
1325 return 0.5 * ( R0_f(quarks[UP]) + R0_f(quarks[CHARM]) );
1326}

◆ 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 [Chetyrkin:1994js], [Baikov:2012er], which is much smaller than the other corrections.

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

Returns
\(R_V^h\)

Definition at line 2414 of file StandardModel/src/StandardModel.cpp.

2415{
2416 /* rescaled strong coupling constant */
2417 double AlsMzPi = AlsMz / M_PI;
2418 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2419 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2420 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2421
2422 gslpp::complex gV_sum(0.0, 0.0);
2423 gslpp::complex gV_q;
2424 for (int q = 0; q < 6; q++) {
2425 gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2426 if (q == (int) (QCD::TOP))
2427 gV_q = 0.0;
2428 gV_sum += gV_q;
2429 }
2430
2431 // singlet vector corrections
2432 return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2433}

◆ 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 [Chetyrkin:1994js], [Bardin:1999ak], [Bardin:1999yd] and references therein.

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

Definition at line 2157 of file StandardModel/src/StandardModel.cpp.

2158{
2159 if (q == QCD::TOP) return 0.0;
2160
2161 double mcMz, mbMz;
2164 //mcMz = 0.56381685; /* for debug */
2165 //mbMz = 2.8194352; /* for debug */
2166
2167 double MtPole = mtpole;
2168
2169 /* electric charge squared */
2170 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2171
2172 /* s = Mz^2 */
2173 double s = Mz * Mz;
2174
2175 /* products of the charm and bottom masses at Mz */
2176 double mcMz2 = mcMz*mcMz;
2177 double mbMz2 = mbMz*mbMz;
2178 double mqMz2, mqdash4;
2179 switch (q) {
2180 case QCD::CHARM:
2181 mqMz2 = mcMz*mcMz;
2182 mqdash4 = mbMz2*mbMz2;
2183 break;
2184 case QCD::BOTTOM:
2185 mqMz2 = mbMz*mbMz;
2186 mqdash4 = mcMz2*mcMz2;
2187 break;
2188 default:
2189 mqMz2 = 0.0;
2190 mqdash4 = 0.0;
2191 break;
2192 }
2193
2194 /* Logarithms */
2195 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2196 double log_t = log(MtPole * MtPole / s); // the pole mass
2197 double log_c = log(mcMz2 / s);
2198 double log_b = log(mbMz2 / s);
2199 double log_q;
2200 switch (q) {
2201 case QCD::CHARM:
2202 case QCD::BOTTOM:
2203 log_q = log(mqMz2 / s);
2204 break;
2205 default:
2206 log_q = 0.0;
2207 break;
2208 }
2209
2210 /* the active number of flavour */
2211 double nf = 5.0;
2212
2213 /* zeta functions */
2214 double zeta2 = getMyEWSMcache()->getZeta2();
2215 double zeta3 = getMyEWSMcache()->getZeta3();
2216 //double zeta4 = getMyCache()->GetZeta4();
2217 double zeta5 = getMyEWSMcache()->getZeta5();
2218
2219 /* massless non-singlet corrections */
2220 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2221 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2222 + 275.0 / 6.0 * zeta5
2223 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2224 - 25.0 / 9.0 * zeta5) * nf
2225 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2226 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2227 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2228 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2229 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2230
2231 /* quadratic massive corrections */
2232 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2233 double C21V = 12.0;
2234 double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2235 double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2236 + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2237 + 1045.0 / 27.0 * zeta5) * nf
2238 + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2239
2240 /* quartic massive corrections */
2241 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2242 double C40V = -6.0;
2243 double C41V = -22.0;
2244 double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2245 + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2246 double C42VL = -11.0 / 2.0 + nf / 3.0;
2247
2248 /* power suppressed top-mass correction */
2249 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2250 double xt = s / MtPole / MtPole; // the pole mass
2251 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2252
2253 /* rescaled strong coupling constant */
2254 double AlsMzPi = AlsMz / M_PI;
2255 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2256 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2257 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2258
2259 /* electromagnetic coupling at Mz */
2260 double alpMz = alphaMz();
2261
2262 /* radiator function to the vector current */
2263 double RVf;
2264 RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2265 + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2266 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2267 + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2268 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2269 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2270 + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2271 + 12.0 * mqdash4 / s / s * AlsMzPi2
2272 - mqMz2 * mqMz2 * mqMz2 / s / s / s
2273 * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2274 return RVf;
2275}

◆ RWc()

const double StandardModel::RWc ( ) const
virtual

The ratio \(R_{W,c)=\Gamma(W\to c + X)/\Gamma(W\to had)\).

Returns
\(R_{W,c)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1328 of file StandardModel/src/StandardModel.cpp.

1329{
1330 double GammWcX, GammWhad;
1331
1332// Add all the W-> cX decays
1333// In GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
1334 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
1335
1336// For the same reasons, I only need to add the W-> ud decays into the hadronic part
1337 GammWhad = GammWcX
1338 + GammaW(quarks[UP], quarks[DOWN]);
1339
1340 return GammWcX/GammWhad;
1341}

◆ RWlilj()

const double StandardModel::RWlilj ( const Particle  li,
const Particle  lj 
) const
virtual

The lepton universality ratio \(R_{W,l_i/l_j)=\Gamma(W\to l_i \nu_i)/\Gamma(W\to l_j \nu_j)\).

Returns
\(R_{W,l_i/l_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1298 of file StandardModel/src/StandardModel.cpp.

1299{
1300 double GammWli, GammWlj;
1301
1302 if (li.is("ELECTRON"))
1303 GammWli = GammaW(leptons[NEUTRINO_1],li);
1304 else if (li.is("MU"))
1305 GammWli = GammaW(leptons[NEUTRINO_2],li);
1306 else if (li.is("TAU"))
1307 GammWli = GammaW(leptons[NEUTRINO_3],li);
1308 else
1309 throw std::runtime_error("Error in StandardModel::RWlilj. li must be a charged lepton");
1310
1311 if (lj.is("ELECTRON"))
1312 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
1313 else if (lj.is("MU"))
1314 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
1315 else if (lj.is("TAU"))
1316 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
1317 else
1318 throw std::runtime_error("Error in StandardModel::RWlilj. lj must be a charged lepton");
1319
1320 return GammWli/GammWlj;
1321}

◆ RZlilj()

const double StandardModel::RZlilj ( const Particle  li,
const Particle  lj 
) const
virtual

The lepton universality ratio \(R_{Z,l_i/l_j)=\Gamma(Z\to l_i^+ l_i^-)/\Gamma(Z\to l_j^+ l_j^-)\).

Returns
\(R_{Z,l_i/l_j)\) in GeV

Reimplemented in NPbase, NPSMEFTd6, and NPSMEFTd6General.

Definition at line 1453 of file StandardModel/src/StandardModel.cpp.

1454{
1455 double GammZli, GammZlj;
1456
1457 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
1458 GammZli = GammaZ(li);
1459 else
1460 throw std::runtime_error("Error in StandardModel::RZlilj. li must be a charged lepton");
1461
1462 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
1463 GammZlj = GammaZ(lj);
1464 else
1465 throw std::runtime_error("Error in StandardModel::RZlilj. lj must be a charged lepton");
1466
1467 return GammZli/GammZlj;
1468}

◆ s02()

const 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 [Altarelli:1990zd] and [Altarelli:1991fk].

Returns
\(s_0^2\)

Definition at line 1011 of file StandardModel/src/StandardModel.cpp.

1012{
1013 double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
1014 if (tmp < 0.0)
1015 throw std::runtime_error("Error in s02()");
1016
1017 return ( (1.0 - sqrt(tmp)) / 2.0);
1018}

◆ 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 3531 of file StandardModel.h.

3532 {
3533 if (scheme.compare("NORESUM") == 0)
3534 return 0.0;
3535 else if (scheme.compare("OMSI") == 0)
3536 return 1.0;
3537 else if (scheme.compare("INTERMEDIATE") == 0)
3538 return 2.0;
3539 else if (scheme.compare("OMSII") == 0)
3540 return 3.0;
3541 else if (scheme.compare("APPROXIMATEFORMULA") == 0)
3542 return 4.0;
3543 else
3544 throw std::runtime_error("EWSM::SchemeToDouble: bad scheme");
3545 }

◆ setCKM()

void StandardModel::setCKM ( const CKM CKMMatrix)
inline

A set method to change the CKM matrix.

Parameters
[in]CKMMatrixa reference to the new CKM matrix

Definition at line 3360 of file StandardModel.h.

3361 {
3362 myCKM = CKMMatrix;
3363 }

◆ 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 FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, HiggsChiral, HiggsKigen, NPbase, NPd6SILH, NPEpsilons, NPSMEFTd6, NPSMEFTd6General, THDM, GeorgiMachacek, LeftRightSymmetricModel, NPSMEFT6dtopquark, and SUSY.

Definition at line 449 of file StandardModel/src/StandardModel.cpp.

450{
451 bool res = false;
452 if (name.compare("CacheInStandardModel") == 0) {
454 res = true;
455 } else if (name.compare("CacheInEWSMcache") == 0) {
457 res = true;
458 } else if (name.compare("Wolfenstein") == 0) {
459 FlagWolfenstein = value;
460 if(!FlagWolfenstein) {
461 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
462 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
463 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
464 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
465
466 ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
467 ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
468 ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
469 ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
470 }
471 res = true;
472 } else if (name.compare("WithoutNonUniversalVC") == 0) {
474 res = true;
475 } else if (name.compare("NoApproximateGammaZ") == 0) {
477 res = true;
478 } else if (name.compare("MWinput") == 0) {
479 FlagMWinput = value;
480 if (FlagMWinput) {
481 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"dAle5Mz"))] = "Mw_inp";
482 ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
483 // Point the different flags towards the approximate formulae, when available
485 FlagMw = "APPROXIMATEFORMULA";
486 FlagRhoZ = "NORESUM";
487 FlagKappaZ = "APPROXIMATEFORMULA";
488 }
489 res = true;
490 } else if (name.compare("SMAux") == 0) {
491 FlagSMAux = value;
492 res = true;
493 } else if (name.compare("FixMuwMut") == 0) {
494 FlagFixMuwMut = value;
495 res = true;
496 } else if (name.compare("UseVud") == 0) {
497 FlagUseVud = value;
499 throw std::runtime_error("UseVud can only be used when Wolfenstein is false");
500 else if(FlagUseVud) {
501 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"V_us"))] = "V_ud";
502 ModelParamMap.erase("V_us");
503 ModelParamMap.insert(std::make_pair("V_ud", std::cref(Vud)));
504 }
505 res = true;
506 } else
507 res = QCD::setFlag(name, value);
508
509 if (!res) res = SMFlavour.setFlag(name, value);
510
511 return (res);
512}
void setFlagCacheInEWSMcache(bool FlagCacheInEWSMcache)
A set method to change the model flag CacheInEWSMcache in StandardModel.
Definition: EWSMcache.h:83
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:38
std::string name
The name of the model.
Definition: Model.h:285
virtual bool setFlag(const std::string name, const bool value)
A method to set a flag of QCD.
Definition: QCD.cpp:479
void setFlagCacheInStandardModel(bool FlagCacheInStandardModel)
A set method to change the model flag CacheInStandardModel of StandardModel.

◆ 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 742 of file StandardModel.h.

◆ setFlagNoApproximateGammaZ()

void StandardModel::setFlagNoApproximateGammaZ ( bool  FlagNoApproximateGammaZ)
inline

Definition at line 696 of file StandardModel.h.

◆ setFlagSigmaForAFB()

bool StandardModel::setFlagSigmaForAFB ( const bool  flagSigmaForAFB_i)
inline

Definition at line 3324 of file StandardModel.h.

3325{
3326 bSigmaForAFB = flagSigmaForAFB_i;
3327 return true;
3328}

◆ setFlagSigmaForR()

bool StandardModel::setFlagSigmaForR ( const bool  flagSigmaForR_i)
inline

Definition at line 3330 of file StandardModel.h.

3331{
3332 bSigmaForR = flagSigmaForR_i;
3333 return true;
3334}

◆ 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 LeftRightSymmetricModel, NPSMEFTd6General, THDM, and THDMW.

Definition at line 514 of file StandardModel/src/StandardModel.cpp.

515{
516 bool res = false;
517 if (name.compare("Mw") == 0) {
518 if (checkEWPOscheme(value)) {
519 FlagMw = value;
520 res = true;
521 } else
522 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
523 + name + "=" + value);
524
525 } else if (name.compare("RhoZ") == 0) {
526 if (checkEWPOscheme(value)) {
527 FlagRhoZ = value;
528 res = true;
529 } else
530 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
531 + name + "=" + value);
532 } else if (name.compare("KappaZ") == 0) {
533 if (checkEWPOscheme(value)) {
534 FlagKappaZ = value;
535 res = true;
536 } else
537 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
538 + name + "=" + value);
539 } else
540 res = QCD::setFlagStr(name, value);
541
542 if (FlagMWinput) {
543 // Point the different flags towards the approximate formulae, when available
545 FlagMw = "APPROXIMATEFORMULA";
546 FlagRhoZ = "NORESUM";
547 FlagKappaZ = "APPROXIMATEFORMULA";
548 }
549
550 return (res);
551}
virtual bool setFlagStr(const std::string name, const std::string value)
A method to set a flag of QCD.
Definition: QCD.cpp:511
bool checkEWPOscheme(const std::string scheme) const
A method to check if a given scheme name in string form is valid.

◆ 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 NPDF2, HiggsChiral, HiggsKigen, NPd6SILH, NPEpsilons, NPEpsilons_pureNP, NPHiggs, NPSMEFT6dtopquark, NPSMEFTd6, NPSMEFTd6MFV, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPSTU, NPSTUVWXY, NPSTUZbbbarLR, NPZbbbar, NPZbbbarLinearized, SigmaBR, SUSY, THDM, CMFV, FlavourWilsonCoefficient, FlavourWilsonCoefficient_DF2, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, pMSSM, SUSYMassInsertion, and THDMW.

Definition at line 280 of file StandardModel/src/StandardModel.cpp.

281{
282 if (name.compare("Mz") == 0) {
283 Mz = value;
284 QCD::setParameter("MAls", value);
285 } else if (name.compare("AlsMz") == 0) {
286 AlsMz = value;
287 QCD::setParameter("AlsM", value);
288 } else if (name.compare("GF") == 0)
289 GF = value;
290 else if (name.compare("ale") == 0)
291 ale = value;
292 else if (name.compare("dAle5Mz") == 0 && !FlagMWinput)
293 dAle5Mz = value;
294 else if (name.compare("Mw_inp") == 0 && FlagMWinput)
295 Mw_inp = value;
296 else if (name.compare("mHl") == 0)
297 mHl = value;
298 else if (name.compare("delMw") == 0)
299 delMw = value;
300 else if (name.compare("delSin2th_l") == 0)
301 delSin2th_l = value;
302 else if (name.compare("delSin2th_q") == 0)
303 delSin2th_q = value;
304 else if (name.compare("delSin2th_b") == 0)
305 delSin2th_b = value;
306 else if (name.compare("delGammaZ") == 0)
307 delGammaZ = value;
308 else if (name.compare("delsigma0H") == 0)
309 delsigma0H = value;
310 else if (name.compare("delR0l") == 0)
311 delR0l = value;
312 else if (name.compare("delR0c") == 0)
313 delR0c = value;
314 else if (name.compare("delR0b") == 0)
315 delR0b = value;
316 else if (name.compare("delGammaWlv") == 0)
317 delGammaWlv = value;
318 else if (name.compare("delGammaWqq") == 0)
319 delGammaWqq = value;
320 else if (name.compare("mneutrino_1") == 0)
321 leptons[NEUTRINO_1].setMass(value);
322 else if (name.compare("mneutrino_2") == 0)
323 leptons[NEUTRINO_2].setMass(value);
324 else if (name.compare("mneutrino_3") == 0)
325 leptons[NEUTRINO_3].setMass(value);
326 else if (name.compare("melectron") == 0)
327 leptons[ELECTRON].setMass(value);
328 else if (name.compare("mmu") == 0)
329 leptons[MU].setMass(value);
330 else if (name.compare("mtau") == 0)
331 leptons[TAU].setMass(value);
332 else if (name.compare("lambda") == 0 && FlagWolfenstein) {
333 lambda = value;
334 requireCKM = true;
335 } else if (name.compare("A") == 0 && FlagWolfenstein) {
336 A = value;
337 requireCKM = true;
338 } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
339 rhob = value;
340 requireCKM = true;
341 } else if (name.compare("etab") == 0 && FlagWolfenstein) {
342 etab = value;
343 requireCKM = true;
344 } else if (name.compare("V_us") == 0 && !FlagWolfenstein && !FlagUseVud) {
345 Vus = value;
346 requireCKM = true;
347 } else if (name.compare("V_ud") == 0 && !FlagWolfenstein && FlagUseVud) {
348 Vud = value;
349 requireCKM = true;
350 } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
351 Vcb = value;
352 requireCKM = true;
353 } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
354 Vub = value;
355 requireCKM = true;
356 } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
357 gamma = value;
358 requireCKM = true;
359 } else if (name.compare("muw") == 0) {
360 /* Update mut if FlagFixMuwMut is activated */
361 muw = value;
362 if (FlagFixMuwMut) {
363 mut = muw / 80.4 * 163.;
364 }
365 }
366 else
367 QCD::setParameter(name, value);
368}
void setMass(double mass)
A set method to fix the particle mass.
Definition: Particle.h:70
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of QCD.
Definition: QCD.cpp:343

◆ setRequireCKM()

void StandardModel::setRequireCKM ( bool  requireCKM)
inline

A set method to change the value of requireCKM.

Parameters
[in]requireCKMthe new value for requireCKM

Definition at line 3351 of file StandardModel.h.

3352 {
3353 this->requireCKM = requireCKM;
3354 }

◆ setSMSuccess()

void StandardModel::setSMSuccess ( bool  success) const
inline

A set method to change the success status of the Standard Model update and matching.

Parameters
[in]successthe new value for SMSuccess

Definition at line 3438 of file StandardModel.h.

3439 {
3440 SMSuccess = success;
3441 }

◆ setYd()

void StandardModel::setYd ( const gslpp::matrix< gslpp::complex > &  Yd)
inline

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

Parameters
[in]Ydthe Yukawa matrix to be set

Definition at line 3400 of file StandardModel.h.

3401 {
3402 this->Yd = Yd;
3403 }

◆ setYe()

void StandardModel::setYe ( const gslpp::matrix< gslpp::complex > &  Ye)
inline

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

Parameters
[in]Yethe Yukawa matrix to be set

Definition at line 3420 of file StandardModel.h.

3421 {
3422 this->Ye = Ye;
3423 }

◆ setYu()

void StandardModel::setYu ( const gslpp::matrix< gslpp::complex > &  Yu)
inline

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

Parameters
[in]Yuthe Yukawa matrix to be set

Definition at line 3380 of file StandardModel.h.

3381 {
3382 this->Yu = Yu;
3383 }

◆ sigma0_had()

const 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, NPSMEFTd6General, and NPZbbbar.

Definition at line 1471 of file StandardModel/src/StandardModel.cpp.

1472{
1474
1475 /* SM contribution with the approximate formula */
1476 return (myApproximateFormulae->X_full("sigmaHadron")
1477 / GeVminus2_to_nb);
1478
1479 } else {
1480 return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1481 / Mz / Mz / Gamma_Z() / Gamma_Z());
1482 }
1483}
static const double GeVminus2_to_nb

◆ sigma_NoISR_l()

const double StandardModel::sigma_NoISR_l ( const QCD::lepton  l_flavor,
const double  s 
) const
protected

Definition at line 8012 of file StandardModel/src/StandardModel.cpp.

8013{
8014 double ml = getLeptons(l_flavor).getMass();
8015 double l_charge = getLeptons(l_flavor).getCharge();
8016 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8017
8018 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8019 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, l_charge);
8020
8021 return sigma;
8022}

◆ sigma_NoISR_q()

const double StandardModel::sigma_NoISR_q ( const QCD::quark  q_flavor,
const double  s 
) const
protected

Definition at line 8024 of file StandardModel/src/StandardModel.cpp.

8025{
8026 double mq = m_q(q_flavor, sqrt(s));
8027 double q_charge = getQuarks(q_flavor).getCharge();
8028 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8029
8030 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8031 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, q_charge);
8032
8033 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8035
8036 return sigma;
8037}

◆ SigmaeeHee()

const double StandardModel::SigmaeeHee ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to e^+ e^- H)\) in the Standard Model

Definition at line 3357 of file StandardModel/src/StandardModel.cpp.

3358{
3359 double xsLH=0.0, xsRH=0.0;
3360
3361 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3362}

◆ SigmaeeHvv()

const double StandardModel::SigmaeeHvv ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to \nu \bar{\nu} H)\) in the Standard Model

Definition at line 3350 of file StandardModel/src/StandardModel.cpp.

3351{
3352 double xsLH=1.0, xsRH=0.0;
3353
3354 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3355}

◆ SigmaeeZH()

const double StandardModel::SigmaeeZH ( const double  sqrt_s,
const double  Pe,
const double  Pp 
) const
virtual

The \(\sigma(e^+ e^- \to Z H)\) in the Standard Model.

Currently, only at tree level. From https://arxiv.org/pdf/hep-ph/9605437

Returns
\(\sigma(e^+ e^- \to Z H)\) in the Standard Model

Definition at line 3328 of file StandardModel/src/StandardModel.cpp.

3329{
3330 double xsLH, xsRH;
3331 double gL,gR,lam,fact;
3332 double s = sqrt_s*sqrt_s;
3333
3334 // From https://arxiv.org/pdf/hep-ph/9605437
3335
3336 gL = -0.5 + sW2();
3337
3338 gR = sW2();
3339
3340 lam = (1.0-(mHl+Mz)*(mHl+Mz)/s)*(1.0-(mHl-Mz)*(mHl-Mz)/s);
3341
3342 fact = (pow(GF*Mz*Mz,2.0)/96.0/M_PI/s) * sqrt(lam)*( lam + 12.0*Mz*Mz/s )/( 1.0 - Mz*Mz/s )/( 1.0 - Mz*Mz/s );
3343
3344 xsLH = 32.0 * gL * gL * fact;
3345 xsRH = 32.0 * gR * gR * fact;
3346
3347 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3348}

◆ sin2thetaEff()

const 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 NPbase, NPZbbbar, and NPEpsilons.

Definition at line 1357 of file StandardModel/src/StandardModel.cpp.

1358{
1359 double Re_kappa = kappaZ_f(f).real();
1360 return ( Re_kappa * sW2());
1361}

◆ sW2() [1/2]

const double StandardModel::sW2 ( ) const

Definition at line 1098 of file StandardModel/src/StandardModel.cpp.

1099{
1100 return ( 1.0 - cW2());
1101}

◆ sW2() [2/2]

const 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\)

Definition at line 1093 of file StandardModel/src/StandardModel.cpp.

1094{
1095 return ( 1.0 - cW2(Mw_i));
1096}

◆ sW2_MSbar_Approx()

const double StandardModel::sW2_MSbar_Approx ( ) const

The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme, denoted as \(\hat{s}_{W}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022)

Returns
\(\hat{s}_{W}^2\)

Definition at line 1103 of file StandardModel/src/StandardModel.cpp.

1104{
1105 //double rho_t= 3. * getGF() * getMtpole() * getMtpole() / (8. * sqrt(2.) * M_PI * M_PI );
1106 return ( sW2()*1.0351 ); //PDG 22 electroweak review eq. (10.19)
1107}

◆ sW2_ND()

const double StandardModel::sW2_ND ( ) const

The square of the sine of the weak mixing angle in the MSbar-ND scheme (w/o decoupling $\alpha\ln(m_t/M_Z)$ terms), denoted as \(\hat{s}_{ND}^2\). See: PDG 22, R.L. Workman et al. (Particle Data Group), Prog. Theor. Exp. Phys. 2022, 083C01 (2022) (eq. 10.13a/10.13b)

Returns
\(\hat{s}_{ND}^2\)

Definition at line 1109 of file StandardModel/src/StandardModel.cpp.

1110{
1111 double d = 1. / 3. * (1. / sW2_MSbar_Approx() - 8. / 3.) *
1112 ( (1 + getAlsMz()/M_PI)*log(getMtpole()/getMz()) - 15.*getAlsMz()/(8.*M_PI) );
1113
1114 return sW2_MSbar_Approx()*(1. + Ale(getMz(),FULLNLO)*d/M_PI);
1115
1116}
const double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:600
const double sW2_MSbar_Approx() const
The (approximated formula for the) square of the sine of the weak mixing angle in the MSbar scheme,...
const double getMz() const
A get method to access the mass of the boson .
const double getAlsMz() const
A get method to access the value of .

◆ 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 [Fleischer:1992fq], [Buchalla:1992zm], [Degrassi:1993ij], [Chetyrkin:1993jp], and the \(O(G_\mu^2 m_t^4)\) term can be found in [Barbieri:1992nz], [Barbieri:1992dq], [Fleischer:1993ub], [Fleischer:1994cb].

Returns
\(\tau_b\)

Definition at line 2119 of file StandardModel/src/StandardModel.cpp.

2120{
2121 double taub_tmp = 0.0;
2122 double Xt = myEWSMcache->Xt_GF();
2123 if (flag_order[EW1])
2124 taub_tmp += -2.0 * Xt;
2125 if (flag_order[EW1QCD1])
2126 taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2127 if (flag_order[EW1QCD2])
2128 taub_tmp += 0.0;
2129 if (flag_order[EW2])
2130 taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2131 if (flag_order[EW2QCD1])
2132 taub_tmp += 0.0;
2133 if (flag_order[EW3])
2134 taub_tmp += 0.0;
2135
2136 return taub_tmp;
2137}
double tau_2() const
The function .
double Xt_GF() const
The quantity with the coupling .
Definition: EWSMcache.h:343
double alsMt() const
The strong coupling at NNLO.
Definition: EWSMcache.h:378

◆ TauLFU_gmuge()

const double StandardModel::TauLFU_gmuge ( ) const
virtual

The computation of the LFU ratio \(g_\mu/ g_e \).

Returns
\(g_\mu/ g_e \)

Definition at line 3171 of file StandardModel/src/StandardModel.cpp.

3172{
3173 double g2LFU;
3174
3175 double me, mmu, mtau, xe, Fxe, xmu, Fxmu;
3176
3177 me = leptons[ELECTRON].getMass();
3178 mmu = leptons[MU].getMass();
3179 mtau = leptons[TAU].getMass();
3180
3181 xe = me*me/mtau/mtau;
3182 Fxe = 1. - 8. * xe + 8. * xe*xe*xe - xe*xe*xe*xe -12. * xe*xe * log(xe);
3183
3184 xmu = mmu*mmu/mtau/mtau;
3185 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3186
3188
3189 g2LFU = g2LFU * (Fxe/Fxmu);
3190
3191 return sqrt(g2LFU);
3192}
virtual const double Gamma_tau_l_nunu(const Particle l) const
The computation of the leptonic tau decays.

◆ TauLFU_gtauge()

const double StandardModel::TauLFU_gtauge ( ) const
virtual

The computation of the LFU ratio \(g_\tau/ g_e \).

Returns
\(g_\tau/ g_e \)

Definition at line 3217 of file StandardModel/src/StandardModel.cpp.

3218{
3219 double g2LFU;
3220
3221 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3222
3223 me = leptons[ELECTRON].getMass();
3224 mmu = leptons[MU].getMass();
3225 mtau = leptons[TAU].getMass();
3226
3227 xtau = mmu*mmu/mtau/mtau;
3228 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3229
3230 xmu = me*me/mmu/mmu;
3231 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3232
3233 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_muon());
3234
3235 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3236
3237 return sqrt(g2LFU);
3238}
virtual const double Gamma_muon() const
The computation of the muon decay.

◆ TauLFU_gtaugmu()

const double StandardModel::TauLFU_gtaugmu ( ) const
virtual

The computation of the LFU ratio \(g_\tau/ g_\mu \).

Returns
\(g_\tau/ g_\mu \)

Definition at line 3194 of file StandardModel/src/StandardModel.cpp.

3195{
3196 double g2LFU;
3197
3198 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3199
3200 me = leptons[ELECTRON].getMass();
3201 mmu = leptons[MU].getMass();
3202 mtau = leptons[TAU].getMass();
3203
3204 xtau = me*me/mtau/mtau;
3205 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3206
3207 xmu = me*me/mmu/mmu;
3208 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3209
3211
3212 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3213
3214 return sqrt(g2LFU);
3215}

◆ TauLFU_gtaugmuK()

const double StandardModel::TauLFU_gtaugmuK ( ) const
virtual

The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_K \).

Returns
\(\left(g_\tau/ g_\mu\right)_K \)

Definition at line 3248 of file StandardModel/src/StandardModel.cpp.

3249{
3250 // 1st approx.
3251
3252 return 1.0;
3253}

◆ TauLFU_gtaugmuPi()

const double StandardModel::TauLFU_gtaugmuPi ( ) const
virtual

The computation of the LFU ratio \(\left(g_\tau/ g_\mu\right)_\pi \).

Returns
\(\left(g_\tau/ g_\mu\right)_\pi \)

Definition at line 3241 of file StandardModel/src/StandardModel.cpp.

3242{
3243 // 1st approx.
3244
3245 return 1.0;
3246}

◆ ThetaLnuN()

const double StandardModel::ThetaLnuN ( ) const
virtual

The effective neutrino nucleon LH parameter: ThetaLnuN.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(\theta_L(\nu N)\)

Definition at line 3034 of file StandardModel/src/StandardModel.cpp.

3035{
3036 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3038
3039 /* SM contribution with the approximate formula */
3041
3042 } else {
3043 throw std::runtime_error("ERROR: StandardModel::ThetaLnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3044 }
3045}
double LEThetaLnuNApprox() const
The effective neutrino nucleon LH parameter: ThetaLnuN.

◆ ThetaRnuN()

const double StandardModel::ThetaRnuN ( ) const
virtual

The effective neutrino nucleon RH parameter: ThetaRnuN.

Follows the corresponding semianalytical expression in EWSMApproximateFormulae.

Returns
\(\theta_R(\nu N)\)

Definition at line 3048 of file StandardModel/src/StandardModel.cpp.

3049{
3050 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3052
3053 /* SM contribution with the approximate formula */
3055
3056 } else {
3057 throw std::runtime_error("ERROR: StandardModel::ThetaRnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3058 }
3059}
double LEThetaRnuNApprox() const
The effective neutrino nucleon RH parameter: ThetaRnuN.

◆ tovers2()

const double StandardModel::tovers2 ( const double  cosmin,
const double  cosmax 
) const

Definition at line 3918 of file StandardModel/src/StandardModel.cpp.

3918 {
3919 return 0.25 * (cosmax * (1.0 - cosmax * (1.0 - cosmax / 3.0)) - cosmin * (1.0 - cosmin * (1.0 - cosmin / 3.0)));
3920}

◆ uovers2()

const double StandardModel::uovers2 ( const double  cosmin,
const double  cosmax 
) const

Definition at line 3922 of file StandardModel/src/StandardModel.cpp.

3922 {
3923 return 0.25 * (cosmax * (1.0 + cosmax * (1.0 + cosmax / 3.0)) - cosmin * (1.0 + cosmin * (1.0 + cosmin / 3.0)));
3924}

◆ 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 FlavourWilsonCoefficient, LoopMediators, RealWeakEFTCC, RealWeakEFTLFV, GeneralSUSY, GeorgiMachacek, LeftRightSymmetricModel, MFV, NPbase, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

Definition at line 227 of file StandardModel/src/StandardModel.cpp.

228{
229 if (!PreUpdate()) return (false);
230
231 UpdateError = false;
232
233 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
234 setParameter(it->first, it->second);
235
236 if (UpdateError) return (false);
237
238 if (!PostUpdate()) return (false);
239
240 return (true);
241}
bool UpdateError
A boolean set to false if update is successful.
Definition: Model.h:272
virtual bool PreUpdate()
The pre-update method for StandardModel.
virtual bool PostUpdate()
The post-update method for StandardModel.
virtual void setParameter(const std::string name, const double &value)
A method to set the value of a parameter of StandardModel.

◆ v()

const double StandardModel::v ( ) const

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 995 of file StandardModel/src/StandardModel.cpp.

996{
997 return ( 1. / sqrt(sqrt(2.) * GF));
998}

Member Data Documentation

◆ A

double StandardModel::A
protected

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

Definition at line 3496 of file StandardModel.h.

◆ ale

double StandardModel::ale
protected

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

Definition at line 3481 of file StandardModel.h.

◆ ale_cache

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

Cache for \(\alpha_e\).

Definition at line 4114 of file StandardModel.h.

◆ alpha21

double StandardModel::alpha21
protected

Definition at line 3505 of file StandardModel.h.

◆ alpha31

double StandardModel::alpha31
protected

Definition at line 3505 of file StandardModel.h.

◆ als_cache

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

Cache for \(\alpha_s\).

Definition at line 4113 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 3477 of file StandardModel.h.

◆ average

double StandardModel::average
mutableprivate

GSL integral variable

Definition at line 4099 of file StandardModel.h.

◆ bSigmaForAFB

bool StandardModel::bSigmaForAFB
mutableprotected

Definition at line 3763 of file StandardModel.h.

◆ bSigmaForR

bool StandardModel::bSigmaForR
mutableprotected

Definition at line 3764 of file StandardModel.h.

◆ CacheSize

const int StandardModel::CacheSize = 5
staticprivate

Defines the depth of the cache.

Definition at line 4112 of file StandardModel.h.

◆ dAl5hMz

double StandardModel::dAl5hMz
protected

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

Definition at line 3508 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)\), used as input for FlagMWinput = FALSE.

Definition at line 3482 of file StandardModel.h.

◆ delGammaWlv

double StandardModel::delGammaWlv
protected

The theoretical uncertainty in \(\Gamma_W_{l\nu}\), denoted as \(\delta\,\Gamma_W_{l\nu}\).

Definition at line 3493 of file StandardModel.h.

◆ delGammaWqq

double StandardModel::delGammaWqq
protected

The theoretical uncertainty in \(\Gamma_W_{qq}\), denoted as \(\delta\,\Gamma_W_{qq}\).

Definition at line 3494 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 3488 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 3484 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 3492 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 3491 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 3490 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 3489 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 3487 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 3485 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 3486 of file StandardModel.h.

◆ delta

double StandardModel::delta
protected

Definition at line 3505 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 4080 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 4079 of file StandardModel.h.

◆ error

double StandardModel::error
mutableprivate

GSL integral variable

Definition at line 4100 of file StandardModel.h.

◆ etab

double StandardModel::etab
protected

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

Definition at line 3498 of file StandardModel.h.

◆ f_GSL

gsl_function StandardModel::f_GSL
mutableprivate

GSL integral variable

Definition at line 4101 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 3519 of file StandardModel.h.

◆ FlagCacheInStandardModel

bool StandardModel::FlagCacheInStandardModel
private

A flag for caching (true by default).

Definition at line 4077 of file StandardModel.h.

◆ FlagFixMuwMut

bool StandardModel::FlagFixMuwMut
protected

A boolean for the model flag FixMuwMut.

Definition at line 3753 of file StandardModel.h.

◆ FlagKappaZ

std::string StandardModel::FlagKappaZ
private

A string for the model flag KappaZ.

Definition at line 4065 of file StandardModel.h.

◆ flagLEP2

bool StandardModel::flagLEP2[NUMofLEP2RCs]
protected

Definition at line 3762 of file StandardModel.h.

◆ FlagMw

std::string StandardModel::FlagMw
private

A string for the model flag Mw.

Definition at line 4063 of file StandardModel.h.

◆ FlagMWinput

bool StandardModel::FlagMWinput
private

A boolean for the model flag MWinput.

Definition at line 4069 of file StandardModel.h.

◆ FlagNoApproximateGammaZ

bool StandardModel::FlagNoApproximateGammaZ
private

A boolean for the model flag NoApproximateGammaZ.

Definition at line 4062 of file StandardModel.h.

◆ FlagRhoZ

std::string StandardModel::FlagRhoZ
private

A string for the model flag RhoZ.

Definition at line 4064 of file StandardModel.h.

◆ FlagSMAux

bool StandardModel::FlagSMAux
private

A boolean for the model flag SMAux.

Definition at line 4070 of file StandardModel.h.

◆ FlagUseVud

bool StandardModel::FlagUseVud
private

A boolean for the model flag UseVud.

Definition at line 4067 of file StandardModel.h.

◆ FlagWithoutNonUniversalVC

bool StandardModel::FlagWithoutNonUniversalVC
private

A boolean for the model flag WithoutNonUniversalVC.

Definition at line 4061 of file StandardModel.h.

◆ FlagWolfenstein

bool StandardModel::FlagWolfenstein
private

A boolean for the model flag Wolfenstein.

Definition at line 4066 of file StandardModel.h.

◆ gamma

double StandardModel::gamma
protected

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

Definition at line 3503 of file StandardModel.h.

◆ GammaW_cache

double StandardModel::GammaW_cache
mutableprivate

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

Definition at line 4082 of file StandardModel.h.

◆ GeVminus2_to_nb

const double StandardModel::GeVminus2_to_nb = 389379.338
static

Definition at line 558 of file StandardModel.h.

◆ GF

double StandardModel::GF
protected

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

Definition at line 3480 of file StandardModel.h.

◆ iterationNo

int StandardModel::iterationNo
private

Definition at line 4105 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 4084 of file StandardModel.h.

◆ lambda

double StandardModel::lambda
protected

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

Definition at line 3495 of file StandardModel.h.

◆ leptons

Particle StandardModel::leptons[6]
protected

An array of Particle objects for the leptons.

Definition at line 3464 of file StandardModel.h.

◆ mHl

double StandardModel::mHl
protected

The Higgs mass \(m_h\) in GeV.

Definition at line 3483 of file StandardModel.h.

◆ muw

double StandardModel::muw
protected

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

Definition at line 3504 of file StandardModel.h.

◆ Mw_cache

double StandardModel::Mw_cache
mutableprivate

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

Definition at line 4081 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 564 of file StandardModel.h.

◆ Mw_inp

double StandardModel::Mw_inp
protected

The mass of the \(W\) boson in GeV used as input for FlagMWinput = TRUE.

Definition at line 3479 of file StandardModel.h.

◆ myApproximateFormulae

EWSMApproximateFormulae* StandardModel::myApproximateFormulae
private

A pointer to an object of type EWSMApproximateFormulae.

Definition at line 4055 of file StandardModel.h.

◆ myCKM

CKM StandardModel::myCKM
protected

An object of type CKM.

Definition at line 3465 of file StandardModel.h.

◆ myEWSMcache

EWSMcache* StandardModel::myEWSMcache
private

A pointer to an object of type EWSMcache.

Definition at line 4048 of file StandardModel.h.

◆ myLeptonFlavour

LeptonFlavour* StandardModel::myLeptonFlavour
private

A pointer to an object of the type LeptonFlavour.

Definition at line 4056 of file StandardModel.h.

◆ myOneLoopEW

EWSMOneLoopEW* StandardModel::myOneLoopEW
private

A pointer to an object of type EWSMOneLoopEW.

Definition at line 4049 of file StandardModel.h.

◆ myPMNS

PMNS StandardModel::myPMNS
protected

Definition at line 3466 of file StandardModel.h.

◆ myThreeLoopEW

EWSMThreeLoopEW* StandardModel::myThreeLoopEW
private

A pointer to an object of type EWSMThreeLoopEW.

Definition at line 4054 of file StandardModel.h.

◆ myThreeLoopEW2QCD

EWSMThreeLoopEW2QCD* StandardModel::myThreeLoopEW2QCD
private

A pointer to an object of type EWSMThreeLoopEW2QCD.

Definition at line 4053 of file StandardModel.h.

◆ myThreeLoopQCD

EWSMThreeLoopQCD* StandardModel::myThreeLoopQCD
private

A pointer to an object of type EWSMThreeLoopQCD.

Definition at line 4051 of file StandardModel.h.

◆ myTwoFermionsLEP2

EWSMTwoFermionsLEP2* StandardModel::myTwoFermionsLEP2
private

A pointer to an object of type EWSMTwoFermionsLEP2.

Definition at line 4058 of file StandardModel.h.

◆ myTwoLoopEW

EWSMTwoLoopEW* StandardModel::myTwoLoopEW
private

A pointer to an object of type EWSMTwoLoopEW.

Definition at line 4052 of file StandardModel.h.

◆ myTwoLoopQCD

EWSMTwoLoopQCD* StandardModel::myTwoLoopQCD
private

A pointer to an object of type EWSMTwoLoopQCD.

Definition at line 4050 of file StandardModel.h.

◆ Mz

double StandardModel::Mz
protected

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

Definition at line 3478 of file StandardModel.h.

◆ NSMvars

const int StandardModel::NSMvars = 28
static

The number of the model parameters in StandardModel.

Definition at line 552 of file StandardModel.h.

◆ NumSMParamsForEWPO

const int StandardModel::NumSMParamsForEWPO = 35
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 2132 of file StandardModel.h.

◆ realorder

orders StandardModel::realorder
mutableprivate

Definition at line 4115 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 3748 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 3749 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 3750 of file StandardModel.h.

◆ rhob

double StandardModel::rhob
protected

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

Definition at line 3497 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 4083 of file StandardModel.h.

◆ s12

double StandardModel::s12
protected

Definition at line 3505 of file StandardModel.h.

◆ s13

double StandardModel::s13
protected

Definition at line 3505 of file StandardModel.h.

◆ s23

double StandardModel::s23
protected

Definition at line 3505 of file StandardModel.h.

◆ SMFlavour

Flavour StandardModel::SMFlavour
protected

An object of type Flavour.

Definition at line 3752 of file StandardModel.h.

◆ SMM

Matching<StandardModelMatching,StandardModel> StandardModel::SMM
mutableprotected

An object of type Matching.

Definition at line 3469 of file StandardModel.h.

◆ SMparamsForEWPO_cache

double StandardModel::SMparamsForEWPO_cache[NumSMParamsForEWPO]
mutableprivate

Definition at line 4078 of file StandardModel.h.

◆ SMresult_cache

double StandardModel::SMresult_cache
mutableprivate

Definition at line 4095 of file StandardModel.h.

◆ SMSuccess

bool StandardModel::SMSuccess
mutableprivate

A boolean for the success of the Standard Model update and matching.

Definition at line 4072 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", "delGammaWlv", "delGammaWqq",
"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 556 of file StandardModel.h.

◆ useDeltaAlpha_cache

bool StandardModel::useDeltaAlpha_cache
mutableprivate

Definition at line 4086 of file StandardModel.h.

◆ useDeltaAlphaLepton_cache

bool StandardModel::useDeltaAlphaLepton_cache
mutableprivate

Definition at line 4085 of file StandardModel.h.

◆ useGammaW_cache

bool StandardModel::useGammaW_cache
mutableprivate

Definition at line 4088 of file StandardModel.h.

◆ useKappaZ_f_cache

bool StandardModel::useKappaZ_f_cache[12]
mutableprivate

Definition at line 4090 of file StandardModel.h.

◆ useMw_cache

bool StandardModel::useMw_cache
mutableprivate

Definition at line 4087 of file StandardModel.h.

◆ useRhoZ_f_cache

bool StandardModel::useRhoZ_f_cache[12]
mutableprivate

Definition at line 4089 of file StandardModel.h.

◆ Vcb

double StandardModel::Vcb
protected

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

Definition at line 3501 of file StandardModel.h.

◆ Vub

double StandardModel::Vub
protected

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

Definition at line 3502 of file StandardModel.h.

◆ Vud

double StandardModel::Vud
protected

\(\vert V_{ud} \vert \) used as an input for FlagWolfenstein = FALSE and FlagUseVud = TRUE

Definition at line 3500 of file StandardModel.h.

◆ Vus

double StandardModel::Vus
protected

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

Definition at line 3499 of file StandardModel.h.

◆ w_GSL1

gsl_integration_workspace* StandardModel::w_GSL1
private

GSL integral variable

Definition at line 4102 of file StandardModel.h.

◆ Yd

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

The Yukawa matrix of the down-type quarks.

Definition at line 3471 of file StandardModel.h.

◆ Ye

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

The Yukawa matrix of the charged leptons.

Definition at line 3473 of file StandardModel.h.

◆ Yn

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

The Yukawa matrix of the neutrinos.

Definition at line 3472 of file StandardModel.h.

◆ Yu

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

The Yukawa matrix of the up-type quarks.

Definition at line 3470 of file StandardModel.h.


The documentation for this class was generated from the following files: