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\).
mneutrino_1 \(m_{\nu_1}\) The mass of the first-generation neutrino in GeV.
mneutrino_2 \(m_{\nu_2}\) The mass of the second-generation neutrino in GeV.
mneutrino_3 \(m_{\nu_3}\) The mass of the third-generation neutrino in GeV.
melectron \(m_e\) The electron mass in GeV.
mmu \(m_\mu\) The muon mass in GeV.
mtau \(m_\tau\) The tau mass in GeV.
lambda \(\lambda\) The CKM parameter \(\lambda\) in the Wolfenstein parameterization.
A \(A\) The CKM parameter \(A\) in the Wolfenstein parameterization.
rhob \(\bar{\rho}\) The CKM parameter \(\bar{\rho}\) in the Wolfenstein parameterization.
etab \(\bar{\eta}\) The CKM parameter \(\bar{\eta}\) in the Wolfenstein parameterization.
muw \(\mu_W\) A matching scale around the weak scale in GeV.

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

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

Model flags

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

Label Value Description
Wolfenstein TRUE / FALSE This flag controls the way the CKM matrix is parameterized. If set to TRUE, the CKM matrix is computed starting from the Wolfenstein parameters. If set to FALSE, the CKM matrix is computed starting from \(\vert V_{us} \vert\), \(\vert V_{cb} \vert\), \(\vert V_{ub} \vert\) and \(\gamma\). The default value is TRUE.
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 509 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
 
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 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 = 26
 The number of the model parameters in StandardModel. More...
 
static const int NumSMParamsForEWPO = 33
 The number of the SM parameters that are relevant to the EW precision observables. More...
 
static std::string SMvars [NSMvars]
 A string array containing the labels of the model parameters in StandardModel. More...
 
- Static Public Attributes inherited from QCD
static const int NQCDvars = 11
 The number of model parameters in QCD. More...
 
static std::string QCDvars [NQCDvars]
 An array containing the labels under which all QCD parameters are stored in a vector of ModelParameter via InputParser::ReadParameters(). More...
 

Protected Member Functions

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

527 {
528 EW1 = 0,
529 EW1QCD1,
530 EW1QCD2,
531 EW2,
532 EW2QCD1,
533 EW3,
535 };
@ 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("mneutrino_1", std::cref(leptons[NEUTRINO_1].getMass())));
135 ModelParamMap.insert(std::make_pair("mneutrino_2", std::cref(leptons[NEUTRINO_2].getMass())));
136 ModelParamMap.insert(std::make_pair("mneutrino_3", std::cref(leptons[NEUTRINO_3].getMass())));
137 ModelParamMap.insert(std::make_pair("melectron", std::cref(leptons[ELECTRON].getMass())));
138 ModelParamMap.insert(std::make_pair("mmu", std::cref(leptons[MU].getMass())));
139 ModelParamMap.insert(std::make_pair("mtau", std::cref(leptons[TAU].getMass())));
140 ModelParamMap.insert(std::make_pair("lambda", std::cref(lambda)));
141 ModelParamMap.insert(std::make_pair("A", std::cref(A)));
142 ModelParamMap.insert(std::make_pair("rhob", std::cref(rhob)));
143 ModelParamMap.insert(std::make_pair("etab", std::cref(etab)));
144 ModelParamMap.insert(std::make_pair("muw", std::cref(muw)));
145
146 iterationNo = 0;
147 realorder = LO;
148
149 w_GSL1 = gsl_integration_workspace_alloc (200);
150}
@ 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 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 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 152 of file StandardModel/src/StandardModel.cpp.

153{
154 if (IsModelInitialized()) {
155 if (myEWSMcache != NULL) delete(myEWSMcache);
156 if (myOneLoopEW != NULL) delete(myOneLoopEW);
157 if (myTwoLoopQCD != NULL) delete(myTwoLoopQCD);
158 if (myThreeLoopQCD != NULL) delete(myThreeLoopQCD);
159 if (myTwoLoopEW != NULL) delete(myTwoLoopEW);
160 if (myThreeLoopEW2QCD != NULL) delete(myThreeLoopEW2QCD);
161 if (myThreeLoopEW != NULL) delete(myThreeLoopEW);
162 if (myApproximateFormulae != NULL) delete(myApproximateFormulae);
163 if (myLeptonFlavour != NULL) delete(myLeptonFlavour);
164 /* BEGIN: REMOVE FROM THE PACKAGE */
165 if (myTwoFermionsLEP2 != NULL) delete(myTwoFermionsLEP2);
166 /* END: REMOVE FROM THE PACKAGE */
167 }
168}
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 1339 of file StandardModel/src/StandardModel.cpp.

1340{
1341 double Re_kappa = kappaZ_f(f).real();
1342 double Re_gV_over_gA = 1.0 - 4.0 * fabs(f.getCharge()) * Re_kappa * sW2();
1343 return ( 2.0 * Re_gV_over_gA / (1.0 + pow(Re_gV_over_gA, 2.0)));
1344}
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 1346 of file StandardModel/src/StandardModel.cpp.

1347{
1348 return (3.0 / 4.0 * A_f(leptons[ELECTRON]) * A_f(f));
1349}
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 8028 of file StandardModel/src/StandardModel.cpp.

8029{
8030 double ml = getLeptons(l_flavor).getMass();
8031 double AFB = myTwoFermionsLEP2->AFB_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8032
8033 return AFB;
8034}
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 8036 of file StandardModel/src/StandardModel.cpp.

8037{
8038 double mq = m_q(q_flavor, sqrt(s));
8039 double AFB = myTwoFermionsLEP2->AFB_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8040
8041 if (flagLEP2[QCDFSR])
8042 AFB *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, s);
8043
8044 return AFB;
8045}
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#4708, with \(M\) the mass of the fermion in the loop.

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

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

3296 {
3297 return (2.0 * tau * (1.0 + (1.0 - tau) * f_triangle(tau)));
3298}
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#4708, with \(M\) the mass of the fermion in the loop.

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

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

3300 {
3301 return -(2.0 + 3.0 * tau + 3.0 * tau * (2.0 - tau) * f_triangle(tau));
3302}

◆ 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#4708, \(\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 3304 of file StandardModel/src/StandardModel.cpp.

3304 {
3305 return I_triangle_1(tau, lambda) - I_triangle_2(tau, lambda);
3306}
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#4708, \(\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 3308 of file StandardModel/src/StandardModel.cpp.

3308 {
3309 gslpp::complex tmp;
3310
3311 double tan2w = sW2() / cW2();
3312
3313 tmp = 4.0 * (3.0 - tan2w) * I_triangle_2(tau, lambda);
3314
3315 tmp = tmp + ((1.0 + 2.0 / tau) * tan2w - (5.0 + 2.0 / tau)) * I_triangle_1(tau, lambda);
3316
3317 return sqrt(cW2()) * tmp;
3318}
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 777 of file StandardModel/src/StandardModel.cpp.

778{
779 int i, nfAle = (int) Nf(Mz), nfmu = Nf_thr ? (int) Nf(mu) : nfAle;
780 double ale, aletmp, mutmp, aleMz = alphaMz();
781 orders fullord;
782
783 for (i = 0; i < CacheSize; ++i)
784 if ((mu == ale_cache[0][i]) && ((double) order == ale_cache[1][i]) &&
785 (AlsMz == ale_cache[2][i]) && (Mz == ale_cache[3][i]) &&
786 (mut == ale_cache[4][i]) && (mub == ale_cache[5][i]) &&
787 (muc == ale_cache[6][i])
788 && (double) Nf_thr == ale_cache[7][i] && aleMz == ale_cache[8][i])
789 return ale_cache[9][i];
790
791 switch (order)
792 {
793 case FULLNLO:
794 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr));
795 case FULLNNLO:
796 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr));
797 case FULLNNNLO:
798 return (Ale(mu, LO, Nf_thr) + Ale(mu, NLO, Nf_thr) + Ale(mu, NNLO, Nf_thr) + Ale(mu, NNNLO, Nf_thr));
799 case LO:
800 if (nfAle == nfmu)
801 return(AleWithInit(mu, aleMz, Mz, order));
802 case NLO:
803 case NNLO:
804 case NNNLO:
805 if (nfAle == nfmu)
806 return(0.);
807 fullord = FullOrder(order);
808 if (nfAle > nfmu) {
809 mutmp = BelowTh(Mz);
810 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
811// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(nfAle), alstmp, nfAls, fullord)); // WARNING: QED threshold corrections not implemented yet
812 for (i = nfAle - 1; i > nfmu; i--) {
813 mutmp = BelowTh(mutmp - MEPS);
814 aletmp = AleWithInit(mutmp, aletmp, AboveTh(mutmp) - MEPS, fullord);
815// aletmp *= (1. - NfThresholdCorrections(mutmp, MassOfNf(i), aletmp, i, fullord)); // WARNING: QED threshold corrections not implemented yet
816 }
817 ale = AleWithInit(mu, aletmp, AboveTh(mu) - MEPS, order);
818 }
819
820 if (nfAle < nfmu) {
821 mutmp = AboveTh(Mz) - MEPS;
822 aletmp = AleWithInit(mutmp, aleMz, Mz, fullord);
823// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(nfAls + 1), alstmp, nfAls + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
824 for (i = nfAle + 1; i < nfmu; i++) {
825 mutmp = AboveTh(mutmp) - MEPS;
826 aletmp = AleWithInit(mutmp, aletmp, BelowTh(mutmp) + MEPS, fullord);
827// alstmp *= (1. + NfThresholdCorrections(mutmp, MassOfNf(i + 1), alstmp, i + 1, fullord)); // WARNING: QED threshold corrections not implemented yet
828 }
829 ale = AleWithInit(mu, aletmp, BelowTh(mu) + MEPS, order);
830 }
831
833 ale_cache[0][0] = mu;
834 ale_cache[1][0] = (double) order;
835 ale_cache[2][0] = AlsMz;
836 ale_cache[3][0] = Mz;
837 ale_cache[4][0] = mut;
838 ale_cache[5][0] = mub;
839 ale_cache[6][0] = muc;
840 ale_cache[7][0] = (double) Nf_thr;
841 ale_cache[8][0] = aleMz;
842 ale_cache[9][0] = ale;
843
844 return ale;
845 default:
846 throw std::runtime_error("StandardModel::Ale(): " + orderToString(order) + " is not implemented.");
847 }
848}
@ 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 605 of file StandardModel/src/StandardModel.cpp.

606{
607 if (mu < 50.0)
608 throw std::runtime_error("out of range in StandardModel::ale_OS()");
609
610 double N = 20.0 / 3.0;
611 double beta1 = N / 3.0;
612 double beta2 = N / 4.0;
613 double alpha_ini = alphaMz();
614 double v = 1.0 + 2.0 * beta1 * alpha_ini / M_PI * log(Mz / mu);
615
616 switch (order) {
617 case LO:
618 return ( alpha_ini / v);
619 case FULLNLO:
620 return ( alpha_ini / v * (1.0 - beta2 / beta1 * alpha_ini / M_PI * log(v) / v));
621 default:
622 throw std::runtime_error("Error in StandardModel::ale_OS()");
623 }
624}
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 850 of file StandardModel/src/StandardModel.cpp.

851{
852 if (fabs(mu - mu_i) < MEPS) return(alei);
853
854 double nf = Nf(mu), alsi = (mu_i == Mz ? AlsMz : Als(mu_i, FULLNNNLO, true, true));
855 double b00e = Beta_e(00, nf), b00s = Beta_s(00, nf);
856 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
857 double logv = log(1. + b00s * alsi / 2. / M_PI * log(mu / mu_i)), logve = log(ve);
858
859 switch (order)
860 {
861 case LO:
862 return (alei / ve);
863 case NLO:
864 return (- alei * alei / 4. / M_PI / ve / ve * (Beta_e(10, nf) / b00e * logve - Beta_e(01, nf) / b00s * logv) );
865 // Higher order terms ? Need to understand eq. (35)
866 case FULLNLO:
867 return (AleWithInit(mu, alei, mu_i, LO) + AleWithInit(mu, alei, mu_i, NLO));
868 default:
869 throw std::runtime_error("StandardModel::AleWithInit(): " + orderToString(order) + " is not implemented.");
870 }
871}
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 938 of file StandardModel/src/StandardModel.cpp.

939{
940 return (ale / (1.0 - DeltaAlpha()));
941// return(1./127.918); // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
942// return(1./127.955); // FOR HEFFDF1 TEST: VALUE IN 2007.04191
943}
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}\)

Reimplemented in NPbase.

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

2764{
2765 // functions and inputs
2766 double alrmoller;
2767
2768 // which alfa is this? => alpha(0). is this ale?
2769
2770 // parity violation asymmetry
2771 // --------------------------
2772 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);
2773
2774 return alrmoller;
2775}
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 1088 of file StandardModel.h.

1089 {
1090 if (qed_flag && order == FULLNNNLO)
1091 return AlsE(mu, order, Nf_thr);
1092
1093 return Als(mu, order, Nf_thr);
1094 }
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 674 of file StandardModel/src/StandardModel.cpp.

675{
676 switch (order)
677 {
678 case FULLNNNLO:
679 realorder = order;
680 return (AlsByOrder(mu, LO, Nf_thr) + AlsByOrder(mu, NLO, Nf_thr) + AlsByOrder(mu, NNLO, Nf_thr) + AlsEByOrder(mu, NNNLO, Nf_thr));
681 default:
682 throw std::runtime_error("StandardModel::AlsE(): " + orderToString(order) + " is not implemented.");
683 }
684}
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 686 of file StandardModel/src/StandardModel.cpp.

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

750{
751 double nf = (double) nf_i, alei = Ale(mu_i, FULLNLO); // CHANGE ME!
752 double b00s = Beta_s(00, nf), b00e = Beta_e(00, nf);
753 double v = 1. + b00s * alsi / 2. / M_PI * log(mu / mu_i);
754 double ve = 1. - b00e * alei / 2. / M_PI * log(mu / mu_i);
755 double logv = log(v), logve = log(ve);
756 double rho = 1. / (1. + b00e * alei / b00s / alsi);
757 double als = AlsWithInit(mu, alsi, mu_i, nf, order);
758 double b01s = Beta_s(01,nf), b01s00e = b01s / b00e;
759
760 switch (order)
761 {
762 case NNNLO:
763 als += alsi * alsi * alei / 4. / 4. / M_PI / M_PI / v / v / ve * (Beta_s(02, nf) / b00e *
764 (ve - 1.) + Beta_s(11, nf) / b00s * rho * ve * (logve - logv) + b01s00e * Beta_e(10, nf) /
765 b00e * (logve - ve + 1.) + b01s * Beta_s(10, nf) / b00s / b00s * rho * logv +
766 b01s00e * Beta_e(01, nf) / b00s * (rho * ve * (logv - logve) - logv));
767 break;
768 case FULLNNNLO:
769 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));
770 default:
771 throw std::runtime_error("StandardModel::AlsEWithInit(): " + orderToString(order) + " is not implemented.");
772 }
773
774 return (als);
775}
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 945 of file StandardModel/src/StandardModel.cpp.

946{
947 double mu_0 = Mz;
948 double alphatilde_e = alphaMz()/4./M_PI;
949 double alphatilde_s = AlsMz/4./M_PI;
950 unsigned int nf = 5;
951
952 double B00S = Beta0(nf), B10S = Beta1(nf), B20S = Beta2(nf), B30S = gsl_sf_zeta_int(3) * 352864./81. - 598391./1458,
953 B01S = -22./9., B11S = -308./27., B02S = 4945./243.;
954
955 double B00E = 80./9., B01E = 176./9., B10E = 464./27.;
956
957 double B10soB00s = B10S / B00S;
958 double B01soB00e = B01S/B00E;
959
960 double vs= 1. + 2. * B00S * alphatilde_s * log(mu/ mu_0);
961 double ve= 1. - 2. * B00E * alphatilde_e * log(mu/ mu_0);
962 double ps= B00S * alphatilde_s /(B00S * alphatilde_s + B00E * alphatilde_e);
963
964 double logve = log(ve);
965 double logvs = log(vs);
966 double logeos = log(ve/vs);
967 double logsoe = log(vs/ve);
968 double asovs = alphatilde_s/vs;
969 double aeove = alphatilde_e/ve;
970
971 double result = 0;
972
973 result = asovs - pow(asovs, 2) * (logvs * B10soB00s - logve * B01soB00e)
974 + pow(asovs, 3) * ((1. - vs) * B20S / B00S + B10soB00s * B10soB00s * (logvs * logvs - logvs
975 + vs - 1.) + B01soB00e * B01soB00e * logve * logve + (-2. * logvs * logve
976 + ps * ve * logve) * B01S * B10S/(B00E * B00S))
977 + pow(asovs, 4) * (0.5 * B30S *(1. - vs * vs)/ B00S + ((2. * vs - 3.) * logvs + vs * vs
978 - vs) * B20S * B10soB00s /(B00S) + B10soB00s * B10soB00s * B10soB00s * (- pow(logvs,3)
979 + 5. * pow(logvs,2) / 2. + 2. * (1. - vs) * logvs - (vs - 1.) * (vs - 1.)* 0.5))
980 + pow(asovs, 2) * (aeove) * ((ve - 1.) * B02S / B00E
981 + ps * ve * logeos * B11S /B00S +(logve - ve + 1.) * B01soB00e * B10E/(B00E)
982 + logvs * ps * B01S * B10soB00s/(B00S) +(logsoe * ve * ps - logvs) * B01soB00e * B01E/( B00S));
983 return (result);
984}
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\)

Reimplemented in NPbase.

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

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

655{
656 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
657 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
658 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
659 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
660
661 switch(nm)
662 {
663 case 00:
664 return(4./3. * (Qbar2 * Nc + 3.)); // QL^2 = 1
665 case 10:
666 return(4. * (Qbar4 * Nc + 3.));
667 case 01:
668 return(4. * CF * Nc * Qbar2);
669 default:
670 throw std::runtime_error("StandardModel::Beta_e(): case not implemented");
671 }
672}
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 626 of file StandardModel/src/StandardModel.cpp.

627{
628 unsigned int nu = nf % 2 == 0 ? nf / 2 : nf / 2;
629 unsigned int nd = nf % 2 == 0 ? nf / 2 : 1 + nf / 2;
630 double Qu = 2. / 3., Qd = -1. / 3., Qbar2 = nu * Qu * Qu + nd * Qd * Qd,
631 Qbar4 = nu * Qu * Qu * Qu * Qu + nd * Qd * Qd * Qd * Qd;
632
633 switch(nm)
634 {
635 case 00:
636 return(Beta0((double) nf));
637 case 10:
638 return(Beta1((double) nf));
639 case 20:
640 return(Beta2((double) nf));
641 case 30:
642 return(Beta3((double) nf));
643 case 01:
644 return(-4. * TF * Qbar2 );
645 case 11:
646 return((4. * CF - 8. * CA) * TF * Qbar2 );
647 case 02:
648 return(11./3. * TF * Qbar2 * Beta_e(00, nf) + 2. * TF * Qbar4);
649 default:
650 throw std::runtime_error("StandardModel::Beta_s(): case not implemented");
651 }
652}
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 3691 of file StandardModel/src/StandardModel.cpp.

3692{
3693 return GammaHtobb()/GammaHTot();
3694}
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 3681 of file StandardModel/src/StandardModel.cpp.

3682{
3683 return GammaHtocc()/GammaHTot();
3684}
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 3666 of file StandardModel/src/StandardModel.cpp.

3667{
3668 return GammaHtogaga()/GammaHTot();
3669}
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 3646 of file StandardModel/src/StandardModel.cpp.

3647{
3648 return GammaHtogg()/GammaHTot();
3649}
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 3671 of file StandardModel/src/StandardModel.cpp.

3672{
3673 return GammaHtomumu()/GammaHTot();
3674}
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 3686 of file StandardModel/src/StandardModel.cpp.

3687{
3688 return GammaHtoss()/GammaHTot();
3689}
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 3676 of file StandardModel/src/StandardModel.cpp.

3677{
3678 return GammaHtotautau()/GammaHTot();
3679}
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 3656 of file StandardModel/src/StandardModel.cpp.

3657{
3658 return GammaHtoWWstar()/GammaHTot();
3659}
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 3661 of file StandardModel/src/StandardModel.cpp.

3662{
3663 return GammaHtoZga()/GammaHTot();
3664}
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 3651 of file StandardModel/src/StandardModel.cpp.

3652{
3653 return GammaHtoZZstar()/GammaHTot();
3654}
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 1283 of file StandardModel/src/StandardModel.cpp.

1284{
1285 double GammW = GammaW();
1286 double GammWij = GammaW(fi, fj);
1287
1288 return GammWij/GammW;
1289}
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 1014 of file StandardModel/src/StandardModel.cpp.

1015{
1016 return ( 1.0 - s02());
1017}
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 3518 of file StandardModel.h.

3519 {
3520 if (scheme.compare("NORESUM") == 0
3521 || scheme.compare("OMSI") == 0
3522 || scheme.compare("INTERMEDIATE") == 0
3523 || scheme.compare("OMSII") == 0
3524 || scheme.compare("APPROXIMATEFORMULA") == 0)
3525 return true;
3526 else
3527 return false;
3528 }

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

548{
549 return (QCD::CheckFlags());
550}
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 364 of file StandardModel/src/StandardModel.cpp.

365{
366 for (int i = 0; i < NSMvars; i++) {
367 if (DPars.find(SMvars[i]) == DPars.end()) {
368 std::cout << "ERROR: missing mandatory SM parameter " << SMvars[i] << std::endl;
371 }
372 }
373 return (QCD::CheckParameters(DPars));
374}
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 556 of file StandardModel/src/StandardModel.cpp.

557{
558 // 11 parameters in QCD:
559 // AlsMz, Mz, mup, mdown, mcharm, mstrange, mtop, mbottom,
560 // mut, mub, muc
561 // 19 parameters in StandardModel
562 // GF, ale, dAle5Mz, mHl,
563 // mneutrino_1, mneutrino_2, mneutrino_3, melectron, mmu, mtau,
564 // delMw, delSin2th_l, delSin2th_q, delSin2th_b, delGammaZ, delsigma0H, delR0l, delR0c, delR0b,
565 // 3 flags in StandardModel
566 // FlagMw_cache, FlagRhoZ_cache, FlagKappaZ_cache
567
568 // Note: When modifying the array below, the constant NumSMParams has to
569 // be modified accordingly.
570 double SMparams[NumSMParamsForEWPO] = {
572 mHl, mtpole,
577 leptons[MU].getMass(),
579 quarks[UP].getMass(),
584 mut, mub, muc,
589 };
590
591 // check updated parameters
592 bool bNotUpdated = true;
593 for (int i = 0; i < NumSMParamsForEWPO; ++i) {
594 if (SMparamsForEWPO_cache[i] != SMparams[i]) {
595 SMparamsForEWPO_cache[i] = SMparams[i];
596 bNotUpdated &= false;
597 }
598 }
599
600 return bNotUpdated;
601}
@ 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 2946 of file StandardModel.h.

2947 {
2948 return 2.406e-01; // Mh=125.1 GeV
2949 }

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

2914 {
2915 return 1.252e-04; // Mh=125.1 GeV
2916 }

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

2925 {
2926 return 2.771e-04; // Mh=125.1 GeV
2927 }

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

2936 {
2937 return 1.098e-01; // Mh=125.1 GeV
2938 }

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

2870 {
2871 return 1.06e-3;
2872 }

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

2857 {
2858 return 5.807e-1; // Mh=125.1 GeV
2859 //return 5.67e-1; // Mh=125.6 GeV
2860 }

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

2834 {
2835 return 2.883e-2; // Mh=125.1 GeV
2836 //return 2.86e-2; // Mh=125.6 GeV
2837 }

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

2881 {
2882 return 2.539e-03; // Mh=125.1 GeV
2883 }

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

2800 {
2801 return 2.27e-3; // Mh=125.1 GeV
2802 }

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

2753 {
2754 return 8.179e-2; // Mh=125.1 GeV
2755 }

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

2892 {
2893 return 1.063e-02; // Mh=125.1 GeV
2894 }

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

2903 {
2904 return 2.356e-02; // Mh=125.1 GeV
2905 }

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

2811 {
2812 return 2.17e-4; // Mh=125.1 GeV
2813 }

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

2846 {
2847 return 4.0e-4;
2848 }

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

2822 {
2823 return 6.256e-2; // Mh=125.1 GeV
2824 //return 6.22e-2; // Mh=125.6 GeV
2825 }

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

2764 {
2765 //return 2.23e-1; // Mh=125.5 GeV
2766 return 2.154e-1; // Mh=125.1 GeV
2767 }

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

2788 {
2789 return 1.541e-3; // Mh=125.1 GeV
2790 //return 1.59e-3; // Mh=125.6 GeV
2791 }

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

2776 {
2777 return 2.643e-2; // Mh=125.1 GeV
2778 //return 2.79e-2; // Mh=125.6 GeV
2779 }

◆ computeCKM()

void StandardModel::computeCKM ( )
protectedvirtual

The method to compute the CKM matrix.

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

377{
378 if (requireCKM) {
379 if (FlagWolfenstein) {
381 Vus = myCKM.getV_us().abs();
382 Vcb = myCKM.getV_cb().abs();
383 Vub = myCKM.getV_ub().abs();
385 } else if (FlagUseVud) {
388 A = myCKM.getA();
389 rhob = myCKM.getRhoBar();
390 etab = myCKM.getEtaBar();
391 Vus = myCKM.getV_us().abs();
392 } else {
395 A = myCKM.getA();
396 rhob = myCKM.getRhoBar();
397 etab = myCKM.getEtaBar();
398 Vud = myCKM.getV_ud().abs();
399 }
400 }
401 myPMNS.computePMNS(s12, s13, s23, delta, alpha21, alpha31); // WARNING: This does not do anything since the input values are not set.
402}
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 1155 of file StandardModel/src/StandardModel.cpp.

1157{
1158 if (flag_order[EW1])
1159 DeltaR_rem[EW1] = myOneLoopEW->DeltaR_rem(Mw_i);
1160 else
1161 DeltaR_rem[EW1] = 0.0;
1162 if (flag_order[EW1QCD1])
1163 DeltaR_rem[EW1QCD1] = myTwoLoopQCD->DeltaR_rem(Mw_i);
1164 else
1165 DeltaR_rem[EW1QCD1] = 0.0;
1166 if (flag_order[EW1QCD2])
1167 DeltaR_rem[EW1QCD2] = myThreeLoopQCD->DeltaR_rem(Mw_i);
1168 else
1169 DeltaR_rem[EW1QCD2] = 0.0;
1170 if (flag_order[EW2])
1171 DeltaR_rem[EW2] = myTwoLoopEW->DeltaR_rem(Mw_i);
1172 else
1173 DeltaR_rem[EW2] = 0.0;
1174 if (flag_order[EW2QCD1])
1175 DeltaR_rem[EW2QCD1] = myThreeLoopEW2QCD->DeltaR_rem(Mw_i);
1176 else
1177 DeltaR_rem[EW2QCD1] = 0.0;
1178 if (flag_order[EW3])
1179 DeltaR_rem[EW3] = myThreeLoopEW->DeltaR_rem(Mw_i);
1180 else
1181 DeltaR_rem[EW3] = 0.0;
1182}
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 1126 of file StandardModel/src/StandardModel.cpp.

1128{
1129 if (flag_order[EW1])
1130 DeltaRho[EW1] = myOneLoopEW->DeltaRho(Mw_i);
1131 else
1132 DeltaRho[EW1] = 0.0;
1133 if (flag_order[EW1QCD1])
1134 DeltaRho[EW1QCD1] = myTwoLoopQCD->DeltaRho(Mw_i);
1135 else
1136 DeltaRho[EW1QCD1] = 0.0;
1137 if (flag_order[EW1QCD2])
1138 DeltaRho[EW1QCD2] = myThreeLoopQCD->DeltaRho(Mw_i);
1139 else
1140 DeltaRho[EW1QCD2] = 0.0;
1141 if (flag_order[EW2])
1142 DeltaRho[EW2] = myTwoLoopEW->DeltaRho(Mw_i);
1143 else
1144 DeltaRho[EW2] = 0.0;
1145 if (flag_order[EW2QCD1])
1146 DeltaRho[EW2QCD1] = myThreeLoopEW2QCD->DeltaRho(Mw_i);
1147 else
1148 DeltaRho[EW2QCD1] = 0.0;
1149 if (flag_order[EW3])
1150 DeltaRho[EW3] = myThreeLoopEW->DeltaRho(Mw_i);
1151 else
1152 DeltaRho[EW3] = 0.0;
1153}
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 3034 of file StandardModel.h.

3035 {
3036 return 662.84; // in eV for Mh=125 GeV
3037 //return 680.39; // in eV for Mh=126 GeV
3038 }

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

3057 {
3058 return -6249.93; // in eV for Mh=125 GeV
3059 //return -6436.35; // in eV for Mh=126 GeV
3060 }

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

3046 {
3047 return 14731.86; // in eV for Mh=125 GeV
3048 //return 15221.98; // in eV for Mh=126 GeV
3049 }

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

2980 {
2981 return 3.96; // in keV for Mh=125 GeV
2982 //return 3.95; // in keV for Mh=126 GeV
2983 }

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

2991 {
2992 return -42.1; // in keV for Mh=125 GeV
2993 //return -42.7; // in keV for Mh=126 GeV
2994 }

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

2969 {
2970 return 380.8; // in keV for Mh=125 GeV
2971 //return 389.6; // in keV for Mh=126 GeV
2972 }

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

2958 {
2959 return 4.101e-3; // Mh=125.1 GeV
2960 //return 4.15e-3; // Mh=125.6 GeV
2961 }

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

3002 {
3003 return 21.74; // in eV for Mh=125 GeV
3004 //return 23.51; // in eV for Mh=126 GeV
3005 }

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

3024 {
3025 return -780.4; // in eV for Mh=125 GeV
3026 //return -848.1; // in eV for Mh=126 GeV
3027 }

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

3013 {
3014 return 7005.6; // in eV for Mh=125 GeV
3015 //return 7648.4; // in eV for Mh=126 GeV
3016 }

◆ computeSigmabbH()

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

The bbH production cross section in the Standard Model.

Definition at line 2735 of file StandardModel.h.

2736 {
2737 if (sqrt_s == 13.0){
2738 return 0.4863; // in pb for Mh=125.09 GeV
2739 }
2740 else if (sqrt_s == 13.6) {
2741 return 0.566; // in pb for Mh=125.09 GeV (NLO+NNLLpart+ybyt matching)
2742 } else
2743 throw std::runtime_error("Bad argument in StandardModel::computeSigmabbH()");
2744 }

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

2372 {
2373 if (sqrt_s == 7.0) {
2374 return 16.83; // in pb for Mh=125.1 GeV
2375 } else if (sqrt_s == 8.0) {
2376 return 21.40; // in pb for Mh=125.1 GeV
2377 } else if (sqrt_s == 13.0) {
2378 return 48.61; // in pb for Mh=125.09 GeV
2379 } else if (sqrt_s == 13.6) {
2380 return 52.17; // in pb for Mh=125.09 GeV
2381 } else if (sqrt_s == 14.0) {
2382 return 54.72; // in pb for Mh=125.09 GeV
2383 } else if (sqrt_s == 27.0) {
2384 return 146.65; // in pb for Mh=125.09 GeV
2385 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2386 return 740.3; // in pb for Mh=125. GeV
2387 } else if (sqrt_s == 1.96) {
2388 return 0.9493; // in pb for Mh=125 GeV
2389 } else
2390 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH()");
2391 }

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

2434 {
2435 if (sqrt_s == 7.0) {
2436 return 0.04; // in pb for Mh=125.09 GeV
2437 } else if (sqrt_s == 8.0) {
2438 return 0.05; // in pb for Mh=125.09 GeV
2439 } else if (sqrt_s == 13.0) {
2440 return 0.10; // in pb for Mh=125.09 GeV
2441 } else if (sqrt_s == 13.6) {
2442 return 0.106; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2443 } else if (sqrt_s == 14.0) {
2444 return 0.11; // in pb for Mh=125.09 GeV
2445 } else if (sqrt_s == 27.0) {
2446 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2447 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2448 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_bb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2449 } else
2450 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_bb()");
2451 }
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 2463 of file StandardModel.h.

2464 {
2465 if (sqrt_s == 7.0) {
2466 return -0.66; // in pb for Mh=125.09 GeV
2467 } else if (sqrt_s == 8.0) {
2468 return -0.82; // in pb for Mh=125.09 GeV
2469 } else if (sqrt_s == 13.0) {
2470 return -1.73; // in pb for Mh=125.09 GeV
2471 } else if (sqrt_s == 13.6) {
2472 return -1.844; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2473 } else if (sqrt_s == 14.0) {
2474 return -1.92; // in pb for Mh=125.09 GeV
2475 } else if (sqrt_s == 27.0) {
2476 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2477 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2478 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tb(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2479 } else
2480 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tb()");
2481 }
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 2403 of file StandardModel.h.

2404 {
2405 if (sqrt_s == 7.0) {
2406 return 16.69; // in pb for Mh=125.09 GeV
2407 } else if (sqrt_s == 8.0) {
2408 return 21.20; // in pb for Mh=125.09 GeV
2409 } else if (sqrt_s == 13.0) {
2410 return 47.94; // in pb for Mh=125.09 GeV
2411 } else if (sqrt_s == 13.6) {
2412 return 51.534; // in pb for Mh=125.09 GeV (interpolation between 13 and 14 TeV)
2413 } else if (sqrt_s == 14.0) {
2414 return 53.93; // in pb for Mh=125.09 GeV
2415 } else if (sqrt_s == 27.0) {
2416 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2417 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2418 return computeSigmaggH(sqrt_s) / computeSigmaggH(14.) * computeSigmaggH_tt(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2419 } else
2420 throw std::runtime_error("Bad argument in StandardModel::computeSigmaggH_tt()");
2421 }
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 2716 of file StandardModel.h.

2717 {
2718 if (sqrt_s == 13.0) {
2719 return 0.07426; // in pb for Mh=125.09 GeV
2720 } else
2721 throw std::runtime_error("Bad argument in StandardModel::computeSigmatHq()");
2722 }

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

2687 {
2688 if (sqrt_s == 7.0) {
2689 return 0.0861; // in pb for Mh=125.1 GeV
2690 //return 0.0851; // in pb for Mh=125.6 GeV
2691 } else if (sqrt_s == 8.0) {
2692 return 0.129; // in pb for Mh=125.1 GeV
2693 //return 0.1274; // in pb for Mh=125.6 GeV
2694 } else if (sqrt_s == 13.0) {
2695 return 0.5060; // in pb for Mh=125.1 GeV
2696 } else if (sqrt_s == 13.6) {
2697 return 0.5688; // in pb for Mh=125.09 GeV
2698 } else if (sqrt_s == 14.0) {
2699 return 0.6128; // in pb for Mh=125.09 GeV
2700 } else if (sqrt_s == 27.0) {
2701 return 2.86; // in pb for Mh=125.09 GeV
2702 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2703 return 37.9; // in pb for Mh=125. GeV
2704 } else if (sqrt_s == 1.96) {
2705 return 0.0043; // in pb for Mh=125 GeV
2706 } else
2707 throw std::runtime_error("Bad argument in StandardModel::computeSigmattH()");
2708 }

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

2497 {
2498 if (sqrt_s == 7.0) {
2499 return 1.241; // in pb for Mh=125.09 GeV
2500 } else if (sqrt_s == 8.0) {
2501 return 1.601; // in pb for Mh=125.09 GeV
2502 } else if (sqrt_s == 13.0) {
2503 return 3.766; // in pb for Mh=125.09 GeV
2504 } else if (sqrt_s == 13.6) {
2505 return 4.075; // in pb for Mh=125.09 GeV
2506 } else if (sqrt_s == 14.0) {
2507 return 4.260; // in pb for Mh=125.09 GeV
2508 } else if (sqrt_s == 27.0) {
2509 return 11.838; // in pb for Mh=125.09 GeV
2510 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2511 return 82.0; // in pb for Mh=125. GeV
2512 } else if (sqrt_s == 1.96) {
2513 return 0.0653; // in pb for Mh=125 GeV
2514 } else
2515 throw std::runtime_error("Bad argument in StandardModel::computeSigmaVBF()");
2516 }

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

2530 {
2531 if (sqrt_s == 7.0) {
2532 return 0.946; // in pb for Mh=125 GeV
2533 } else if (sqrt_s == 8.0) {
2534 return 1.220; // in pb for Mh=125 GeV
2535 } else if (sqrt_s == 13.0) {
2536 return 2.882; // in pb for Mh=125 GeV
2537 } else if (sqrt_s == 13.6) {
2538 return 3.1088; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2539 } else if (sqrt_s == 14.0) {
2540 return 3.260; // in pb for Mh=125 GeV
2541 } else if (sqrt_s == 27.0) {
2542 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2543 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2544 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaWF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2545 } else if (sqrt_s == 1.96) {
2546 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaWF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2547 } else
2548 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWF()");
2549 }
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 2609 of file StandardModel.h.

2610 {
2611 if (sqrt_s == 7.0) {
2612 return 0.577; // in pb for Mh=125.1 GeV
2613 //return 0.5688; // in pb for Mh=125.6 GeV
2614 } else if (sqrt_s == 8.0) {
2615 return 0.7027; // in pb for Mh=125.1 GeV
2616 //return 0.6931; // in pb for Mh=125.6 GeV
2617 } else if (sqrt_s == 13.0) {
2618 return 1.358; // in pb for Mh=125.09 GeV
2619 } else if (sqrt_s == 13.6) {
2620 return 1.453; // in pb for Mh=125.09 GeV
2621 } else if (sqrt_s == 14.0) {
2622 return 1.498; // in pb for Mh=125.09 GeV
2623 } else if (sqrt_s == 27.0) {
2624 return 3.397; // in pb for Mh=125.09 GeV
2625 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2626 return 15.9; // in pb for Mh=125. GeV
2627 } else if (sqrt_s == 1.96) {
2628 return 0.1295; // in pb for Mh=125 GeV
2629 } else
2630 throw std::runtime_error("Bad argument in StandardModel::computeSigmaWH()");
2631 }

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

2563 {
2564 if (sqrt_s == 7.0) {
2565 return 0.333; // in pb for Mh=125 GeV
2566 } else if (sqrt_s == 8.0) {
2567 return 0.432; // in pb for Mh=125 GeV
2568 } else if (sqrt_s == 13.0) {
2569 return 1.049; // in pb for Mh=125 GeV
2570 } else if (sqrt_s == 13.6) {
2571 return 1.1342; // in pb for Mh=125 GeV (interpolation between 13 and 14 TeV)
2572 } else if (sqrt_s == 14.0) {
2573 return 1.191; // in pb for Mh=125 GeV
2574 } else if (sqrt_s == 27.0) {
2575 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2576 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2577 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(14.) * computeSigmaZF(14.); // in the absence of this value we rescale the LHC result at 14 TeV
2578 } else if (sqrt_s == 1.96) {
2579 return computeSigmaVBF(sqrt_s) / computeSigmaVBF(7.) * computeSigmaZF(7.); // in the absence of individual cross sections for TeVatron we rescale the LHC ones
2580 } else
2581 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZF()");
2582 }
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 2646 of file StandardModel.h.

2647 {
2648 if (sqrt_s == 7.0) {
2649 return 0.3341; // in pb for Mh=125.1 GeV
2650 //return 0.3299; // in pb for Mh=125.6 GeV
2651 } else if (sqrt_s == 8.0) {
2652 return 0.4142; // in pb for Mh=125.1 GeV
2653 //return 0.4091; // in pb for Mh=125.6 GeV
2654 } else if (sqrt_s == 13.0) {
2655 return 0.880; // in pb for Mh=125.09 GeV
2656 } else if (sqrt_s == 13.6) {
2657 return 0.9422; // in pb for Mh=125.09 GeV
2658 } else if (sqrt_s == 14.0) {
2659 return 0.981; // in pb for Mh=125.09 GeV
2660 } else if (sqrt_s == 27.0) {
2661 return 2.463; // in pb for Mh=125.09 GeV
2662 } else if ( (sqrt_s == 84.0) || (sqrt_s == 100.0) ) {
2663 return 11.26; // in pb for Mh=125. GeV
2664 } else if (sqrt_s == 1.96) {
2665 return 0.0785; // in pb for Mh=125 GeV
2666 } else
2667 throw std::runtime_error("Bad argument in StandardModel::computeSigmaZH()");
2668 }

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

2592 {
2593 return 0.;
2594 }

◆ computeYukawas()

void StandardModel::computeYukawas ( )
protectedvirtual

The method to compute the Yukawas matrix.

Reimplemented in SUSY.

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

411{
412 if (requireYu || requireCKM) {
413 Yu.reset();
414 for (int i = 0; i < 3; i++) {
415 Yu.assign(i, i, this->getmq(quark(UP + 2 * i), v()/ sqrt(2.))/ v() * sqrt(2.));
416// std::cout << quarks[UP + 2 * i].getName() << " mass at EW scale is " << this->getmq(quark(UP + 2 * i), v() / sqrt(2.)) << std::endl;
417 }
418// std::cout << "(top MSbar mass is " << this->Mp2Mbar(this->getMtpole()) << ")" << std::endl;
419 Yu = Yu * myCKM.getCKM();
420 }
421 if (requireYd) {
422 Yd.reset();
423 for (int i = 0; i < 3; i++) {
424 Yd.assign(i, i, this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) / v() * sqrt(2.));
425// std::cout << quarks[DOWN + 2 * i].getName() << " mass at " << v() / sqrt(2) << " is " << this->getmq(quark(DOWN + 2 * i), v() / sqrt(2.)) << std::endl;
426 }
427 }
428 if (requireYe) {
429 Ye = gslpp::matrix<gslpp::complex>::Id(3);
430 for (int i = 0; i < 3; i++)
431 Ye.assign(i, i, this->leptons[ELECTRON + 2 * i].getMass() / v() * sqrt(2.));
432 }
433 if (requireYn) {
434 Yn = gslpp::matrix<gslpp::complex>::Id(3);
435 for (int i = 0; i < 3; i++)
436 Yn.assign(i, i, this->leptons[NEUTRINO_1 + 2 * i].getMass() / v() * sqrt(2.));
437 Yn = Yn * myPMNS.getPMNS().hconjugate();
438 }
439}
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 1081 of file StandardModel/src/StandardModel.cpp.

1082{
1083 return ( cW2(Mw()));
1084// return (1.0 - 0.2312); // FOR HEFFDF1 TEST
1085}

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

1077{
1078 return ( Mw_i * Mw_i / Mz / Mz);
1079}

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

1069{
1070 if (FlagMWinput){
1072 } else
1073 return dAle5Mz;
1074}
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 2133 of file StandardModel/src/StandardModel.cpp.

2134{
2135 switch (q) {
2136 case QCD::UP:
2137 case QCD::CHARM:
2138 return ( -0.000113);
2139 case QCD::TOP:
2140 return ( 0.0);
2141 case QCD::DOWN:
2142 case QCD::STRANGE:
2143 return ( -0.000160);
2144 case QCD::BOTTOM:
2145 return ( -0.000040);
2146 default:
2147 throw std::runtime_error("Error in StandardModel::Delta_EWQCD");
2148 }
2149}
@ 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 926 of file StandardModel/src/StandardModel.cpp.

927{
930 return DeltaAlpha_cache;
931
932 double Mz2 = Mz*Mz;
934 useDeltaAlpha_cache = true;
935 return DeltaAlpha_cache;
936}
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 901 of file StandardModel/src/StandardModel.cpp.

902{
903 double Mz2 = Mz*Mz;
904 return (DeltaAlphaLepton(Mz2) + dAl5hMz);
905}
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 873 of file StandardModel/src/StandardModel.cpp.

874{
875 if (s == Mz * Mz)
879
880 double DeltaAlphaL = 0.0;
881 if (flag_order[EW1])
882 DeltaAlphaL += myOneLoopEW->DeltaAlpha_l(s);
883 if (flag_order[EW1QCD1])
884 DeltaAlphaL += myTwoLoopQCD->DeltaAlpha_l(s);
885 if (flag_order[EW1QCD2])
886 DeltaAlphaL += myThreeLoopQCD->DeltaAlpha_l(s);
887 if (flag_order[EW2])
888 DeltaAlphaL += myTwoLoopEW->DeltaAlpha_l(s);
889 if (flag_order[EW2QCD1])
890 DeltaAlphaL += myThreeLoopEW2QCD->DeltaAlpha_l(s);
891 if (flag_order[EW3])
892 DeltaAlphaL += myThreeLoopEW->DeltaAlpha_l(s);
893
894 if (s == Mz * Mz) {
895 DeltaAlphaLepton_cache = DeltaAlphaL;
897 }
898 return DeltaAlphaL;
899}
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 907 of file StandardModel/src/StandardModel.cpp.

908{
909 double DeltaAlpha = 0.0;
910 if (flag_order[EW1])
912 if (flag_order[EW1QCD1])
914 if (flag_order[EW1QCD2])
916 if (flag_order[EW2])
918 if (flag_order[EW2QCD1])
920 if (flag_order[EW3])
922
923 return DeltaAlpha;
924}
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 1764 of file StandardModel/src/StandardModel.cpp.

1765{
1766 Particle p1 = f, pe = leptons[ELECTRON];
1767
1768 if (f.is("TOP") || f.is("ELECTRON")) return (gslpp::complex(0.0, 0.0, false));
1769
1770 /* In the case of BOTTOM, the top contribution has to be subtracted.
1771 * The remaining contribution is the same as that for DOWN and STRANGE. */
1772 if (f.is("BOTTOM")) p1 = quarks[DOWN];
1773
1774 double myMw = Mw();
1775 double cW2 = myMw * myMw / Mz / Mz, sW2 = 1.0 - cW2;
1776 gslpp::complex ul = (3.0 * myEWSMcache->v_f(pe, myMw) * myEWSMcache->v_f(pe, myMw)
1777 + myEWSMcache->a_f(pe) * myEWSMcache->a_f(pe)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1778 + myOneLoopEW->FW(Mz*Mz, pe, myMw);
1779 double deltal = myEWSMcache->delta_f(pe, myMw);
1780 gslpp::complex uf = (3.0 * myEWSMcache->v_f(p1, myMw) * myEWSMcache->v_f(p1, myMw)
1781 + myEWSMcache->a_f(p1) * myEWSMcache->a_f(p1)) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1782 + myOneLoopEW->FW(Mz*Mz, p1, myMw);
1783 double deltaf = myEWSMcache->delta_f(p1, myMw);
1784
1785 gslpp::complex dKappa = (deltaf * deltaf - deltal * deltal) / 4.0 / cW2 * myOneLoopEW->FZ(Mz*Mz, myMw)
1786 - uf + ul;
1787 dKappa *= ale / 4.0 / M_PI / sW2;
1788 return dKappa;
1789}
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 1112 of file StandardModel/src/StandardModel.cpp.

1113{
1114 /* in the experimental/running-width scheme */
1115 double myMw = Mw();
1116 double sW2 = 1.0 - myMw * myMw / Mz / Mz;
1117 double tmp = sqrt(2.0) * GF * sW2 * myMw * myMw / M_PI / ale;
1118 if (FlagMw.compare("NORESUM") == 0
1119 || FlagMw.compare("APPROXIMATEFORMULA") == 0) {
1120 return (tmp - 1.0);
1121 } else {
1122 return (1.0 - 1.0 / tmp);
1123 }
1124}

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

1223{
1224 double Mwbar_SM = MwbarFromMw(Mw());
1225 double sW2bar = 1.0 - Mwbar_SM * Mwbar_SM / Mzbar() / Mzbar();
1226 double tmp = sqrt(2.0) * GF * sW2bar * Mwbar_SM * Mwbar_SM / M_PI / ale;
1227
1228 return (tmp - 1.0);
1229}
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 1739 of file StandardModel/src/StandardModel.cpp.

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

◆ eeffAFBbottom()

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

Reimplemented in NPbase.

Definition at line 3257 of file StandardModel.h.

3258 {
3259 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) );
3260 }
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

Reimplemented in NPbase.

Definition at line 3253 of file StandardModel.h.

3254 {
3255 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) );
3256 }

◆ eeffAFBe()

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

Reimplemented in NPbase.

Definition at line 3227 of file StandardModel.h.

3228 {
3229 double cosmin = -0.90; // As in LEP2
3230 double cosmax = 0.90; // As in LEP2
3231
3232 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));
3233 }
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

Reimplemented in NPbase.

Definition at line 3234 of file StandardModel.h.

3235 {
3236 double cosmin = -0.90; // As in LEP2
3237 double cosmax = 0.90; // As in LEP2
3238
3239 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) );
3240 }

◆ eeffAFBmu()

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

Reimplemented in NPbase.

Definition at line 3241 of file StandardModel.h.

3242 {
3243 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) );
3244 }

◆ eeffAFBstrange()

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

Reimplemented in NPbase.

Definition at line 3249 of file StandardModel.h.

3250 {
3251 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) );
3252 }

◆ eeffAFBtau()

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

Reimplemented in NPbase.

Definition at line 3245 of file StandardModel.h.

3246 {
3247 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) );
3248 }

◆ eeffRbottom()

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

Reimplemented in NPbase.

Definition at line 3220 of file StandardModel.h.

3221 {
3222 return ( eeffsigmaBottom(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3223 }
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

Reimplemented in NPbase.

Definition at line 3216 of file StandardModel.h.

3217 {
3218 return ( eeffsigmaCharm(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3219 }
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

Reimplemented in NPbase.

Definition at line 3196 of file StandardModel.h.

3197 {
3198 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaE(pol_e, pol_p, s) );
3199 }
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

Reimplemented in NPbase.

Definition at line 3200 of file StandardModel.h.

3201 {
3202 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaEtsub(pol_e, pol_p, s) );
3203 }
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

Reimplemented in NPbase.

Definition at line 3204 of file StandardModel.h.

3205 {
3206 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaMu(pol_e, pol_p, s) );
3207 }
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

Reimplemented in NPbase.

Definition at line 3212 of file StandardModel.h.

3213 {
3214 return ( eeffsigmaStrange(pol_e, pol_p, s) / eeffsigmaHadron(pol_e, pol_p, s) );
3215 }
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

Reimplemented in NPbase.

Definition at line 3208 of file StandardModel.h.

3209 {
3210 return ( eeffsigmaHadron(pol_e, pol_p, s) / eeffsigmaTau(pol_e, pol_p, s) );
3211 }
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

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

4048 {
4049 // Only valid for f=/=e (MLL2, MRR2 do not depend on t for f=/=e. Simply enter t=1 as argument)
4050 // For f=e this corresponds to t-subtracted definition from LEP
4051 double sumM2, sigma;
4052 double tdumm = 1.;
4053 double topb = 0.3894e+9;
4054
4055 //double cosmin = -1.0;
4056 //double cosmax = 1.0;
4057
4058 double Nf;
4059
4060 double pLH, pRH; //Polarization factors, minus the 1/4 average
4061
4062 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4063 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4064
4065 if (f.is("LEPTON")) {
4066 Nf = 1.0;
4067 } else {
4068 Nf = 3.0;
4069 }
4070
4071 sumM2 = (pLH * MLR2eeff(f, s) + pRH * MRL2eeff(f, s)) * tovers2(cosmin, cosmax)
4072 + (pLH * MLL2eeff(f, s, tdumm) + pRH * MRR2eeff(f, s, tdumm)) * uovers2(cosmin, cosmax);
4073
4074 sigma = Nf * 0.5 * M_PI * (alphaMz())*(alphaMz()) * sumM2 / s;
4075
4076 return topb * sigma;
4077}
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

Reimplemented in NPbase.

Definition at line 3189 of file StandardModel.h.

3190 {
3191 return eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0);
3192 }

◆ eeffsigmaCharm()

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

Reimplemented in NPbase.

Definition at line 3184 of file StandardModel.h.

3185 {
3186 return eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0);
3187 }

◆ eeffsigmaE()

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

Reimplemented in NPbase.

Definition at line 3144 of file StandardModel.h.

3145 {
3146 double cosmin = -0.90; // As in LEP2
3147 double cosmax = 0.90; // As in LEP2
3148
3149 return eeffsigmaEbin(pol_e, pol_p, s, cosmin, cosmax);
3150 }

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

4019 {
4020
4021 double sumM2, sigma;
4022 double topb = 0.3894e+9;
4023 double t0, t1, lambdaK;
4024
4025 double pLH, pRH; //Polarization factors, minus the 1/4 average
4026
4027 pLH = (1.0 - pol_e) * (1.0 + pol_p);
4028 pRH = (1.0 + pol_e) * (1.0 - pol_p);
4029
4030 // t values for cosmin and cosmax
4031 t0 = 0.5 * s * ( -1.0 + cosmin );
4032 t1 = 0.5 * s * ( -1.0 + cosmax );
4033
4034 // Kähllén function of (s,0,0)
4035 lambdaK = s*s;
4036
4037 // Sum of the integrals of the amplitudes squared x (t/s)^2, (s/t)^2, (u/s)^2
4038 sumM2 = (pLH + pRH) * ( intMLR2eeeets2(s, t0, t1) + intMLRtilde2eeeest2(s, t0, t1) ) +
4039 pLH * intMLL2eeeeus2(s, t0, t1) + pRH * intMRR2eeeeus2(s, t0, t1);
4040
4041 // Build the cross section
4042 sigma = M_PI * (alphaMz())*(alphaMz()) * sumM2 / s / sqrt(lambdaK);
4043
4044 return topb * sigma;
4045
4046}
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

Reimplemented in NPbase.

Definition at line 3154 of file StandardModel.h.

3155 {
3156 double cosmin = -0.90; // As in LEP2
3157 double cosmax = 0.90; // As in LEP2
3158
3159 return eeffsigma(leptons[ELECTRON], pol_e, pol_p, s, cosmin, cosmax);
3160 }

◆ eeffsigmaHadron()

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

Reimplemented in NPbase.

Definition at line 3172 of file StandardModel.h.

3173 {
3174 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)
3175 + eeffsigma(quarks[CHARM], pol_e, pol_p, s, -1.0, 1.0) + eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0)
3176 + eeffsigma(quarks[BOTTOM], pol_e, pol_p, s, -1.0, 1.0) );
3177 }

◆ eeffsigmaMu()

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

Reimplemented in NPbase.

Definition at line 3162 of file StandardModel.h.

3163 {
3164 return eeffsigma(leptons[MU], pol_e, pol_p, s, -1.0, 1.0);
3165 }

◆ eeffsigmaStrange()

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

Reimplemented in NPbase.

Definition at line 3179 of file StandardModel.h.

3180 {
3181 return eeffsigma(quarks[STRANGE], pol_e, pol_p, s, -1.0, 1.0);
3182 }

◆ eeffsigmaTau()

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

Reimplemented in NPbase.

Definition at line 3167 of file StandardModel.h.

3168 {
3169 return eeffsigma(leptons[TAU], pol_e, pol_p, s, -1.0, 1.0);
3170 }

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

1795{
1796 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1797 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1798
1799 return DeltaRhoPrime;
1800}
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 1802 of file StandardModel/src/StandardModel.cpp.

1803{
1804 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1805 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1806 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1807 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1808 double DeltaRW = 1.0 - M_PI * alphaMz() / (sqrt(2.0) * GF * Mz * Mz * sW2() * cW2());
1809
1810 return ( c02() * DeltaRhoPrime + s02() * DeltaRW / (c02() - s02())
1811 - 2.0 * s02() * DeltaKappaPrime);
1812}
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 1814 of file StandardModel/src/StandardModel.cpp.

1815{
1816 double rhoZe = rhoZ_f(leptons[ELECTRON]).real();
1817 double sin2thetaEff = kappaZ_f(leptons[ELECTRON]).real() * sW2();
1818 double DeltaRhoPrime = 2.0 * (sqrt(rhoZe) - 1.0);
1819 double DeltaKappaPrime = sin2thetaEff / s02() - 1.0;
1820
1821 return ( c02() * DeltaRhoPrime + (c02() - s02()) * DeltaKappaPrime);
1822}

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

1825{
1826 /* epsilon_b from g_A^b
1827 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1828 //double rhoZe = rhoZ_l_SM(StandardModel::ELECTRON).real();
1829 //double rhoZb = rhoZ_q_SM(QCD::BOTTOM).real();
1830 //double DeltaRhoPrime = 2.0*( sqrt(rhoZe) - 1.0 );
1831 //double eps1 = DeltaRhoPrime;
1832 //return ( - 1.0 + sqrt(rhoZb)/(1.0 + eps1/2.0) );
1833
1834 /* epsilon_b from Re(g_V^b/g_A^b), i.e. Re(kappaZ_b)
1835 * see Eq.(13) of IJMP A7, 1031 (1998) by Altarelli et al. */
1836 gslpp::complex kappaZe = kappaZ_f(leptons[ELECTRON]);
1837 gslpp::complex kappaZb = kappaZ_f(quarks[BOTTOM]);
1839 return ( kappaZe.real() / kappaZb.real() - 1.0);
1840 else
1841 return ( (kappaZe.real() + deltaKappaZ_f(quarks[BOTTOM]).real())
1842 / kappaZb.real() - 1.0);
1843
1844 /* epsilon_b from Gamma_b via Eqs.(11), (12) and (16) of IJMP A7,
1845 * 1031 (1998) by Altarelli et al.
1846 * Note: mb has to be mb=4.7, since Eq.(16) were derived with this value.
1847 */
1848 //double als_Mz = Als(myCache->Mz(), FULLNNLO);
1849 //double delta_als = (als_Mz - 0.119)/M_PI;
1850 //double delta_alpha = (alphaMz() - 1.0/128.90)/myCache->ale();
1851 //double Gamma_b_Born = 0.3798*( 1.0 + delta_als - 0.42*delta_alpha);
1852 //double a = als_Mz/M_PI;
1853 //double RQCD = 1.0 + 1.2*a - 1.1*a*a - 13.0*a*a*a;
1854 //double mb = Mrun(myCache->Mz(), quarks[QCD::BOTTOM].getMass(), FULLNNLO);// This is wrong!
1855 //double mb = 4.7;
1856 //std::cout << "mb = " << mb << std::endl;
1857 //double beta = sqrt(1.0 - 4.0*mb*mb/myCache->Mz()/myCache->Mz());
1858 //double Nc = 3.0;
1859 //double factor = myCache->GF()*myCache->Mz()*myCache->Mz()*myCache->Mz()/6.0/M_PI/sqrt(2.0);
1860 //double Gamma_b = factor*beta*((3.0 - beta*beta)/2.0*gVq_SM(QCD::BOTTOM).abs2()
1861 // + beta*beta*gAq_SM(QCD::BOTTOM).abs2())
1862 // *Nc*RQCD*(1.0 + alphaMz()/12.0/M_PI);
1863 //return ( (Gamma_b/Gamma_b_Born - 1.0 - 1.42*epsilon1_SM()
1864 // + 0.54*epsilon3_SM() )/2.29 );
1865}
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#4708, with \(M\) the mass of the particle in the loop.

Returns
\(f(\tau)\)

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

3256 {
3257 gslpp::complex tmp;
3258 if (tau >= 1.0) {
3259 tmp = asin(1.0 / sqrt(tau));
3260 return (tmp * tmp);
3261 } else {
3262 tmp = log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i();
3263 return (-0.25 * tmp * tmp);
3264 }
3265}

◆ 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#4708, with \(M\) the mass of the particle in the loop.

Returns
\(g(\tau)\)

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

3267 {
3268 gslpp::complex tmp;
3269 if (tau >= 1.0) {
3270 tmp = sqrt(tau - 1.0) * asin(1.0 / sqrt(tau));
3271 return tmp;
3272 } else {
3273 tmp = sqrt(1.0 - tau) * (log((1.0 + sqrt(1.0 - tau)) / (1.0 - sqrt(1.0 - tau))) - M_PI * gslpp::complex::i());
3274 return 0.5 * tmp;
3275 }
3276}

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

1584{
1585 return ( sqrt(rhoZ_f(f)) * f.getIsospin());
1586}
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 1411 of file StandardModel/src/StandardModel.cpp.

1412{
1413 double Gamma_had_tmp = 0.0;
1414
1416
1417 /* SM contribution with the approximate formula */
1418 return myApproximateFormulae->X_full("Gamma_had");
1419
1420 } else {
1421
1422 Gamma_had_tmp = GammaZ(quarks[UP]) + GammaZ(quarks[DOWN]) + GammaZ(quarks[CHARM])
1424
1425 /* Singlet vector contribution (not included in the approximate formula) */
1426 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1427 Gamma_had_tmp += 4.0 * 3.0 * G0 * RVh();
1428
1429 return Gamma_had_tmp;
1430 }
1431}
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 1405 of file StandardModel/src/StandardModel.cpp.

1406{
1409}

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

3089{
3090 double Gamma;
3091 double me, mmu, x, Fx, H1x, H2x, H3x, zeta3;
3092 double alpha, rEW;
3093 double pi2;
3094
3095 me = leptons[ELECTRON].getMass();
3096 mmu = leptons[MU].getMass();
3097 pi2 = M_PI*M_PI;
3098
3099 x = me*me/mmu/mmu;
3100 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3101
3102 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3103
3104 zeta3 = 1.2020569031595942;
3105
3106 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);
3107
3108 H3x = -15.3;
3109
3110 // alpha(m_mu)
3111 alpha = 1./ale - log(x)/3./M_PI; // + 1./6./M_PI;
3112 alpha = 1./alpha;
3113
3114 // Rad. corrections
3115 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3116
3117 // Gamma: PDG formula
3118 Gamma = GF*GF*pow(mmu,5)*Fx*rEW/192./pow(M_PI,3);
3119
3120 return Gamma;
3121}
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 3128 of file StandardModel/src/StandardModel.cpp.

3129{
3130 double Gamma;
3131 double ml, mtau, x, Fx, H1x, H2x, H3x, zeta3;
3132 double alpha, rEW;
3133 double pi2;
3134
3135 ml = l.getMass();
3136 mtau = leptons[TAU].getMass();
3137 pi2 = M_PI*M_PI;
3138
3139 x = ml*ml/mtau/mtau;
3140 Fx = 1. - 8. * x + 8. * x*x*x - x*x*x*x -12. * x*x * log(x);
3141
3142 H1x = 25./8. - pi2/2. - (9. + 4. *pi2 + 12. * log(x) )*x + 16. * pi2 * pow(x,3./2.);
3143
3144 zeta3 = 1.2020569031595942;
3145
3146 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);
3147
3148 H3x = -15.3;
3149
3150 // alpha(m_tau)
3151 alpha = 1./133.29; // Improve
3152
3153 // Rad. corrections
3154 rEW = 1. + H1x * alpha/M_PI + H2x * alpha*alpha/pi2 + H3x * alpha * alpha *alpha/pi2/M_PI;
3155
3156 // Gamma: PDG formula
3157 Gamma = GF*GF*pow(mtau,5)*Fx*rEW/192./pow(M_PI,3);
3158
3159 return Gamma;
3160}

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

1434{
1436
1437 /* SM contribution with the approximate formula */
1438 return myApproximateFormulae->X_full("GammaZ");
1439
1440 } else {
1442 + Gamma_inv() + Gamma_had());
1443 }
1444}
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 3604 of file StandardModel/src/StandardModel.cpp.

3605{
3606 double mf0=quarks[BOTTOM].getMass(), mf;
3607 double beta;
3608 double Nc=3.0;
3609 double gamma;
3610 double asMH,DeltaQCD,Deltamt,NF;
3611
3612 // alfa_s(MH)
3613 asMH = Als(mHl, FULLNLO);
3614
3615 mf = Mrun(mHl, mf0, mf0, BOTTOM, FULLNLO);
3616
3617 beta=1.0-4.0*mf*mf/mHl/mHl;
3618
3619 NF=5;
3620
3621 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) ) );
3622
3623 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) );
3624
3625 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3626
3627 return gamma;
3628}
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 3552 of file StandardModel/src/StandardModel.cpp.

3553{
3554 double mf0=quarks[CHARM].getMass(), mf;
3555 double beta;
3556 double Nc=3.0;
3557 double gamma;
3558 double asMH,DeltaQCD,Deltamt,NF;
3559
3560 // alfa_s(MH)
3561 asMH = Als(mHl, FULLNLO);
3562
3563 mf = Mrun(mHl, mf0, mf0, CHARM, FULLNLO);
3564
3565 beta=1.0-4.0*mf*mf/mHl/mHl;
3566
3567 NF=5;
3568
3569 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) ) );
3570
3571 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) );
3572
3573 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3574
3575 return gamma;
3576}

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

3486{
3487 double gamma;
3488
3489 double m_t = mtpole;
3490 double m_b = quarks[BOTTOM].getMass();
3491 double m_c = quarks[CHARM].getMass();
3492 double m_s = quarks[STRANGE].getMass();
3493 double m_tau = leptons[TAU].getMass();
3494 double m_mu = leptons[MU].getMass();
3495
3496 double M_w_2 = pow(Mw(),2.0);
3497
3498 double Qt = quarks[TOP].getCharge();
3499 double Qb = quarks[BOTTOM].getCharge();
3500 double Qc = quarks[CHARM].getCharge();
3501 double Qs = quarks[STRANGE].getCharge();
3502 double Qtau = leptons[TAU].getCharge();
3503 double Qmu = leptons[MU].getCharge();
3504
3505 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3506 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3507 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3508 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3509 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3510 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3511 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3512
3513 gslpp::complex MSM;
3514
3515 MSM = ale * (3.0 * Qt * Qt * AH_f(tau_t) +
3516 3.0 * Qb * Qb * AH_f(tau_b) +
3517 3.0 * Qc * Qc * AH_f(tau_c) +
3518 3.0 * Qs * Qs * AH_f(tau_s) +
3519 Qtau * Qtau * AH_f(tau_tau) +
3520 Qmu * Qmu * AH_f(tau_mu) +
3521 AH_W(tau_W));
3522
3523 gamma = (4.0*GF/sqrt(2)) * (MSM.abs2()) * pow(mHl,3.0)/512.0/pow(M_PI,3);
3524
3525 return gamma;
3526}
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 3362 of file StandardModel/src/StandardModel.cpp.

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

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

3529{
3530 double mf=leptons[MU].getMass();
3531 double beta=1.0-4.0*mf*mf/mHl/mHl;
3532 double Nc=1.0;
3533 double gamma;
3534
3535 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3536
3537 return gamma;
3538}

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

3579{
3580 double mf0=quarks[STRANGE].getMass(), mf;
3581 double beta;
3582 double Nc=3.0;
3583 double gamma;
3584 double asMH,DeltaQCD,Deltamt,NF;
3585
3586 // alfa_s(MH)
3587 asMH = Als(mHl, FULLNLO);
3588
3589 mf = Mrun(mHl, 2.0, mf0, STRANGE, FULLNLO);
3590
3591 beta=1.0-4.0*mf*mf/mHl/mHl;
3592
3593 NF=5;
3594
3595 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) ) );
3596
3597 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) );
3598
3599 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta * (DeltaQCD + Deltamt);
3600
3601 return gamma;
3602}

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

3631{
3632 double gamma;
3633
3634 gamma = GammaHtobb() + GammaHtocc() + GammaHtoss() +
3638
3639 return gamma;
3640}

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

3541{
3542 double mf=leptons[TAU].getMass();
3543 double beta=1.0-4.0*mf*mf/mHl/mHl;
3544 double Nc=1.0;
3545 double gamma;
3546
3547 gamma = Nc * (4.0*GF/sqrt(2.0)) * (mf*mf/16.0/M_PI) * mHl * beta*beta*beta;
3548
3549 return gamma;
3550}

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

3411{
3412 double x=Mw()/mHl;
3413 double fx;
3414 double g2 = 4.0 * sqrt(2.0) * GF * pow(Mw(),2);
3415 double gamma;
3416
3417 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3418 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3419 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);
3420
3421 gamma = 3.0 * g2*g2 * mHl * fx / 512.0 / pow(M_PI,3.0);
3422
3423 return gamma;
3424}

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

3427{
3428 double gamma;
3429
3430 double m_t = mtpole;
3431 double m_b = quarks[BOTTOM].getMass();
3432 double m_c = quarks[CHARM].getMass();
3433 double m_s = quarks[STRANGE].getMass();
3434 double m_tau = leptons[TAU].getMass();
3435 double m_mu = leptons[MU].getMass();
3436
3437 double M_w_2 = pow(Mw(),2.0);
3438
3439 double Qt = quarks[TOP].getCharge();
3440 double Qb = quarks[BOTTOM].getCharge();
3441 double Qc = quarks[CHARM].getCharge();
3442 double Qs = quarks[STRANGE].getCharge();
3443 double Qtau = leptons[TAU].getCharge();
3444 double Qmu = leptons[MU].getCharge();
3445
3446 double tau_t = 4.0 * m_t * m_t / mHl / mHl;
3447 double tau_b = 4.0 * m_b * m_b / mHl / mHl;
3448 double tau_c = 4.0 * m_c * m_c / mHl / mHl;
3449 double tau_s = 4.0 * m_s * m_s / mHl / mHl;
3450 double tau_tau = 4.0 * m_tau * m_tau / mHl / mHl;
3451 double tau_mu = 4.0 * m_mu * m_mu / mHl / mHl;
3452 double tau_W = 4.0 * M_w_2 / mHl / mHl;
3453
3454 double lambda_t = 4.0 * m_t * m_t / Mz / Mz;
3455 double lambda_b = 4.0 * m_b * m_b / Mz / Mz;
3456 double lambda_c = 4.0 * m_c * m_c / Mz / Mz;
3457 double lambda_s = 4.0 * m_s * m_s / Mz / Mz;
3458 double lambda_tau = 4.0 * m_tau * m_tau / Mz / Mz;
3459 double lambda_mu = 4.0 * m_mu * m_mu / Mz / Mz;
3460 double lambda_W = 4.0 * M_w_2 / Mz / Mz;
3461
3462 double sc = sqrt(sW2()*cW2());
3463 double vSMt = (2.0 * (quarks[TOP].getIsospin()) - 4.0 * Qt * sW2())/sc;
3464 double vSMb = (2.0 * (quarks[BOTTOM].getIsospin()) - 4.0 * Qb * sW2())/sc;
3465 double vSMc = (2.0 * (quarks[CHARM].getIsospin()) - 4.0 * Qc * sW2())/sc;
3466 double vSMs = (2.0 * (quarks[STRANGE].getIsospin()) - 4.0 * Qs * sW2())/sc;
3467 double vSMtau = (2.0 * (leptons[TAU].getIsospin()) - 4.0 * Qtau * sW2())/sc;
3468 double vSMmu = (2.0 * (leptons[MU].getIsospin()) - 4.0 * Qmu * sW2())/sc;
3469
3470 gslpp::complex MSM;
3471
3472 MSM = (ale/4.0/M_PI) * ((3.0 * vSMt * Qt * AHZga_f(tau_t, lambda_t) +
3473 3.0 * vSMb * Qb * AHZga_f(tau_b, lambda_b) +
3474 3.0 * vSMc * Qc * AHZga_f(tau_c, lambda_c) +
3475 3.0 * vSMs * Qs * AHZga_f(tau_s, lambda_s) +
3476 vSMtau * Qtau * AHZga_f(tau_tau, lambda_tau) +
3477 vSMmu * Qmu * AHZga_f(tau_mu, lambda_mu)) +
3478 AHZga_W(tau_W, lambda_W)/sqrt(sW2()));
3479
3480 gamma = (4.0*sqrt(2)*GF) * (MSM.abs2()) * pow(mHl*(1.0-Mz*Mz/mHl/mHl),3.0)/32.0/M_PI;
3481
3482 return gamma;
3483}
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 3394 of file StandardModel/src/StandardModel.cpp.

3395{
3396 double x=Mz/mHl;
3397 double fx;
3398 double g2 = 4.0 * sqrt(2.0) * GF * Mz * Mz;
3399 double gamma;
3400
3401 fx = -fabs(1.0-x*x)*( 47.0*x*x/2.0 - 13.0/2.0 +1.0/x/x ) +
3402 3.0*( 1.0 - 6.0*x*x + 4.0*x*x*x*x )*fabs(log(x)) +
3403 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);
3404
3405 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);
3406
3407 return gamma;
3408}

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

1267{
1269 if (useGammaW_cache)
1270 return GammaW_cache;
1271
1272 double GammaWtmp = 0.;
1273
1274 for (int i = 0; i < 6; i += 2)
1275 GammaWtmp += GammaW(leptons[i], leptons[i + 1]) + GammaW(quarks[i], quarks[i + 1]);
1276
1277 GammaW_cache = GammaWtmp;
1278 useGammaW_cache = true;
1279 return GammaWtmp;
1280}

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

1243{
1244 if ((fi.getIndex()) % 2 || (fj.getIndex() + 1) % 2)
1245 throw std::runtime_error("Error in StandardModel::GammaW()");
1246
1247 double G0 = GF * pow(Mw(), 3.0) / 6.0 / sqrt(2.0) / M_PI;
1248 gslpp::complex V(0.0, 0.0, false);
1249
1250 if (fi.is("TOP"))
1251 return (0.0);
1252
1253 if (fj.getIndex() - fi.getIndex() == 1)
1254 V = gslpp::complex(1.0, 0.0, false);
1255 else
1256 V = gslpp::complex(0.0, 0.0, false);
1257
1258 if (fi.is("LEPTON"))
1259 return ( V.abs2() * G0 * rho_GammaW(fi, fj));
1260 else {
1261 double AlsMw = AlsWithInit(Mw(), AlsMz, Mz, 5, FULLNLO);
1262 return ( 3.0 * V.abs2() * G0 * rho_GammaW(fi, fj)*(1.0 + AlsMw / M_PI));
1263 }
1264}
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 1357 of file StandardModel/src/StandardModel.cpp.

1358{
1359 if (f.is("TOP"))
1360 return 0.0;
1361 double Gamma;
1363
1364 /* SM contribution with the approximate formula */
1365 if (f.is("NEUTRINO_1") || f.is("NEUTRINO_2") || f.is("NEUTRINO_3"))
1366 Gamma = myApproximateFormulae->X_full("Gamma_nu");
1367 else if (f.is("ELECTRON") || f.is("MU"))
1368 Gamma = myApproximateFormulae->X_full("Gamma_e_mu");
1369 else if (f.is("TAU"))
1370 Gamma = myApproximateFormulae->X_full("Gamma_tau");
1371 else if (f.is("UP"))
1372 Gamma = myApproximateFormulae->X_full("Gamma_u");
1373 else if (f.is("CHARM"))
1374 Gamma = myApproximateFormulae->X_full("Gamma_c");
1375 else if (f.is("DOWN") || f.is("STRANGE"))
1376 Gamma = myApproximateFormulae->X_full("Gamma_d_s");
1377 else if (f.is("BOTTOM"))
1378 Gamma = myApproximateFormulae->X_full("Gamma_b");
1379 else
1380 throw std::runtime_error("Error in StandardModel::GammaZ()");
1381
1382 } else {
1383 gslpp::complex myrhoZ_f = rhoZ_f(f);
1384 gslpp::complex gV_over_gA = gV_f(f) / gA_f(f);
1385 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1386 if (f.is("LEPTON")) {
1387 double myalphaMz = alphaMz();
1388 double Q = f.getCharge();
1389 double xl = pow(f.getMass() / Mz, 2.0);
1390 Gamma = G0 * myrhoZ_f.abs() * sqrt(1.0 - 4.0 * xl)
1391 * ((1.0 + 2.0 * xl)*(gV_over_gA.abs2() + 1.0) - 6.0 * xl)
1392 * (1.0 + 3.0 / 4.0 * myalphaMz / M_PI * pow(Q, 2.0));
1393 } else if (f.is("QUARK")) {
1394 Gamma = 3.0 * G0 * myrhoZ_f.abs()*(gV_over_gA.abs2() * RVq((QCD::quark) (f.getIndex() - 6)) + RAq((QCD::quark) (f.getIndex() - 6)));
1395
1396 /* Nonfactorizable EW-QCD corrections */
1397 Gamma += Delta_EWQCD((QCD::quark) (f.getIndex() - 6));
1398 } else
1399 throw std::runtime_error("Error in StandardModel::GammaZ()");
1400 }
1401
1402 return Gamma;
1403}
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}\)

Reimplemented in NPbase.

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

3069{
3070 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3072
3073 /* SM contribution with the approximate formula */
3075
3076 } else {
3077 throw std::runtime_error("ERROR: StandardModel::gAnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3078 }
3079}
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 789 of file StandardModel.h.

790 {
791 return ale;
792 }

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

772 {
773 return AlsMz;
774 }

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

3067 {
3068 return 1.;
3069 }

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

3076 {
3077 return 1.;
3078 }

◆ getCCC1()

virtual const double StandardModel::getCCC1 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1173 of file StandardModel.h.

1173{ return 0.; };

◆ getCCC2()

virtual const double StandardModel::getCCC2 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1178 of file StandardModel.h.

1178{ return 0.; };

◆ getCCC3()

virtual const double StandardModel::getCCC3 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Reimplemented in RealWeakEFTCC.

Definition at line 1183 of file StandardModel.h.

1183{ return 0.; };

◆ getCCC4()

virtual const double StandardModel::getCCC4 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1188 of file StandardModel.h.

1188{ return 0.; };

◆ getCCC5()

virtual const double StandardModel::getCCC5 ( ) const
inlinevirtual

A virtual implementation for the RealWeakEFTCC class.

Definition at line 1193 of file StandardModel.h.

1193{ 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 3084 of file StandardModel.h.

3085 {
3086 return 1.;
3087 }

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

3094 {
3095 return 1.;
3096 }

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

921 {
922 return myCKM;
923 }

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

801 {
802 return dAle5Mz;
803 }

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

863 {
864 return delGammaZ;
865 }

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

820 {
821 return delMw;
822 }

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

903 {
904 return delR0b;
905 }

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

893 {
894 return delR0c;
895 }

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

883 {
884 return delR0l;
885 }

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

873 {
874 return delsigma0H;
875 }

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

853 {
854 return delSin2th_b;
855 }

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

831 {
832 return delSin2th_l;
833 }

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

842 {
843 return delSin2th_q;
844 }

◆ getFlagKappaZ()

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

A method to retrieve the model flag KappaZ.

See StandardModelFlags for detail.

Returns

Definition at line 714 of file StandardModel.h.

715 {
716 return FlagKappaZ;
717 }

◆ getFlagMw()

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

A method to retrieve the model flag Mw.

See StandardModelFlags for detail.

Returns

Definition at line 694 of file StandardModel.h.

695 {
696 return FlagMw;
697 }

◆ getFlagRhoZ()

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

A method to retrieve the model flag RhoZ.

See StandardModelFlags for detail.

Returns

Definition at line 704 of file StandardModel.h.

705 {
706 return FlagRhoZ;
707 }

◆ getFlavour()

const Flavour & StandardModel::getFlavour ( ) const
inline

Definition at line 1033 of file StandardModel.h.

1034 {
1035 return SMFlavour;
1036 }

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

781 {
782 return GF;
783 }

◆ getIntegrand_AFBnumeratorWithISR_bottom133()

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

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

9535{
9536 double s = 133. * 133.;
9538}
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 9540 of file StandardModel/src/StandardModel.cpp.

9541{
9542 double s = 167. * 167.;
9544}

◆ getIntegrand_AFBnumeratorWithISR_bottom172()

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

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

9547{
9548 double s = 172. * 172.;
9550}

◆ getIntegrand_AFBnumeratorWithISR_bottom183()

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

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

9553{
9554 double s = 183. * 183.;
9556}

◆ getIntegrand_AFBnumeratorWithISR_bottom189()

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

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

9559{
9560 double s = 189. * 189.;
9562}

◆ getIntegrand_AFBnumeratorWithISR_bottom192()

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

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

9565{
9566 double s = 192. * 192.;
9568}

◆ getIntegrand_AFBnumeratorWithISR_bottom196()

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

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

9571{
9572 double s = 196. * 196.;
9574}

◆ getIntegrand_AFBnumeratorWithISR_bottom200()

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

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

9577{
9578 double s = 200. * 200.;
9580}

◆ getIntegrand_AFBnumeratorWithISR_bottom202()

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

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

9583{
9584 double s = 202. * 202.;
9586}

◆ getIntegrand_AFBnumeratorWithISR_bottom205()

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

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

9589{
9590 double s = 205. * 205.;
9592}

◆ getIntegrand_AFBnumeratorWithISR_bottom207()

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

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

9595{
9596 double s = 207. * 207.;
9598}

◆ getIntegrand_AFBnumeratorWithISR_charm133()

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

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

9466{
9467 double s = 133. * 133.;
9469}

◆ getIntegrand_AFBnumeratorWithISR_charm167()

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

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

9472{
9473 double s = 167. * 167.;
9475}

◆ getIntegrand_AFBnumeratorWithISR_charm172()

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

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

9478{
9479 double s = 172. * 172.;
9481}

◆ getIntegrand_AFBnumeratorWithISR_charm183()

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

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

9484{
9485 double s = 183. * 183.;
9487}

◆ getIntegrand_AFBnumeratorWithISR_charm189()

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

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

9490{
9491 double s = 189. * 189.;
9493}

◆ getIntegrand_AFBnumeratorWithISR_charm192()

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

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

9496{
9497 double s = 192. * 192.;
9499}

◆ getIntegrand_AFBnumeratorWithISR_charm196()

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

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

9502{
9503 double s = 196. * 196.;
9505}

◆ getIntegrand_AFBnumeratorWithISR_charm200()

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

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

9508{
9509 double s = 200. * 200.;
9511}

◆ getIntegrand_AFBnumeratorWithISR_charm202()

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

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

9514{
9515 double s = 202. * 202.;
9517}

◆ getIntegrand_AFBnumeratorWithISR_charm205()

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

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

9520{
9521 double s = 205. * 205.;
9523}

◆ getIntegrand_AFBnumeratorWithISR_charm207()

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

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

9526{
9527 double s = 207. * 207.;
9529}

◆ getIntegrand_AFBnumeratorWithISR_mu130()

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

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

9304{
9305 double s = 130. * 130.;
9307}
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 9309 of file StandardModel/src/StandardModel.cpp.

9310{
9311 double s = 136. * 136.;
9313}

◆ getIntegrand_AFBnumeratorWithISR_mu161()

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

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

9316{
9317 double s = 161. * 161.;
9319}

◆ getIntegrand_AFBnumeratorWithISR_mu172()

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

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

9322{
9323 double s = 172. * 172.;
9325}

◆ getIntegrand_AFBnumeratorWithISR_mu183()

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

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

9328{
9329 double s = 183. * 183.;
9331}

◆ getIntegrand_AFBnumeratorWithISR_mu189()

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

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

9334{
9335 double s = 189. * 189.;
9337}

◆ getIntegrand_AFBnumeratorWithISR_mu192()

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

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

9340{
9341 double s = 192. * 192.;
9343}

◆ getIntegrand_AFBnumeratorWithISR_mu196()

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

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

9346{
9347 double s = 196. * 196.;
9349}

◆ getIntegrand_AFBnumeratorWithISR_mu200()

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

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

9352{
9353 double s = 200. * 200.;
9355}

◆ getIntegrand_AFBnumeratorWithISR_mu202()

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

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

9358{
9359 double s = 202. * 202.;
9361}

◆ getIntegrand_AFBnumeratorWithISR_mu205()

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

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

9364{
9365 double s = 205. * 205.;
9367}

◆ getIntegrand_AFBnumeratorWithISR_mu207()

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

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

9370{
9371 double s = 207. * 207.;
9373}

◆ getIntegrand_AFBnumeratorWithISR_tau130()

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

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

9377{
9378 double s = 130. * 130.;
9380}

◆ getIntegrand_AFBnumeratorWithISR_tau136()

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

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

9383{
9384 double s = 136. * 136.;
9386}

◆ getIntegrand_AFBnumeratorWithISR_tau161()

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

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

9389{
9390 double s = 161. * 161.;
9392}

◆ getIntegrand_AFBnumeratorWithISR_tau172()

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

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

9395{
9396 double s = 172. * 172.;
9398}

◆ getIntegrand_AFBnumeratorWithISR_tau183()

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

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

9401{
9402 double s = 183. * 183.;
9404}

◆ getIntegrand_AFBnumeratorWithISR_tau189()

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

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

9407{
9408 double s = 189. * 189.;
9410}

◆ getIntegrand_AFBnumeratorWithISR_tau192()

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

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

9413{
9414 double s = 192. * 192.;
9416}

◆ getIntegrand_AFBnumeratorWithISR_tau196()

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

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

9419{
9420 double s = 196. * 196.;
9422}

◆ getIntegrand_AFBnumeratorWithISR_tau200()

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

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

9425{
9426 double s = 200. * 200.;
9428}

◆ getIntegrand_AFBnumeratorWithISR_tau202()

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

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

9431{
9432 double s = 202. * 202.;
9434}

◆ getIntegrand_AFBnumeratorWithISR_tau205()

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

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

9437{
9438 double s = 205. * 205.;
9440}

◆ getIntegrand_AFBnumeratorWithISR_tau207()

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

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

9443{
9444 double s = 207. * 207.;
9446}

◆ getIntegrand_dsigmaBox_bottom130()

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

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

9196{
9197 double s = 130. * 130.;
9199}
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 9201 of file StandardModel/src/StandardModel.cpp.

9202{
9203 double s = 133. * 133.;
9205}

◆ getIntegrand_dsigmaBox_bottom136()

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

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

9208{
9209 double s = 136. * 136.;
9211}

◆ getIntegrand_dsigmaBox_bottom161()

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

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

9214{
9215 double s = 161. * 161.;
9217}

◆ getIntegrand_dsigmaBox_bottom167()

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

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

9220{
9221 double s = 167. * 167.;
9223}

◆ getIntegrand_dsigmaBox_bottom172()

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

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

9226{
9227 double s = 172. * 172.;
9229}

◆ getIntegrand_dsigmaBox_bottom183()

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

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

9232{
9233 double s = 183. * 183.;
9235}

◆ getIntegrand_dsigmaBox_bottom189()

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

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

9238{
9239 double s = 189. * 189.;
9241}

◆ getIntegrand_dsigmaBox_bottom192()

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

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

9244{
9245 double s = 192. * 192.;
9247}

◆ getIntegrand_dsigmaBox_bottom196()

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

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

9250{
9251 double s = 196. * 196.;
9253}

◆ getIntegrand_dsigmaBox_bottom200()

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

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

9256{
9257 double s = 200. * 200.;
9259}

◆ getIntegrand_dsigmaBox_bottom202()

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

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

9262{
9263 double s = 202. * 202.;
9265}

◆ getIntegrand_dsigmaBox_bottom205()

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

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

9268{
9269 double s = 205. * 205.;
9271}

◆ getIntegrand_dsigmaBox_bottom207()

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

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

9274{
9275 double s = 207. * 207.;
9277}

◆ getIntegrand_dsigmaBox_charm130()

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

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

9018{
9019 double s = 130. * 130.;
9020 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9021}

◆ getIntegrand_dsigmaBox_charm133()

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

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

9024{
9025 double s = 133. * 133.;
9026 return (Integrand_dsigmaBox_q(x, QCD::quark(CHARM), s));
9027}

◆ getIntegrand_dsigmaBox_charm136()

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

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

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

◆ getIntegrand_dsigmaBox_charm161()

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

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

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

◆ getIntegrand_dsigmaBox_charm167()

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

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

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

◆ getIntegrand_dsigmaBox_charm172()

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

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

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

◆ getIntegrand_dsigmaBox_charm183()

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

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

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

◆ getIntegrand_dsigmaBox_charm189()

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

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

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

◆ getIntegrand_dsigmaBox_charm192()

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

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

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

◆ getIntegrand_dsigmaBox_charm196()

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

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

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

◆ getIntegrand_dsigmaBox_charm200()

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

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

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

◆ getIntegrand_dsigmaBox_charm202()

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

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

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

◆ getIntegrand_dsigmaBox_charm205()

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

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

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

◆ getIntegrand_dsigmaBox_charm207()

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

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

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

◆ getIntegrand_dsigmaBox_down130()

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

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

8930{
8931 double s = 130. * 130.;
8932 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8933}

◆ getIntegrand_dsigmaBox_down133()

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

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

8936{
8937 double s = 133. * 133.;
8938 return (Integrand_dsigmaBox_q(x, QCD::quark(DOWN), s));
8939}

◆ getIntegrand_dsigmaBox_down136()

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

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

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

◆ getIntegrand_dsigmaBox_down161()

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

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

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

◆ getIntegrand_dsigmaBox_down167()

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

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

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

◆ getIntegrand_dsigmaBox_down172()

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

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

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

◆ getIntegrand_dsigmaBox_down183()

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

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

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

◆ getIntegrand_dsigmaBox_down189()

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

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

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

◆ getIntegrand_dsigmaBox_down192()

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

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

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

◆ getIntegrand_dsigmaBox_down196()

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

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

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

◆ getIntegrand_dsigmaBox_down200()

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

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

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

◆ getIntegrand_dsigmaBox_down202()

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

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

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

◆ getIntegrand_dsigmaBox_down205()

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

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

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

◆ getIntegrand_dsigmaBox_down207()

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

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

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

◆ getIntegrand_dsigmaBox_mu130()

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

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

8678{
8679 double s = 130. * 130.;
8680 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8681}
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 8683 of file StandardModel/src/StandardModel.cpp.

8684{
8685 double s = 136. * 136.;
8686 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8687}

◆ getIntegrand_dsigmaBox_mu161()

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

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

8690{
8691 double s = 161. * 161.;
8692 return (Integrand_dsigmaBox_l(x, QCD::lepton(MU), s));
8693}

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

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

◆ getIntegrand_dsigmaBox_mu183()

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

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

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

◆ getIntegrand_dsigmaBox_mu189()

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

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

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

◆ getIntegrand_dsigmaBox_mu192()

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

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

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

◆ getIntegrand_dsigmaBox_mu196()

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

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

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

◆ getIntegrand_dsigmaBox_mu200()

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

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

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

◆ getIntegrand_dsigmaBox_mu202()

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

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

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

◆ getIntegrand_dsigmaBox_mu205()

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

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

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

◆ getIntegrand_dsigmaBox_mu207()

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

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

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

◆ getIntegrand_dsigmaBox_strange130()

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

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

9106{
9107 double s = 130. * 130.;
9109}

◆ getIntegrand_dsigmaBox_strange133()

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

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

9112{
9113 double s = 133. * 133.;
9115}

◆ getIntegrand_dsigmaBox_strange136()

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

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

9118{
9119 double s = 136. * 136.;
9121}

◆ getIntegrand_dsigmaBox_strange161()

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

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

9124{
9125 double s = 161. * 161.;
9127}

◆ getIntegrand_dsigmaBox_strange167()

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

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

9130{
9131 double s = 167. * 167.;
9133}

◆ getIntegrand_dsigmaBox_strange172()

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

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

9138{
9139 double s = 172. * 172.;
9141}

◆ getIntegrand_dsigmaBox_strange183()

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

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

9144{
9145 double s = 183. * 183.;
9147}

◆ getIntegrand_dsigmaBox_strange189()

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

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

9150{
9151 double s = 189. * 189.;
9153}

◆ getIntegrand_dsigmaBox_strange192()

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

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

9156{
9157 double s = 192. * 192.;
9159}

◆ getIntegrand_dsigmaBox_strange196()

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

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

9162{
9163 double s = 196. * 196.;
9165}

◆ getIntegrand_dsigmaBox_strange200()

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

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

9168{
9169 double s = 200. * 200.;
9171}

◆ getIntegrand_dsigmaBox_strange202()

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

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

9174{
9175 double s = 202. * 202.;
9177}

◆ getIntegrand_dsigmaBox_strange205()

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

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

9180{
9181 double s = 205. * 205.;
9183}

◆ getIntegrand_dsigmaBox_strange207()

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

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

9186{
9187 double s = 207. * 207.;
9189}

◆ getIntegrand_dsigmaBox_tau130()

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

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

8754{
8755 double s = 130. * 130.;
8756 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8757}

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

8760{
8761 double s = 136. * 136.;
8762 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8763}

◆ getIntegrand_dsigmaBox_tau161()

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

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

8766{
8767 double s = 161. * 161.;
8768 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8769}

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

8772{
8773 double s = 172. * 172.;
8774 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8775}

◆ getIntegrand_dsigmaBox_tau183()

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

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

8778{
8779 double s = 183. * 183.;
8780 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8781}

◆ getIntegrand_dsigmaBox_tau189()

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

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

8784{
8785 double s = 189. * 189.;
8786 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8787}

◆ getIntegrand_dsigmaBox_tau192()

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

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

8790{
8791 double s = 192. * 192.;
8792 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8793}

◆ getIntegrand_dsigmaBox_tau196()

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

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

8796{
8797 double s = 196. * 196.;
8798 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8799}

◆ getIntegrand_dsigmaBox_tau200()

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

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

8802{
8803 double s = 200. * 200.;
8804 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8805}

◆ getIntegrand_dsigmaBox_tau202()

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

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

8808{
8809 double s = 202. * 202.;
8810 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8811}

◆ getIntegrand_dsigmaBox_tau205()

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

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

8814{
8815 double s = 205. * 205.;
8816 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8817}

◆ getIntegrand_dsigmaBox_tau207()

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

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

8820{
8821 double s = 207. * 207.;
8822 return (Integrand_dsigmaBox_l(x, QCD::lepton(TAU), s));
8823}

◆ getIntegrand_dsigmaBox_up130()

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

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

8843{
8844 double s = 130. * 130.;
8845 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8846}

◆ getIntegrand_dsigmaBox_up133()

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

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

8849{
8850 double s = 133. * 133.;
8851 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8852}

◆ getIntegrand_dsigmaBox_up136()

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

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

8855{
8856 double s = 136. * 136.;
8857 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8858}

◆ getIntegrand_dsigmaBox_up161()

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

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

8861{
8862 double s = 161. * 161.;
8863 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8864}

◆ getIntegrand_dsigmaBox_up167()

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

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

8867{
8868 double s = 167. * 167.;
8869 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8870}

◆ getIntegrand_dsigmaBox_up172()

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

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

8873{
8874 double s = 172. * 172.;
8875 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8876}

◆ getIntegrand_dsigmaBox_up183()

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

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

8879{
8880 double s = 183. * 183.;
8881 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8882}

◆ getIntegrand_dsigmaBox_up189()

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

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

8885{
8886 double s = 189. * 189.;
8887 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8888}

◆ getIntegrand_dsigmaBox_up192()

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

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

8891{
8892 double s = 192. * 192.;
8893 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8894}

◆ getIntegrand_dsigmaBox_up196()

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

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

8897{
8898 double s = 196. * 196.;
8899 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8900}

◆ getIntegrand_dsigmaBox_up200()

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

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

8903{
8904 double s = 200. * 200.;
8905 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8906}

◆ getIntegrand_dsigmaBox_up202()

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

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

8909{
8910 double s = 202. * 202.;
8911 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8912}

◆ getIntegrand_dsigmaBox_up205()

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

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

8915{
8916 double s = 205. * 205.;
8917 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8918}

◆ getIntegrand_dsigmaBox_up207()

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

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

8921{
8922 double s = 207. * 207.;
8923 return (Integrand_dsigmaBox_q(x, QCD::quark(UP), s));
8924}

◆ getIntegrand_sigmaWithISR_bottom130()

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

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

8584{
8585 double s = 130. * 130.;
8587}
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 8589 of file StandardModel/src/StandardModel.cpp.

8590{
8591 double s = 133. * 133.;
8593}

◆ getIntegrand_sigmaWithISR_bottom136()

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

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

8596{
8597 double s = 136. * 136.;
8599}

◆ getIntegrand_sigmaWithISR_bottom161()

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

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

8602{
8603 double s = 161. * 161.;
8605}

◆ getIntegrand_sigmaWithISR_bottom167()

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

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

8608{
8609 double s = 167. * 167.;
8611}

◆ getIntegrand_sigmaWithISR_bottom172()

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

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

8614{
8615 double s = 172. * 172.;
8617}

◆ getIntegrand_sigmaWithISR_bottom183()

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

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

8620{
8621 double s = 183. * 183.;
8623}

◆ getIntegrand_sigmaWithISR_bottom189()

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

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

8626{
8627 double s = 189. * 189.;
8629}

◆ getIntegrand_sigmaWithISR_bottom192()

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

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

8632{
8633 double s = 192. * 192.;
8635}

◆ getIntegrand_sigmaWithISR_bottom196()

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

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

8638{
8639 double s = 196. * 196.;
8641}

◆ getIntegrand_sigmaWithISR_bottom200()

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

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

8644{
8645 double s = 200. * 200.;
8647}

◆ getIntegrand_sigmaWithISR_bottom202()

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

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

8650{
8651 double s = 202. * 202.;
8653}

◆ getIntegrand_sigmaWithISR_bottom205()

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

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

8656{
8657 double s = 205. * 205.;
8659}

◆ getIntegrand_sigmaWithISR_bottom207()

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

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

8662{
8663 double s = 207. * 207.;
8665}

◆ getIntegrand_sigmaWithISR_charm130()

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

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

8408{
8409 double s = 130. * 130.;
8411}

◆ getIntegrand_sigmaWithISR_charm133()

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

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

8414{
8415 double s = 133. * 133.;
8417}

◆ getIntegrand_sigmaWithISR_charm136()

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

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

8420{
8421 double s = 136. * 136.;
8423}

◆ getIntegrand_sigmaWithISR_charm161()

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

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

8426{
8427 double s = 161. * 161.;
8429}

◆ getIntegrand_sigmaWithISR_charm167()

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

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

8432{
8433 double s = 167. * 167.;
8435}

◆ getIntegrand_sigmaWithISR_charm172()

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

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

8438{
8439 double s = 172. * 172.;
8441}

◆ getIntegrand_sigmaWithISR_charm183()

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

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

8444{
8445 double s = 183. * 183.;
8447}

◆ getIntegrand_sigmaWithISR_charm189()

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

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

8450{
8451 double s = 189. * 189.;
8453}

◆ getIntegrand_sigmaWithISR_charm192()

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

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

8456{
8457 double s = 192. * 192.;
8459}

◆ getIntegrand_sigmaWithISR_charm196()

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

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

8462{
8463 double s = 196. * 196.;
8465}

◆ getIntegrand_sigmaWithISR_charm200()

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

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

8468{
8469 double s = 200. * 200.;
8471}

◆ getIntegrand_sigmaWithISR_charm202()

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

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

8474{
8475 double s = 202. * 202.;
8477}

◆ getIntegrand_sigmaWithISR_charm205()

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

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

8480{
8481 double s = 205. * 205.;
8483}

◆ getIntegrand_sigmaWithISR_charm207()

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

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

8486{
8487 double s = 207. * 207.;
8489}

◆ getIntegrand_sigmaWithISR_down130()

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

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

8319{
8320 double s = 130. * 130.;
8322}

◆ getIntegrand_sigmaWithISR_down133()

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

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

8325{
8326 double s = 133. * 133.;
8328}

◆ getIntegrand_sigmaWithISR_down136()

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

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

8332{
8333 double s = 136. * 136.;
8335}

◆ getIntegrand_sigmaWithISR_down161()

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

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

8338{
8339 double s = 161. * 161.;
8341}

◆ getIntegrand_sigmaWithISR_down167()

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

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

8344{
8345 double s = 167. * 167.;
8347}

◆ getIntegrand_sigmaWithISR_down172()

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

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

8350{
8351 double s = 172. * 172.;
8353}

◆ getIntegrand_sigmaWithISR_down183()

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

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

8356{
8357 double s = 183. * 183.;
8359}

◆ getIntegrand_sigmaWithISR_down189()

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

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

8362{
8363 double s = 189. * 189.;
8365}

◆ getIntegrand_sigmaWithISR_down192()

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

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

8368{
8369 double s = 192. * 192.;
8371}

◆ getIntegrand_sigmaWithISR_down196()

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

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

8374{
8375 double s = 196. * 196.;
8377}

◆ getIntegrand_sigmaWithISR_down200()

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

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

8380{
8381 double s = 200. * 200.;
8383}

◆ getIntegrand_sigmaWithISR_down202()

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

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

8386{
8387 double s = 202. * 202.;
8389}

◆ getIntegrand_sigmaWithISR_down205()

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

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

8392{
8393 double s = 205. * 205.;
8395}

◆ getIntegrand_sigmaWithISR_down207()

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

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

8398{
8399 double s = 207. * 207.;
8401}

◆ getIntegrand_sigmaWithISR_mu130()

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

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

8063{
8064 double s = 130. * 130.;
8066}
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 8068 of file StandardModel/src/StandardModel.cpp.

8069{
8070 double s = 136. * 136.;
8072}

◆ getIntegrand_sigmaWithISR_mu161()

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

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

8075{
8076 double s = 161. * 161.;
8078}

◆ getIntegrand_sigmaWithISR_mu172()

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

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

8081{
8082 double s = 172. * 172.;
8084}

◆ getIntegrand_sigmaWithISR_mu183()

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

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

8087{
8088 double s = 183. * 183.;
8090}

◆ getIntegrand_sigmaWithISR_mu189()

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

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

8093{
8094 double s = 189. * 189.;
8096}

◆ getIntegrand_sigmaWithISR_mu192()

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

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

8099{
8100 double s = 192. * 192.;
8102}

◆ getIntegrand_sigmaWithISR_mu196()

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

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

8105{
8106 double s = 196. * 196.;
8108}

◆ getIntegrand_sigmaWithISR_mu200()

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

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

8111{
8112 double s = 200. * 200.;
8114}

◆ getIntegrand_sigmaWithISR_mu202()

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

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

8117{
8118 double s = 202. * 202.;
8120}

◆ getIntegrand_sigmaWithISR_mu205()

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

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

8123{
8124 double s = 205. * 205.;
8126}

◆ getIntegrand_sigmaWithISR_mu207()

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

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

8129{
8130 double s = 207. * 207.;
8132}

◆ getIntegrand_sigmaWithISR_strange130()

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

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

8496{
8497 double s = 130. * 130.;
8499}

◆ getIntegrand_sigmaWithISR_strange133()

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

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

8502{
8503 double s = 133. * 133.;
8505}

◆ getIntegrand_sigmaWithISR_strange136()

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

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

8508{
8509 double s = 136. * 136.;
8511}

◆ getIntegrand_sigmaWithISR_strange161()

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

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

8514{
8515 double s = 161. * 161.;
8517}

◆ getIntegrand_sigmaWithISR_strange167()

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

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

8520{
8521 double s = 167. * 167.;
8523}

◆ getIntegrand_sigmaWithISR_strange172()

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

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

8526{
8527 double s = 172. * 172.;
8529}

◆ getIntegrand_sigmaWithISR_strange183()

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

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

8532{
8533 double s = 183. * 183.;
8535}

◆ getIntegrand_sigmaWithISR_strange189()

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

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

8538{
8539 double s = 189. * 189.;
8541}

◆ getIntegrand_sigmaWithISR_strange192()

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

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

8544{
8545 double s = 192. * 192.;
8547}

◆ getIntegrand_sigmaWithISR_strange196()

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

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

8550{
8551 double s = 196. * 196.;
8553}

◆ getIntegrand_sigmaWithISR_strange200()

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

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

8556{
8557 double s = 200. * 200.;
8559}

◆ getIntegrand_sigmaWithISR_strange202()

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

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

8562{
8563 double s = 202. * 202.;
8565}

◆ getIntegrand_sigmaWithISR_strange205()

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

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

8568{
8569 double s = 205. * 205.;
8571}

◆ getIntegrand_sigmaWithISR_strange207()

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

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

8574{
8575 double s = 207. * 207.;
8577}

◆ getIntegrand_sigmaWithISR_tau130()

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

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

8136{
8137 double s = 130. * 130.;
8139}

◆ getIntegrand_sigmaWithISR_tau136()

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

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

8142{
8143 double s = 136. * 136.;
8145}

◆ getIntegrand_sigmaWithISR_tau161()

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

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

8148{
8149 double s = 161. * 161.;
8151}

◆ getIntegrand_sigmaWithISR_tau172()

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

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

8154{
8155 double s = 172. * 172.;
8157}

◆ getIntegrand_sigmaWithISR_tau183()

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

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

8160{
8161 double s = 183. * 183.;
8163}

◆ getIntegrand_sigmaWithISR_tau189()

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

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

8166{
8167 double s = 189. * 189.;
8169}

◆ getIntegrand_sigmaWithISR_tau192()

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

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

8172{
8173 double s = 192. * 192.;
8175}

◆ getIntegrand_sigmaWithISR_tau196()

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

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

8178{
8179 double s = 196. * 196.;
8181}

◆ getIntegrand_sigmaWithISR_tau200()

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

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

8184{
8185 double s = 200. * 200.;
8187}

◆ getIntegrand_sigmaWithISR_tau202()

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

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

8190{
8191 double s = 202. * 202.;
8193}

◆ getIntegrand_sigmaWithISR_tau205()

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

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

8196{
8197 double s = 205. * 205.;
8199}

◆ getIntegrand_sigmaWithISR_tau207()

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

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

8202{
8203 double s = 207. * 207.;
8205}

◆ getIntegrand_sigmaWithISR_up130()

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

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

8232{
8233 double s = 130. * 130.;
8234 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8235}

◆ getIntegrand_sigmaWithISR_up133()

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

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

8238{
8239 double s = 133. * 133.;
8240 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8241}

◆ getIntegrand_sigmaWithISR_up136()

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

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

8244{
8245 double s = 136. * 136.;
8246 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8247}

◆ getIntegrand_sigmaWithISR_up161()

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

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

8250{
8251 double s = 161. * 161.;
8252 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8253}

◆ getIntegrand_sigmaWithISR_up167()

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

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

8256{
8257 double s = 167. * 167.;
8258 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8259}

◆ getIntegrand_sigmaWithISR_up172()

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

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

8262{
8263 double s = 172. * 172.;
8264 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8265}

◆ getIntegrand_sigmaWithISR_up183()

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

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

8268{
8269 double s = 183. * 183.;
8270 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8271}

◆ getIntegrand_sigmaWithISR_up189()

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

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

8274{
8275 double s = 189. * 189.;
8276 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8277}

◆ getIntegrand_sigmaWithISR_up192()

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

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

8280{
8281 double s = 192. * 192.;
8282 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8283}

◆ getIntegrand_sigmaWithISR_up196()

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

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

8286{
8287 double s = 196. * 196.;
8288 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8289}

◆ getIntegrand_sigmaWithISR_up200()

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

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

8292{
8293 double s = 200. * 200.;
8294 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8295}

◆ getIntegrand_sigmaWithISR_up202()

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

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

8298{
8299 double s = 202. * 202.;
8300 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8301}

◆ getIntegrand_sigmaWithISR_up205()

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

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

8304{
8305 double s = 205. * 205.;
8306 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8307}

◆ getIntegrand_sigmaWithISR_up207()

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

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

8310{
8311 double s = 207. * 207.;
8312 return (Integrand_sigmaWithISR_q(x, QCD::quark(UP), s));
8313}

◆ getIterationNo()

const int StandardModel::getIterationNo ( ) const
inline

Definition at line 617 of file StandardModel.h.

618 {
619 return iterationNo;
620 }

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

745 {
746 return leptons[p];
747 }

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

966 {
967 return SMM.getObj();
968 }

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

810 {
811 return mHl;
812 }

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

3311{
3312 return m_q(q, mu, FULLNLO);
3313}

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

952 {
953 return muw;
954 }

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

763 {
764 return Mw_inp;
765 }

◆ getMyApproximateFormulae()

EWSMApproximateFormulae * StandardModel::getMyApproximateFormulae ( ) const
inline

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

Returns
the pointer myApproximateFormulae

Definition at line 992 of file StandardModel.h.

993 {
995 }

◆ getMyEWSMcache()

EWSMcache * StandardModel::getMyEWSMcache ( ) const
inline

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

Returns
the pointer myEWSMcache

Definition at line 974 of file StandardModel.h.

975 {
976 return myEWSMcache;
977 }

◆ getMyLeptonFlavour()

LeptonFlavour * StandardModel::getMyLeptonFlavour ( ) const
inline

Definition at line 1038 of file StandardModel.h.

1039 {
1040 return myLeptonFlavour;
1041 }

◆ getMyOneLoopEW()

EWSMOneLoopEW * StandardModel::getMyOneLoopEW ( ) const
inline

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

Returns
the pointer myOneLoopEW

Definition at line 983 of file StandardModel.h.

984 {
985 return myOneLoopEW;
986 }

◆ getMyThreeLoopEW()

EWSMThreeLoopEW * StandardModel::getMyThreeLoopEW ( ) const
inline

Definition at line 1008 of file StandardModel.h.

1009 {
1010 return myThreeLoopEW;
1011 }

◆ getMyThreeLoopEW2QCD()

EWSMThreeLoopEW2QCD * StandardModel::getMyThreeLoopEW2QCD ( ) const
inline

Definition at line 1013 of file StandardModel.h.

1014 {
1015 return myThreeLoopEW2QCD;
1016 }

◆ getMyThreeLoopQCD()

EWSMThreeLoopQCD * StandardModel::getMyThreeLoopQCD ( ) const
inline

Definition at line 1018 of file StandardModel.h.

1019 {
1020 return myThreeLoopQCD;
1021 }

◆ getMyTwoFermionsLEP2()

EWSMTwoFermionsLEP2 * StandardModel::getMyTwoFermionsLEP2 ( ) const
inline

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

Returns
the pointer myTwoFermionsLEP2

Definition at line 1002 of file StandardModel.h.

1003 {
1004 return myTwoFermionsLEP2;
1005 }

◆ getMyTwoLoopEW()

EWSMTwoLoopEW * StandardModel::getMyTwoLoopEW ( ) const
inline

Definition at line 1023 of file StandardModel.h.

1024 {
1025 return myTwoLoopEW;
1026 }

◆ getMyTwoLoopQCD()

EWSMTwoLoopQCD * StandardModel::getMyTwoLoopQCD ( ) const
inline

Definition at line 1028 of file StandardModel.h.

1029 {
1030 return myTwoLoopQCD;
1031 }

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

754 {
755 return Mz;
756 }

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

3112 {
3113 return 0.;
3114 }

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

3103 {
3104 return 0.;
3105 }

◆ getTrueSM()

virtual const StandardModel & StandardModel::getTrueSM ( ) const
inlinevirtual

Reimplemented in NPbase.

Definition at line 956 of file StandardModel.h.

957 {
958 throw std::runtime_error("StandardModel::getTrueSM() must be overridden by the NP extension.");
959 }

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

932 {
933 return myPMNS.getPMNS();
934 }

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

912 {
913 return myCKM.getCKM();
914 }

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

3359 {
3360 return Yd;
3361 }

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

3379 {
3380 return Ye;
3381 }

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

942 {
943 return Yn;
944 }

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

3339 {
3340 return Yu;
3341 }

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

Reimplemented in NPbase.

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

3002{
3003 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3005
3006 /* SM contribution with the approximate formula */
3008
3009 } else {
3010 throw std::runtime_error("ERROR: StandardModel::gLnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3011 }
3012}
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)\)

Reimplemented in NPbase.

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

3016{
3017 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3019
3020 /* SM contribution with the approximate formula */
3022
3023 } else {
3024 throw std::runtime_error("ERROR: StandardModel::gRnuN2, prediction implemented only via semianalytical approximate formula. Check flags!");
3025 }
3026}
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 1577 of file StandardModel/src/StandardModel.cpp.

1578{
1579 return ( gA_f(f)
1580 *(1.0 - 4.0 * fabs(f.getCharge())*(kappaZ_f(f)) * sW2()));
1581}

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

Reimplemented in NPbase.

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

3056{
3057 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3059
3060 /* SM contribution with the approximate formula */
3062
3063 } else {
3064 throw std::runtime_error("ERROR: StandardModel::gVnue, prediction implemented only via semianalytical approximate formula. Check flags!");
3065 }
3066}
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#4708, \(\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 3278 of file StandardModel/src/StandardModel.cpp.

3278 {
3279 gslpp::complex tmp;
3280
3281 tmp = (tau * lambda * (f_triangle(tau) - f_triangle(lambda)) + 2.0 * tau * (g_triangle(tau) - g_triangle(lambda))) / (tau - lambda);
3282
3283 tmp = tau * lambda * (1.0 + tmp) / (2.0 * (tau - lambda));
3284
3285 return tmp;
3286}
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#4708, \(\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 3288 of file StandardModel/src/StandardModel.cpp.

3288 {
3289 gslpp::complex tmp;
3290
3291 tmp = -0.5 * tau * lambda * (f_triangle(tau) - f_triangle(lambda)) / (tau - lambda);
3292
3293 return tmp;
3294}

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

197{
198 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
199 if (it->first.compare("AlsM") == 0 || it->first.compare("MAls") == 0)
200 throw std::runtime_error("ERROR: inappropriate parameter " + it->first
201 + " in model initialization");
202 else if (FlagFixMuwMut && it->first.compare("mut") == 0)
203 throw std::runtime_error("ERROR: cannot use " + it->first
204 + " when FlagFixMuwMut is true: use only muw");
205
206 std::map<std::string, double> myDPars(DPars);
207 myDPars["AlsM"] = myDPars.at("AlsMz"); // do not change!
208 myDPars["MAls"] = myDPars.at("Mz");
209 if (FlagFixMuwMut)
210 myDPars["mut"] = myDPars.at("muw") * 163. / 80.4 ;
211 return (QCD::Init(myDPars));
212}
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 174 of file StandardModel/src/StandardModel.cpp.

175{
176 myEWSMcache = new EWSMcache(*this);
184 myLeptonFlavour = new LeptonFlavour(*this);
185 /* BEGIN: REMOVE FROM THE PACKAGE */
187 /* END: REMOVE FROM THE PACKAGE */
189 return (true);
190}
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 9291 of file StandardModel/src/StandardModel.cpp.

9292{
9293 double sprime = (1.0 - x)*s;
9294 double Ncf = 1.0;
9295 double ml = getLeptons(l_flavor).getMass();
9296 double G3prime = myTwoFermionsLEP2->G_3prime_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9297 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9298
9299 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9300}
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 9450 of file StandardModel/src/StandardModel.cpp.

9451{
9452 double sprime = (1.0 - x)*s;
9453 double Ncf = 3.0;
9454 double mq = m_q(q_flavor, sqrt(s));
9455 double G3prime = myTwoFermionsLEP2->G_3prime_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),flagLEP2[Weak]);
9456 double H = myTwoFermionsLEP2->H_ISR_FB(x, s);
9457
9458 if (flagLEP2[QCDFSR])
9459 G3prime *= myTwoFermionsLEP2->QCD_FSR_forAFB(q_flavor, mq, sprime);
9460
9461 return ( M_PI*ale*ale*Ncf*H*G3prime/sprime );
9462}
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 8671 of file StandardModel/src/StandardModel.cpp.

8672{
8673 double ml = getLeptons(l_flavor).getMass();
8674 return ( myTwoFermionsLEP2->dsigma_l_box(l_flavor, ml, s, cosTheta, Mw(), Gamma_Z()) );
8675}
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 8830 of file StandardModel/src/StandardModel.cpp.

8831{
8832 double mq = m_q(q_flavor, sqrt(s));
8833 return ( myTwoFermionsLEP2->dsigma_q_box(q_flavor, mq, s, cosTheta, Mw(), Gamma_Z()) );
8834}
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 8047 of file StandardModel/src/StandardModel.cpp.

8048{
8049 double sprime = (1.0 - x)*s;
8050 double ml = getLeptons(l_flavor).getMass();
8051 double l_charge = getLeptons(l_flavor).getCharge();
8052 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, sprime, Mw(), Gamma_Z(),
8053 flagLEP2[Weak]);
8054 double H = myTwoFermionsLEP2->H_ISR(x, s);
8055
8056 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8057 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, l_charge);
8058
8059 return ( H*sigma );
8060}
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 8207 of file StandardModel/src/StandardModel.cpp.

8208{
8209 double sprime = (1.0 - x)*s;
8210 double mq = m_q(q_flavor, sqrt(s));
8211 double q_charge = getQuarks(q_flavor).getCharge();
8212 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, sprime, Mw(), Gamma_Z(),
8213 flagLEP2[Weak]);
8214 double H = myTwoFermionsLEP2->H_ISR(x, s);
8215
8216 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8217 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(sprime, q_charge);
8218
8219 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8220 sigma *= myTwoFermionsLEP2->QCD_FSR_forSigma(sprime);
8221
8222 return ( H*sigma );
8223}
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 3967 of file StandardModel/src/StandardModel.cpp.

3967 {
3968
3969 double intM2;
3970 double sw2cw2;
3971 double gLeSM;
3972 double GammaZSM;
3973 double Mz2, Mz4, s2;
3974
3975 sw2cw2 = s02() * c02();
3976 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3977 GammaZSM = Gamma_Z();
3978 Mz2 = Mz * Mz;
3979 Mz4 = Mz2 * Mz2;
3980 s2 = s * s;
3981
3982 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)) +
3983 ((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)) +
3984 (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)) ) +
3985 (2.0*(gLeSM*gLeSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
3986 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
3987 (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)));
3988
3989 return intM2;
3990}

◆ intMLR2eeeets2()

const double StandardModel::intMLR2eeeets2 ( const double  s,
const double  t0,
const double  t1 
) const

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

3923 {
3924
3925 double intM2;
3926 double sw2cw2;
3927 double gLeSM,gReSM;
3928 double GammaZSM;
3929 double Mz2, s2;
3930 double propZSM2,propZSMRe,MeeLR2SM;
3931
3932 sw2cw2 = s02() * c02();
3933 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3934 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3935 GammaZSM = Gamma_Z();
3936 Mz2 = Mz * Mz;
3937 s2 = s * s;
3938
3939 propZSM2 = s2/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3940 propZSMRe = (s*(s - Mz2))/((s - Mz2)*(s - Mz2) + Mz2*GammaZSM*GammaZSM);
3941
3942 MeeLR2SM = 1.0 + (gLeSM*gLeSM*gReSM*gReSM/(sw2cw2*sw2cw2))*propZSM2 + 2.0*(gLeSM*gReSM/sw2cw2)*propZSMRe;
3943
3944 intM2 = MeeLR2SM*(t1*t1*t1 - t0*t0*t0)/(3.0*s*s);
3945
3946 return intM2;
3947}

◆ intMLRtilde2eeeest2()

const double StandardModel::intMLRtilde2eeeest2 ( const double  s,
const double  t0,
const double  t1 
) const

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

3949 {
3950
3951 double intM2;
3952 double sw2cw2;
3953 double gLeSM,gReSM;
3954 double Mz2;
3955
3956 sw2cw2 = s02() * c02();
3957 gLeSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3958 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
3959 Mz2 = Mz * Mz;
3960
3961 intM2 = s*s*(((gLeSM*gLeSM*gReSM*gReSM)/sw2cw2/sw2cw2)*(1.0/(Mz2 - t1) - 1.0/(Mz2 - t0)) - 1.0/t1 + 1.0/t0 +
3962 (2.0*gLeSM*gReSM*(-log(t1/t0) + log((-Mz2 + t1)/(-Mz2 + t0))))/(Mz2*sw2cw2));
3963
3964 return intM2;
3965}

◆ intMRR2eeeeus2()

const double StandardModel::intMRR2eeeeus2 ( const double  s,
const double  t0,
const double  t1 
) const

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

3992 {
3993
3994 double intM2;
3995 double sw2cw2;
3996 double gReSM;
3997 double GammaZSM;
3998 double Mz2, Mz4, s2;
3999
4000 sw2cw2 = s02() * c02();
4001 gReSM = - (leptons[ELECTRON].getCharge()) * s02();
4002 GammaZSM = Gamma_Z();
4003 Mz2 = Mz * Mz;
4004 Mz4 = Mz2 * Mz2;
4005 s2 = s * s;
4006
4007 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)) +
4008 ((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)) +
4009 (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)) ) +
4010 (2.0*(gReSM*gReSM) )/(Mz2*sw2cw2)*(Mz2 *(t1 - t0) - s2*log(t1/t0) + (Mz2 + s)*(Mz2 + s)*log((-Mz2 + t1)/(-Mz2 + t0))) +
4011 (-(s2/t1) + s2/t0 + t1 - t0 + 2.0*s*log(t1/t0)) +
4012 (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)));
4013
4014 return intM2;
4015}

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

680 {
682 }

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

667 {
669 }

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

3398 {
3399 return SMSuccess;
3400 }
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 1653 of file StandardModel/src/StandardModel.cpp.

1654{
1655 if (f.is("TOP")) return (gslpp::complex(0.0, 0.0, false));
1656
1658 if (useKappaZ_f_cache[f.getIndex()])
1659 return kappaZ_f_cache[f.getIndex()];
1660
1661 double myMw = Mw();
1662
1663 double ReKappaZf = 0.0, ImKappaZf = 0.0;
1664 if (FlagKappaZ.compare("APPROXIMATEFORMULA") == 0) {
1665
1666// Choose the correct formulae for the effective angle
1667 if ( f.is("BOTTOM") ){
1668 ReKappaZf = myApproximateFormulae->sin2thetaEff_b_full() / sW2();
1669 } else if ( f.is("ELECTRON") || f.is("MU") || f.is("TAU") ) {
1670 ReKappaZf = myApproximateFormulae->sin2thetaEff_l_full() / sW2();
1671 } else {
1672 ReKappaZf = myApproximateFormulae->sin2thetaEff(f) / sW2();
1673 }
1674
1675 ImKappaZf = myOneLoopEW->deltaKappa_rem_f(f, myMw).imag();
1676#ifdef WITHIMTWOLOOPQCD
1677 ImKappaZf += myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag();
1678
1679 /* TEST */
1680 //ImKappaZf -= myCache->ale()*myCache->alsMz()/24.0/M_PI*(cW2() - sW2())/sW2()/sW2();
1681#endif
1682 } else {
1683 /* compute Delta rho */
1684 double DeltaRho[orders_EW_size];
1685 ComputeDeltaRho(myMw, DeltaRho);
1686
1687 /* compute delta kappa_rem^f */
1688 gslpp::complex deltaKappa_remf[orders_EW_size];
1689 deltaKappa_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1690 deltaKappa_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1691 deltaKappa_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1692 deltaKappa_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1693 deltaKappa_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1694 deltaKappa_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1695 if (flag_order[EW1])
1696 deltaKappa_remf[EW1] = myOneLoopEW->deltaKappa_rem_f(f, myMw);
1697 if (flag_order[EW1QCD1])
1698#ifdef WITHIMTWOLOOPQCD
1699 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(),
1700 myTwoLoopQCD->deltaKappa_rem_f(f, myMw).imag(), false);
1701#else
1702 deltaKappa_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1703#endif
1704 if (flag_order[EW1QCD2])
1705 deltaKappa_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1706 if (flag_order[EW2])
1707 deltaKappa_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1708 if (flag_order[EW2QCD1])
1709 deltaKappa_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1710 if (flag_order[EW3])
1711 deltaKappa_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaKappa_rem_f(f, myMw).real(), 0.0, false);
1712
1713 /* compute Delta rbar_rem */
1714 double DeltaRbar_rem = 0.0;
1715 if (flag_order[EW1])
1716 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1717
1718 /* Re[kappa_Z^f] with or without resummation */
1719 double deltaKappa_rem_f_real[orders_EW_size];
1720 for (int j = 0; j < orders_EW_size; ++j)
1721 deltaKappa_rem_f_real[j] = deltaKappa_remf[j].real();
1722
1723 ReKappaZf = resumKappaZ(DeltaRho, deltaKappa_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1724
1725 /* O(alpha^2) correction to Re[kappa_Z^f] from the Z-gamma mixing */
1726 ReKappaZf += 35.0 * alphaMz() * alphaMz() / 18.0 / sW2()
1727 *(1.0 - 8.0 / 3.0 * ReKappaZf * sW2());
1728
1729 /* Im[kappa_Z^f] without resummation */
1730 for (int j = 0; j < orders_EW_size; ++j)
1731 ImKappaZf += deltaKappa_remf[j].imag();
1732 }
1733
1734 kappaZ_f_cache[f.getIndex()] = gslpp::complex(ReKappaZf, ImKappaZf, false);
1735 useKappaZ_f_cache[f.getIndex()] = true;
1736 return (gslpp::complex(ReKappaZf, ImKappaZf, false));
1737}
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 NPbase, and NPSTUVWXY.

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

6158{
6159
6160 bSigmaForAFB = true;
6161 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6162 double relerr = 1.e-7;
6163 double abserr = 1.e-17;
6164
6165 if(s == 133.*133.){
6166 double AFB_noBox, sigma = 0.0;
6167 if (!flagLEP2[ISR])
6168 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6169 else {
6170 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom133, &(*this), _1));
6171 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6172 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6173 }
6174 double numerator = average; // interval
6175
6176
6177 sigma = LEP2sigmaBottom(s);
6178
6179 AFB_noBox = numerator/sigma;
6180 }
6181 SMresult_cache = AFB_noBox;
6182
6183 if (flagLEP2[WeakBox]) {
6184 // numerator
6185 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6186 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6187 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6188 }
6189 double sigma_box_F = average; // interval
6190 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
6191 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6192 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6193 }
6194 double sigma_box_B = average; // interval
6195
6196 // denominator
6197 if (!flagLEP2[ISR]) {
6198
6199 sigma = LEP2sigmaBottom(s);
6200 }
6201
6202 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6203 }
6204 } else if (s == 167.*167.){
6205 double AFB_noBox, sigma = 0.0;
6206 if (!flagLEP2[ISR])
6207 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6208 else {
6209 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom167, &(*this), _1));
6210 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6211 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6212 }
6213 double numerator = average; // interval
6214
6215
6216 sigma = LEP2sigmaBottom(s);
6217
6218 AFB_noBox = numerator/sigma;
6219 }
6220 SMresult_cache = AFB_noBox;
6221
6222 if (flagLEP2[WeakBox]) {
6223 // numerator
6224 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6225 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6226 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6227 }
6228 double sigma_box_F = average; // interval
6229 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
6230 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6231 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6232 }
6233 double sigma_box_B = average; // interval
6234
6235 // denominator
6236 if (!flagLEP2[ISR]) {
6237
6238 sigma = LEP2sigmaBottom(s);
6239 }
6240
6241 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6242 }
6243 } else if (s == 183.*183.) {
6244 double AFB_noBox, sigma = 0.0;
6245 if (!flagLEP2[ISR])
6246 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6247 else {
6248 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom183, &(*this), _1));
6249 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6250 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6251 }
6252 double numerator = average; // interval
6253
6254
6255 sigma = LEP2sigmaBottom(s);
6256
6257 AFB_noBox = numerator/sigma;
6258 }
6259 SMresult_cache = AFB_noBox;
6260
6261 if (flagLEP2[WeakBox]) {
6262 // numerator
6263 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6264 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6265 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6266 }
6267 double sigma_box_F = average; // interval
6268 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
6269 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6270 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6271 }
6272 double sigma_box_B = average; // interval
6273
6274 // denominator
6275 if (!flagLEP2[ISR]) {
6276
6277 sigma = LEP2sigmaBottom(s);
6278 }
6279
6280 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6281 }
6282 } else if (s == 189.*189.) {
6283 double AFB_noBox, sigma = 0.0;
6284 if (!flagLEP2[ISR])
6285 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6286 else {
6287 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom189, &(*this), _1));
6288 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6289 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6290 }
6291 double numerator = average; // interval
6292
6293
6294 sigma = LEP2sigmaBottom(s);
6295
6296 AFB_noBox = numerator/sigma;
6297 }
6298 SMresult_cache = AFB_noBox;
6299
6300 if (flagLEP2[WeakBox]) {
6301 // numerator
6302 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6303 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6304 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6305 }
6306 double sigma_box_F = average; // interval
6307 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
6308 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6309 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6310 }
6311 double sigma_box_B = average; // interval
6312
6313 // denominator
6314 if (!flagLEP2[ISR]) {
6315
6316 sigma = LEP2sigmaBottom(s);
6317 }
6318
6319 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6320 }
6321 } else if (s == 192.*192.) {
6322 double AFB_noBox, sigma = 0.0;
6323 if (!flagLEP2[ISR])
6324 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6325 else {
6326 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom192, &(*this), _1));
6327 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6328 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6329 }
6330 double numerator = average; // interval
6331
6332
6333 sigma = LEP2sigmaBottom(s);
6334
6335 AFB_noBox = numerator/sigma;
6336 }
6337 SMresult_cache = AFB_noBox;
6338
6339 if (flagLEP2[WeakBox]) {
6340 // numerator
6341 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6342 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6343 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6344 }
6345 double sigma_box_F = average; // interval
6346 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
6347 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6348 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6349 }
6350 double sigma_box_B = average; // interval
6351
6352 // denominator
6353 if (!flagLEP2[ISR]) {
6354
6355 sigma = LEP2sigmaBottom(s);
6356 }
6357
6358 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6359 }
6360 } else if (s == 196.*196.) {
6361 double AFB_noBox, sigma = 0.0;
6362 if (!flagLEP2[ISR])
6363 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6364 else {
6365 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom196, &(*this), _1));
6366 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6367 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6368 }
6369 double numerator = average; // interval
6370
6371
6372 sigma = LEP2sigmaBottom(s);
6373
6374 AFB_noBox = numerator/sigma;
6375 }
6376 SMresult_cache = AFB_noBox;
6377
6378 if (flagLEP2[WeakBox]) {
6379 // numerator
6380 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6381 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6382 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6383 }
6384 double sigma_box_F = average; // interval
6385 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
6386 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6387 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6388 }
6389 double sigma_box_B = average; // interval
6390
6391 // denominator
6392 if (!flagLEP2[ISR]) {
6393
6394 sigma = LEP2sigmaBottom(s);
6395 }
6396
6397 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6398 }
6399 } else if (s == 200.*200.) {
6400 double AFB_noBox, sigma = 0.0;
6401 if (!flagLEP2[ISR])
6402 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6403 else {
6404 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom200, &(*this), _1));
6405 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6406 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6407 }
6408 double numerator = average; // interval
6409
6410
6411 sigma = LEP2sigmaBottom(s);
6412
6413 AFB_noBox = numerator/sigma;
6414 }
6415 SMresult_cache = AFB_noBox;
6416
6417 if (flagLEP2[WeakBox]) {
6418 // numerator
6419 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6420 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6421 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6422 }
6423 double sigma_box_F = average; // interval
6424 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
6425 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6426 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6427 }
6428 double sigma_box_B = average; // interval
6429
6430 // denominator
6431 if (!flagLEP2[ISR]) {
6432
6433 sigma = LEP2sigmaBottom(s);
6434 }
6435
6436 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6437 }
6438 } else if (s == 202.*202.) {
6439 double AFB_noBox, sigma = 0.0;
6440 if (!flagLEP2[ISR])
6441 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6442 else {
6443 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom202, &(*this), _1));
6444 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6445 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6446 }
6447 double numerator = average; // interval
6448
6449
6450 sigma = LEP2sigmaBottom(s);
6451
6452 AFB_noBox = numerator/sigma;
6453 }
6454 SMresult_cache = AFB_noBox;
6455
6456 if (flagLEP2[WeakBox]) {
6457 // numerator
6458 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6459 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6460 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6461 }
6462 double sigma_box_F = average; // interval
6463 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
6464 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6465 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6466 }
6467 double sigma_box_B = average; // interval
6468
6469 // denominator
6470 if (!flagLEP2[ISR]) {
6471
6472 sigma = LEP2sigmaBottom(s);
6473 }
6474
6475 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6476 }
6477 } else if (s == 205.*205.) {
6478 double AFB_noBox, sigma = 0.0;
6479 if (!flagLEP2[ISR])
6480 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6481 else {
6482 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom205, &(*this), _1));
6483 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6484 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6485 }
6486 double numerator = average; // interval
6487
6488
6489 sigma = LEP2sigmaBottom(s);
6490
6491 AFB_noBox = numerator/sigma;
6492 }
6493 SMresult_cache = AFB_noBox;
6494
6495 if (flagLEP2[WeakBox]) {
6496 // numerator
6497 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6498 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6499 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6500 }
6501 double sigma_box_F = average; // interval
6502 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6503 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6504 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6505 }
6506 double sigma_box_B = average; // interval
6507
6508 // denominator
6509 if (!flagLEP2[ISR]) {
6510
6511 sigma = LEP2sigmaBottom(s);
6512 }
6513
6514 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6515 }
6516 } else if (s == 207.*207.) {
6517 double AFB_noBox, sigma = 0.0;
6518 if (!flagLEP2[ISR])
6519 AFB_noBox = AFB_NoISR_q(QCD::quark(BOTTOM),s);
6520 else {
6521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_bottom207, &(*this), _1));
6522 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6524 }
6525 double numerator = average; // interval
6526
6527
6528 sigma = LEP2sigmaBottom(s);
6529
6530 AFB_noBox = numerator/sigma;
6531 }
6532 SMresult_cache = AFB_noBox;
6533
6534 if (flagLEP2[WeakBox]) {
6535 // numerator
6536 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6537 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6538 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6539 }
6540 double sigma_box_F = average; // interval
6541 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6542 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6543 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6544 }
6545 double sigma_box_B = average; // interval
6546
6547 // denominator
6548 if (!flagLEP2[ISR]) {
6549
6550 sigma = LEP2sigmaBottom(s);
6551 }
6552
6553 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6554 }
6555 } else {
6556 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBbottom!");
6557 }
6558
6559 double AFBbottom = SMresult_cache;
6560
6561 gsl_set_error_handler(old_handler);
6562 bSigmaForAFB = false;
6563 return AFBbottom;
6564
6565}
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 NPbase, and NPSTUVWXY.

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

6569{
6570
6571 bSigmaForAFB = true;
6572 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6573 double relerr = 1.e-7;
6574 double abserr = 1.e-17;
6575
6576 if(s == 133.*133.){
6577 double AFB_noBox, sigma = 0.0;
6578 if (!flagLEP2[ISR])
6579 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6580 else {
6581 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm133, &(*this), _1));
6582 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6583 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6584 }
6585 double numerator = average; // interval
6586
6587
6588 sigma = LEP2sigmaCharm(s);
6589
6590 AFB_noBox = numerator/sigma;
6591 }
6592 SMresult_cache = AFB_noBox;
6593
6594 if (flagLEP2[WeakBox]) {
6595 // numerator
6596 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6597 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6598 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6599 }
6600 double sigma_box_F = average; // interval
6601 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
6602 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6603 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6604 }
6605 double sigma_box_B = average; // interval
6606
6607 // denominator
6608 if (!flagLEP2[ISR]) {
6609
6610 sigma = LEP2sigmaCharm(s);
6611 }
6612
6613 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6614 }
6615 } else if (s == 167.*167.){
6616 double AFB_noBox, sigma = 0.0;
6617 if (!flagLEP2[ISR])
6618 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6619 else {
6620 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm167, &(*this), _1));
6621 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6622 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6623 }
6624 double numerator = average; // interval
6625
6626
6627 sigma = LEP2sigmaCharm(s);
6628
6629 AFB_noBox = numerator/sigma;
6630 }
6631 SMresult_cache = AFB_noBox;
6632
6633 if (flagLEP2[WeakBox]) {
6634 // numerator
6635 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6636 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6637 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6638 }
6639 double sigma_box_F = average; // interval
6640 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
6641 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6642 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6643 }
6644 double sigma_box_B = average; // interval
6645
6646 // denominator
6647 if (!flagLEP2[ISR]) {
6648
6649 sigma = LEP2sigmaCharm(s);
6650 }
6651
6652 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6653 }
6654 } else if (s == 183.*183.) {
6655 double AFB_noBox, sigma = 0.0;
6656 if (!flagLEP2[ISR])
6657 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6658 else {
6659 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm183, &(*this), _1));
6660 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6661 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6662 }
6663 double numerator = average; // interval
6664
6665
6666 sigma = LEP2sigmaCharm(s);
6667
6668 AFB_noBox = numerator/sigma;
6669 }
6670 SMresult_cache = AFB_noBox;
6671
6672 if (flagLEP2[WeakBox]) {
6673 // numerator
6674 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6675 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6676 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6677 }
6678 double sigma_box_F = average; // interval
6679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
6680 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6682 }
6683 double sigma_box_B = average; // interval
6684
6685 // denominator
6686 if (!flagLEP2[ISR]) {
6687
6688 sigma = LEP2sigmaCharm(s);
6689 }
6690
6691 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6692 }
6693 } else if (s == 189.*189.) {
6694 double AFB_noBox, sigma = 0.0;
6695 if (!flagLEP2[ISR])
6696 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6697 else {
6698 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm189, &(*this), _1));
6699 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6700 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6701 }
6702 double numerator = average; // interval
6703
6704
6705 sigma = LEP2sigmaCharm(s);
6706
6707 AFB_noBox = numerator/sigma;
6708 }
6709 SMresult_cache = AFB_noBox;
6710
6711 if (flagLEP2[WeakBox]) {
6712 // numerator
6713 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6714 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6715 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6716 }
6717 double sigma_box_F = average; // interval
6718 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
6719 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6720 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6721 }
6722 double sigma_box_B = average; // interval
6723
6724 // denominator
6725 if (!flagLEP2[ISR]) {
6726
6727 sigma = LEP2sigmaCharm(s);
6728 }
6729
6730 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6731 }
6732 } else if (s == 192.*192.) {
6733 double AFB_noBox, sigma = 0.0;
6734 if (!flagLEP2[ISR])
6735 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6736 else {
6737 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm192, &(*this), _1));
6738 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6739 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6740 }
6741 double numerator = average; // interval
6742
6743
6744 sigma = LEP2sigmaCharm(s);
6745
6746 AFB_noBox = numerator/sigma;
6747 }
6748 SMresult_cache = AFB_noBox;
6749
6750 if (flagLEP2[WeakBox]) {
6751 // numerator
6752 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6753 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6754 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6755 }
6756 double sigma_box_F = average; // interval
6757 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
6758 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6759 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6760 }
6761 double sigma_box_B = average; // interval
6762
6763 // denominator
6764 if (!flagLEP2[ISR]) {
6765
6766 sigma = LEP2sigmaCharm(s);
6767 }
6768
6769 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6770 }
6771 } else if (s == 196.*196.) {
6772 double AFB_noBox, sigma = 0.0;
6773 if (!flagLEP2[ISR])
6774 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6775 else {
6776 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm196, &(*this), _1));
6777 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6778 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6779 }
6780 double numerator = average; // interval
6781
6782
6783 sigma = LEP2sigmaCharm(s);
6784
6785 AFB_noBox = numerator/sigma;
6786 }
6787 SMresult_cache = AFB_noBox;
6788
6789 if (flagLEP2[WeakBox]) {
6790 // numerator
6791 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6792 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6793 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6794 }
6795 double sigma_box_F = average; // interval
6796 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
6797 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6798 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6799 }
6800 double sigma_box_B = average; // interval
6801
6802 // denominator
6803 if (!flagLEP2[ISR]) {
6804
6805 sigma = LEP2sigmaCharm(s);
6806 }
6807
6808 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6809 }
6810 } else if (s == 200.*200.) {
6811 double AFB_noBox, sigma = 0.0;
6812 if (!flagLEP2[ISR])
6813 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6814 else {
6815 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm200, &(*this), _1));
6816 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6817 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6818 }
6819 double numerator = average; // interval
6820
6821
6822 sigma = LEP2sigmaCharm(s);
6823
6824 AFB_noBox = numerator/sigma;
6825 }
6826 SMresult_cache = AFB_noBox;
6827
6828 if (flagLEP2[WeakBox]) {
6829 // numerator
6830 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6831 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6832 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6833 }
6834 double sigma_box_F = average; // interval
6835 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
6836 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6837 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6838 }
6839 double sigma_box_B = average; // interval
6840
6841 // denominator
6842 if (!flagLEP2[ISR]) {
6843
6844 sigma = LEP2sigmaCharm(s);
6845 }
6846
6847 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6848 }
6849 } else if (s == 202.*202.) {
6850 double AFB_noBox, sigma = 0.0;
6851 if (!flagLEP2[ISR])
6852 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6853 else {
6854 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm202, &(*this), _1));
6855 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6856 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6857 }
6858 double numerator = average; // interval
6859
6860
6861 sigma = LEP2sigmaCharm(s);
6862
6863 AFB_noBox = numerator/sigma;
6864 }
6865 SMresult_cache = AFB_noBox;
6866
6867 if (flagLEP2[WeakBox]) {
6868 // numerator
6869 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6870 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6871 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6872 }
6873 double sigma_box_F = average; // interval
6874 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
6875 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6876 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6877 }
6878 double sigma_box_B = average; // interval
6879
6880 // denominator
6881 if (!flagLEP2[ISR]) {
6882
6883 sigma = LEP2sigmaCharm(s);
6884 }
6885
6886 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6887 }
6888 } else if (s == 205.*205.) {
6889 double AFB_noBox, sigma = 0.0;
6890 if (!flagLEP2[ISR])
6891 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6892 else {
6893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6894 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6895 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6896 }
6897 double numerator = average; // interval
6898
6899
6900 sigma = LEP2sigmaCharm(s);
6901
6902 AFB_noBox = numerator/sigma;
6903 }
6904 SMresult_cache = AFB_noBox;
6905
6906 if (flagLEP2[WeakBox]) {
6907 // numerator
6908 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6909 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6910 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6911 }
6912 double sigma_box_F = average; // interval
6913 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6914 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6915 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6916 }
6917 double sigma_box_B = average; // interval
6918
6919 // denominator
6920 if (!flagLEP2[ISR]) {
6921
6922 sigma = LEP2sigmaCharm(s);
6923 }
6924
6925 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6926 }
6927 } else if (s == 207.*207.) {
6928 double AFB_noBox, sigma = 0.0;
6929 if (!flagLEP2[ISR])
6930 AFB_noBox = AFB_NoISR_q(QCD::quark(CHARM),s);
6931 else {
6932 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_charm205, &(*this), _1));
6933 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6934 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6935 }
6936 double numerator = average; // interval
6937
6938
6939 sigma = LEP2sigmaCharm(s);
6940
6941 AFB_noBox = numerator/sigma;
6942 }
6943 SMresult_cache = AFB_noBox;
6944
6945 if (flagLEP2[WeakBox]) {
6946 // numerator
6947 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6948 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6949 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6950 }
6951 double sigma_box_F = average; // interval
6952 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6953 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6954 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6955 }
6956 double sigma_box_B = average; // interval
6957
6958 // denominator
6959 if (!flagLEP2[ISR]) {
6960
6961 sigma = LEP2sigmaCharm(s);
6962 }
6963
6964 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
6965 }
6966 } else {
6967 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBcharm!");
6968 }
6969
6970 double AFBcharm = SMresult_cache;
6971
6972 gsl_set_error_handler(old_handler);
6973 bSigmaForAFB = false;
6974 return AFBcharm;
6975
6976}
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

Reimplemented in NPbase.

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

6979{
6980 return 0.;
6981}

◆ LEP2AFBmu()

const double StandardModel::LEP2AFBmu ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

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

6984{
6985
6986 bSigmaForAFB = true;
6987 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
6988 double relerr = 1.e-7;
6989 double abserr = 1.e-17;
6990
6991 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
6993
6994 /* SM contribution with the approximate formula */
6996
6997 } else {
6998
6999 if(s == 130.*130.){
7000 double AFB_noBox, sigma = 0.0;
7001 if (!flagLEP2[ISR])
7002 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7003 else {
7004 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu130, &(*this), _1));
7005 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7006 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7007 }
7008 double numerator = average; // interval
7009
7010
7011 sigma = LEP2sigmaMu(s);
7012
7013 AFB_noBox = numerator/sigma;
7014 }
7015 SMresult_cache = AFB_noBox;
7016
7017 if (flagLEP2[WeakBox]) {
7018 // numerator
7019 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7020 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7021 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7022 }
7023 double sigma_box_F = average; // interval
7024 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
7025 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7026 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7027 }
7028 double sigma_box_B = average; // interval
7029
7030 // denominator
7031 if (!flagLEP2[ISR]) {
7032
7033 sigma = LEP2sigmaMu(s);
7034 }
7035
7036 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7037 }
7038 } else if (s == 136.*136.){
7039 double AFB_noBox, sigma = 0.0;
7040 if (!flagLEP2[ISR])
7041 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7042 else {
7043 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu136, &(*this), _1));
7044 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7045 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7046 }
7047 double numerator = average; // interval
7048
7049
7050 sigma = LEP2sigmaMu(s);
7051
7052 AFB_noBox = numerator/sigma;
7053 }
7054 SMresult_cache = AFB_noBox;
7055
7056 if (flagLEP2[WeakBox]) {
7057 // numerator
7058 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7059 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7060 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7061 }
7062 double sigma_box_F = average; // interval
7063 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
7064 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7065 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7066 }
7067 double sigma_box_B = average; // interval
7068
7069 // denominator
7070 if (!flagLEP2[ISR]) {
7071
7072 sigma = LEP2sigmaMu(s);
7073 }
7074
7075 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7076 }
7077 } else if (s == 161.*161.){
7078 double AFB_noBox, sigma = 0.0;
7079 if (!flagLEP2[ISR])
7080 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7081 else {
7082 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu161, &(*this), _1));
7083 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7084 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7085 }
7086 double numerator = average; // interval
7087
7088
7089 sigma = LEP2sigmaMu(s);
7090
7091 AFB_noBox = numerator/sigma;
7092 }
7093 SMresult_cache = AFB_noBox;
7094
7095 if (flagLEP2[WeakBox]) {
7096 // numerator
7097 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7098 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7099 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7100 }
7101 double sigma_box_F = average; // interval
7102 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
7103 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7104 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7105 }
7106 double sigma_box_B = average; // interval
7107
7108 // denominator
7109 if (!flagLEP2[ISR]) {
7110
7111 sigma = LEP2sigmaMu(s);
7112 }
7113
7114 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7115 }
7116 } else if (s == 172.*172.){
7117 double AFB_noBox, sigma = 0.0;
7118 if (!flagLEP2[ISR])
7119 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7120 else {
7121 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu172, &(*this), _1));
7122 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7123 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7124 }
7125 double numerator = average; // interval
7126
7127
7128 sigma = LEP2sigmaMu(s);
7129
7130 AFB_noBox = numerator/sigma;
7131 }
7132 SMresult_cache = AFB_noBox;
7133
7134 if (flagLEP2[WeakBox]) {
7135 // numerator
7136 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7137 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7138 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7139 }
7140 double sigma_box_F = average; // interval
7141 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
7142 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7143 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7144 }
7145 double sigma_box_B = average; // interval
7146
7147 // denominator
7148 if (!flagLEP2[ISR]) {
7149
7150 sigma = LEP2sigmaMu(s);
7151 }
7152
7153 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7154 }
7155 } else if (s == 183.*183.) {
7156 double AFB_noBox, sigma = 0.0;
7157 if (!flagLEP2[ISR])
7158 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7159 else {
7160 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu183, &(*this), _1));
7161 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7162 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7163 }
7164 double numerator = average; // interval
7165
7166
7167 sigma = LEP2sigmaMu(s);
7168
7169 AFB_noBox = numerator/sigma;
7170 }
7171 SMresult_cache = AFB_noBox;
7172
7173 if (flagLEP2[WeakBox]) {
7174 // numerator
7175 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7176 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7177 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7178 }
7179 double sigma_box_F = average; // interval
7180 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
7181 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7182 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7183 }
7184 double sigma_box_B = average; // interval
7185
7186 // denominator
7187 if (!flagLEP2[ISR]) {
7188
7189 sigma = LEP2sigmaMu(s);
7190 }
7191
7192 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7193 }
7194 } else if (s == 189.*189.) {
7195 double AFB_noBox, sigma = 0.0;
7196 if (!flagLEP2[ISR])
7197 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7198 else {
7199 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu189, &(*this), _1));
7200 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7201 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7202 }
7203 double numerator = average; // interval
7204
7205
7206 sigma = LEP2sigmaMu(s);
7207
7208 AFB_noBox = numerator/sigma;
7209 }
7210 SMresult_cache = AFB_noBox;
7211
7212 if (flagLEP2[WeakBox]) {
7213 // numerator
7214 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7215 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7216 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7217 }
7218 double sigma_box_F = average; // interval
7219 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
7220 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7221 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7222 }
7223 double sigma_box_B = average; // interval
7224
7225 // denominator
7226 if (!flagLEP2[ISR]) {
7227
7228 sigma = LEP2sigmaMu(s);
7229 }
7230
7231 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7232 }
7233 } else if (s == 192.*192.) {
7234 double AFB_noBox, sigma = 0.0;
7235 if (!flagLEP2[ISR])
7236 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7237 else {
7238 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu192, &(*this), _1));
7239 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7240 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7241 }
7242 double numerator = average; // interval
7243
7244
7245 sigma = LEP2sigmaMu(s);
7246
7247 AFB_noBox = numerator/sigma;
7248 }
7249 SMresult_cache = AFB_noBox;
7250
7251 if (flagLEP2[WeakBox]) {
7252 // numerator
7253 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7254 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7255 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7256 }
7257 double sigma_box_F = average; // interval
7258 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
7259 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7260 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7261 }
7262 double sigma_box_B = average; // interval
7263
7264 // denominator
7265 if (!flagLEP2[ISR]) {
7266
7267 sigma = LEP2sigmaMu(s);
7268 }
7269
7270 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7271 }
7272 } else if (s == 196.*196.) {
7273 double AFB_noBox, sigma = 0.0;
7274 if (!flagLEP2[ISR])
7275 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7276 else {
7277 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu196, &(*this), _1));
7278 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7279 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7280 }
7281 double numerator = average; // interval
7282
7283
7284 sigma = LEP2sigmaMu(s);
7285
7286 AFB_noBox = numerator/sigma;
7287 }
7288 SMresult_cache = AFB_noBox;
7289
7290 if (flagLEP2[WeakBox]) {
7291 // numerator
7292 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7293 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7294 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7295 }
7296 double sigma_box_F = average; // interval
7297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
7298 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7300 }
7301 double sigma_box_B = average; // interval
7302
7303 // denominator
7304 if (!flagLEP2[ISR]) {
7305
7306 sigma = LEP2sigmaMu(s);
7307 }
7308
7309 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7310 }
7311 } else if (s == 200.*200.) {
7312 double AFB_noBox, sigma = 0.0;
7313 if (!flagLEP2[ISR])
7314 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7315 else {
7316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu200, &(*this), _1));
7317 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7319 }
7320 double numerator = average; // interval
7321
7322
7323 sigma = LEP2sigmaMu(s);
7324
7325 AFB_noBox = numerator/sigma;
7326 }
7327 SMresult_cache = AFB_noBox;
7328
7329 if (flagLEP2[WeakBox]) {
7330 // numerator
7331 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7332 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7333 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7334 }
7335 double sigma_box_F = average; // interval
7336 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
7337 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7338 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7339 }
7340 double sigma_box_B = average; // interval
7341
7342 // denominator
7343 if (!flagLEP2[ISR]) {
7344
7345 sigma = LEP2sigmaMu(s);
7346 }
7347
7348 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7349 }
7350 } else if (s == 202.*202.) {
7351 double AFB_noBox, sigma = 0.0;
7352 if (!flagLEP2[ISR])
7353 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7354 else {
7355 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu202, &(*this), _1));
7356 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7357 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7358 }
7359 double numerator = average; // interval
7360
7361
7362 sigma = LEP2sigmaMu(s);
7363
7364 AFB_noBox = numerator/sigma;
7365 }
7366 SMresult_cache = AFB_noBox;
7367
7368 if (flagLEP2[WeakBox]) {
7369 // numerator
7370 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7371 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7372 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7373 }
7374 double sigma_box_F = average; // interval
7375 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
7376 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7377 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7378 }
7379 double sigma_box_B = average; // interval
7380
7381 // denominator
7382 if (!flagLEP2[ISR]) {
7383
7384 sigma = LEP2sigmaMu(s);
7385 }
7386
7387 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7388 }
7389 } else if (s == 205.*205.) {
7390 double AFB_noBox, sigma = 0.0;
7391 if (!flagLEP2[ISR])
7392 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7393 else {
7394 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu205, &(*this), _1));
7395 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7396 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7397 }
7398 double numerator = average; // interval
7399
7400
7401 sigma = LEP2sigmaMu(s);
7402
7403 AFB_noBox = numerator/sigma;
7404 }
7405 SMresult_cache = AFB_noBox;
7406
7407 if (flagLEP2[WeakBox]) {
7408 // numerator
7409 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7410 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7411 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7412 }
7413 double sigma_box_F = average; // interval
7414 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
7415 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7416 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7417 }
7418 double sigma_box_B = average; // interval
7419
7420 // denominator
7421 if (!flagLEP2[ISR]) {
7422
7423 sigma = LEP2sigmaMu(s);
7424 }
7425
7426 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7427 }
7428 } else if (s == 207.*207.) {
7429 double AFB_noBox, sigma = 0.0;
7430 if (!flagLEP2[ISR])
7431 AFB_noBox = AFB_NoISR_l(QCD::lepton(MU),s);
7432 else {
7433 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_mu207, &(*this), _1));
7434 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7435 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7436 }
7437 double numerator = average; // interval
7438
7439
7440 sigma = LEP2sigmaMu(s);
7441
7442 AFB_noBox = numerator/sigma;
7443 }
7444 SMresult_cache = AFB_noBox;
7445
7446 if (flagLEP2[WeakBox]) {
7447 // numerator
7448 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7449 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7450 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7451 }
7452 double sigma_box_F = average; // interval
7453 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
7454 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7455 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7456 }
7457 double sigma_box_B = average; // interval
7458
7459 // denominator
7460 if (!flagLEP2[ISR]) {
7461
7462 sigma = LEP2sigmaMu(s);
7463 }
7464
7465 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7466 }
7467 } else {
7468 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::AFBmu!");
7469 }
7470
7471 double AFBmu = SMresult_cache;
7472
7473 gsl_set_error_handler(old_handler);
7474 bSigmaForAFB = false;
7475 return AFBmu;
7476 }
7477}
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 NPbase, and NPSTUVWXY.

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

7481{
7482
7483 bSigmaForAFB = true;
7484 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
7485 double relerr = 1.e-7;
7486 double abserr = 1.e-17;
7487
7488 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
7490
7491 /* SM contribution with the approximate formula */
7493
7494 } else {
7495
7496 if(s == 130.*130.){
7497 double AFB_noBox, sigma = 0.0;
7498 if (!flagLEP2[ISR])
7499 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7500 else {
7501 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau130, &(*this), _1));
7502 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7503 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7504 }
7505 double numerator = average; // interval
7506
7507
7508 sigma = LEP2sigmaTau(s);
7509
7510 AFB_noBox = numerator/sigma;
7511 }
7512 SMresult_cache = AFB_noBox;
7513
7514 if (flagLEP2[WeakBox]) {
7515 // numerator
7516 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7517 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7518 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7519 }
7520 double sigma_box_F = average; // interval
7521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
7522 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7524 }
7525 double sigma_box_B = average; // interval
7526
7527 // denominator
7528 if (!flagLEP2[ISR]) {
7529
7530 sigma = LEP2sigmaTau(s);
7531 }
7532
7533 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7534 }
7535 } else if (s == 136.*136.){
7536 double AFB_noBox, sigma = 0.0;
7537 if (!flagLEP2[ISR])
7538 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7539 else {
7540 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau136, &(*this), _1));
7541 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7542 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7543 }
7544 double numerator = average; // interval
7545
7546
7547 sigma = LEP2sigmaTau(s);
7548
7549 AFB_noBox = numerator/sigma;
7550 }
7551 SMresult_cache = AFB_noBox;
7552
7553 if (flagLEP2[WeakBox]) {
7554 // numerator
7555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7556 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7558 }
7559 double sigma_box_F = average; // interval
7560 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
7561 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7562 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7563 }
7564 double sigma_box_B = average; // interval
7565
7566 // denominator
7567 if (!flagLEP2[ISR]) {
7568
7569 sigma = LEP2sigmaTau(s);
7570 }
7571
7572 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7573 }
7574 } else if (s == 161.*161.){
7575 double AFB_noBox, sigma = 0.0;
7576 if (!flagLEP2[ISR])
7577 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7578 else {
7579 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau161, &(*this), _1));
7580 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7581 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7582 }
7583 double numerator = average; // interval
7584
7585
7586 sigma = LEP2sigmaTau(s);
7587
7588 AFB_noBox = numerator/sigma;
7589 }
7590 SMresult_cache = AFB_noBox;
7591
7592 if (flagLEP2[WeakBox]) {
7593 // numerator
7594 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7595 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7596 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7597 }
7598 double sigma_box_F = average; // interval
7599 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
7600 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7601 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7602 }
7603 double sigma_box_B = average; // interval
7604
7605 // denominator
7606 if (!flagLEP2[ISR]) {
7607
7608 sigma = LEP2sigmaTau(s);
7609 }
7610
7611 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7612 }
7613 } else if (s == 172.*172.){
7614 double AFB_noBox, sigma = 0.0;
7615 if (!flagLEP2[ISR])
7616 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7617 else {
7618 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau172, &(*this), _1));
7619 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7620 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7621 }
7622 double numerator = average; // interval
7623
7624
7625 sigma = LEP2sigmaTau(s);
7626
7627 AFB_noBox = numerator/sigma;
7628 }
7629 SMresult_cache = AFB_noBox;
7630
7631 if (flagLEP2[WeakBox]) {
7632 // numerator
7633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7634 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7636 }
7637 double sigma_box_F = average; // interval
7638 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
7639 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7640 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7641 }
7642 double sigma_box_B = average; // interval
7643
7644 // denominator
7645 if (!flagLEP2[ISR]) {
7646
7647 sigma = LEP2sigmaTau(s);
7648 }
7649
7650 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7651 }
7652 } else if (s == 183.*183.) {
7653 double AFB_noBox, sigma = 0.0;
7654 if (!flagLEP2[ISR])
7655 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7656 else {
7657 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau183, &(*this), _1));
7658 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7659 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7660 }
7661 double numerator = average; // interval
7662
7663
7664 sigma = LEP2sigmaTau(s);
7665
7666 AFB_noBox = numerator/sigma;
7667 }
7668 SMresult_cache = AFB_noBox;
7669
7670 if (flagLEP2[WeakBox]) {
7671 // numerator
7672 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7673 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7674 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7675 }
7676 double sigma_box_F = average; // interval
7677 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
7678 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7679 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7680 }
7681 double sigma_box_B = average; // interval
7682
7683 // denominator
7684 if (!flagLEP2[ISR]) {
7685
7686 sigma = LEP2sigmaTau(s);
7687 }
7688
7689 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7690 }
7691 } else if (s == 189.*189.) {
7692 double AFB_noBox, sigma = 0.0;
7693 if (!flagLEP2[ISR])
7694 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7695 else {
7696 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau189, &(*this), _1));
7697 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7698 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7699 }
7700 double numerator = average; // interval
7701
7702
7703 sigma = LEP2sigmaTau(s);
7704
7705 AFB_noBox = numerator/sigma;
7706 }
7707 SMresult_cache = AFB_noBox;
7708
7709 if (flagLEP2[WeakBox]) {
7710 // numerator
7711 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7712 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7713 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7714 }
7715 double sigma_box_F = average; // interval
7716 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
7717 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7718 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7719 }
7720 double sigma_box_B = average; // interval
7721
7722 // denominator
7723 if (!flagLEP2[ISR]) {
7724
7725 sigma = LEP2sigmaTau(s);
7726 }
7727
7728 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7729 }
7730 } else if (s == 192.*192.) {
7731 double AFB_noBox, sigma = 0.0;
7732 if (!flagLEP2[ISR])
7733 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7734 else {
7735 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau192, &(*this), _1));
7736 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7737 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7738 }
7739 double numerator = average; // interval
7740
7741
7742 sigma = LEP2sigmaTau(s);
7743
7744 AFB_noBox = numerator/sigma;
7745 }
7746 SMresult_cache = AFB_noBox;
7747
7748 if (flagLEP2[WeakBox]) {
7749 // numerator
7750 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7751 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7752 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7753 }
7754 double sigma_box_F = average; // interval
7755 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
7756 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7757 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7758 }
7759 double sigma_box_B = average; // interval
7760
7761 // denominator
7762 if (!flagLEP2[ISR]) {
7763
7764 sigma = LEP2sigmaTau(s);
7765 }
7766
7767 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7768 }
7769 } else if (s == 196.*196.) {
7770 double AFB_noBox, sigma = 0.0;
7771 if (!flagLEP2[ISR])
7772 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7773 else {
7774 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau196, &(*this), _1));
7775 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7776 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7777 }
7778 double numerator = average; // interval
7779
7780
7781 sigma = LEP2sigmaTau(s);
7782
7783 AFB_noBox = numerator/sigma;
7784 }
7785 SMresult_cache = AFB_noBox;
7786
7787 if (flagLEP2[WeakBox]) {
7788 // numerator
7789 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7790 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7791 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7792 }
7793 double sigma_box_F = average; // interval
7794 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
7795 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7796 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7797 }
7798 double sigma_box_B = average; // interval
7799
7800 // denominator
7801 if (!flagLEP2[ISR]) {
7802
7803 sigma = LEP2sigmaTau(s);
7804 }
7805
7806 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7807 }
7808 } else if (s == 200.*200.) {
7809 double AFB_noBox, sigma = 0.0;
7810 if (!flagLEP2[ISR])
7811 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7812 else {
7813 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau200, &(*this), _1));
7814 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7815 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7816 }
7817 double numerator = average; // interval
7818
7819
7820 sigma = LEP2sigmaTau(s);
7821
7822 AFB_noBox = numerator/sigma;
7823 }
7824 SMresult_cache = AFB_noBox;
7825
7826 if (flagLEP2[WeakBox]) {
7827 // numerator
7828 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7829 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7830 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7831 }
7832 double sigma_box_F = average; // interval
7833 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
7834 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7835 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7836 }
7837 double sigma_box_B = average; // interval
7838
7839 // denominator
7840 if (!flagLEP2[ISR]) {
7841
7842 sigma = LEP2sigmaTau(s);
7843 }
7844
7845 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7846 }
7847 } else if (s == 202.*202.) {
7848 double AFB_noBox, sigma = 0.0;
7849 if (!flagLEP2[ISR])
7850 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7851 else {
7852 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau202, &(*this), _1));
7853 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7854 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7855 }
7856 double numerator = average; // interval
7857
7858
7859 sigma = LEP2sigmaTau(s);
7860
7861 AFB_noBox = numerator/sigma;
7862 }
7863 SMresult_cache = AFB_noBox;
7864
7865 if (flagLEP2[WeakBox]) {
7866 // numerator
7867 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7868 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7869 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7870 }
7871 double sigma_box_F = average; // interval
7872 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
7873 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7874 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7875 }
7876 double sigma_box_B = average; // interval
7877
7878 // denominator
7879 if (!flagLEP2[ISR]) {
7880
7881 sigma = LEP2sigmaTau(s);
7882 }
7883
7884 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7885 }
7886 } else if (s == 205.*205.) {
7887 double AFB_noBox, sigma = 0.0;
7888 if (!flagLEP2[ISR])
7889 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7890 else {
7891 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau205, &(*this), _1));
7892 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7893 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7894 }
7895 double numerator = average; // interval
7896
7897
7898 sigma = LEP2sigmaTau(s);
7899
7900 AFB_noBox = numerator/sigma;
7901 }
7902 SMresult_cache = AFB_noBox;
7903
7904 if (flagLEP2[WeakBox]) {
7905 // numerator
7906 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7907 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7908 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7909 }
7910 double sigma_box_F = average; // interval
7911 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
7912 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7913 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7914 }
7915 double sigma_box_B = average; // interval
7916
7917 // denominator
7918 if (!flagLEP2[ISR]) {
7919
7920 sigma = LEP2sigmaTau(s);
7921 }
7922
7923 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7924 }
7925 } else if (s == 207.*207.) {
7926 double AFB_noBox, sigma = 0.0;
7927 if (!flagLEP2[ISR])
7928 AFB_noBox = AFB_NoISR_l(QCD::lepton(TAU),s);
7929 else {
7930 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_AFBnumeratorWithISR_tau207, &(*this), _1));
7931 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7932 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7933 }
7934 double numerator = average; // interval
7935
7936
7937 sigma = LEP2sigmaTau(s);
7938
7939 AFB_noBox = numerator/sigma;
7940 }
7941 SMresult_cache = AFB_noBox;
7942
7943 if (flagLEP2[WeakBox]) {
7944 // numerator
7945 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7946 if (gsl_integration_qags(&f_GSL, 0., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7947 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7948 }
7949 double sigma_box_F = average; // interval
7950 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
7951 if (gsl_integration_qags(&f_GSL, -1., 0., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
7952 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
7953 }
7954 double sigma_box_B = average; // interval
7955
7956 // denominator
7957 if (!flagLEP2[ISR]) {
7958
7959 sigma = LEP2sigmaTau(s);
7960 }
7961
7962 SMresult_cache += (sigma_box_F - sigma_box_B)/sigma;
7963 }
7964 } else {
7965 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBtau!");
7966 }
7967
7968 double AFBtau = SMresult_cache;
7969
7970 gsl_set_error_handler(old_handler);
7971 bSigmaForAFB = false;
7972 return AFBtau;
7973 }
7974}
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

Reimplemented in NPbase.

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

9647{
9648 return LEP2dsigmadcosE(s, cos);
9649}
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

Reimplemented in NPbase.

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

9652{
9653 return LEP2dsigmadcosMu(s, cos);
9654}
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

Reimplemented in NPbase.

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

9657{
9658 return LEP2dsigmadcosTau(s, cos);
9659}
virtual const double LEP2dsigmadcosTau(const double s, const double cos) const

◆ LEP2dsigmadcosE()

const double StandardModel::LEP2dsigmadcosE ( const double  s,
const double  cos 
) const
virtual

Reimplemented in NPbase.

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

9605{
9606 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9608
9609 /* SM contribution with the approximate formula */
9611
9612 } else {
9613 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosE only implemented via semi-analytical approx");
9614 }
9615}
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

Reimplemented in NPbase.

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

9618{
9619 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9621
9622 /* SM contribution with the approximate formula */
9624
9625 } else {
9626 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosMu only implemented via semi-analytical approx");
9627 }
9628}
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

Reimplemented in NPbase.

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

9631{
9632 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
9634
9635 /* SM contribution with the approximate formula */
9637
9638 } else {
9639 throw std::runtime_error("ERROR: StandardModel::LEP2dsigmadcosTau only implemented via semi-analytical approx");
9640 }
9641}
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 NPbase, and NPSTUVWXY.

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

7978{
7979
7980 double sigma_b = LEP2sigmaBottom(s);
7981 double sigma_had = LEP2sigmaHadron(s);
7982 SMresult_cache = sigma_b / sigma_had;
7983 double R_bottom = SMresult_cache;
7984
7985 return R_bottom;
7986}
virtual const double LEP2sigmaHadron(const double s) const

◆ LEP2Rcharm()

const double StandardModel::LEP2Rcharm ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

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

7990{
7991
7992 double sigma_c = LEP2sigmaCharm(s);
7993 double sigma_had = LEP2sigmaHadron(s);
7994 SMresult_cache = sigma_c / sigma_had;
7995 double R_charm = SMresult_cache;
7996
7997 return R_charm;
7998}

◆ LEP2sigmaBottom()

const double StandardModel::LEP2sigmaBottom ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

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

4815{
4816 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4817 double relerr = 1.e-8;
4818 double abserr = 1.e-20;
4819
4820 if(s == 133.*133.){
4821
4822 if (!flagLEP2[ISR]){
4824 } else {
4825 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
4826 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4827 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4828 }
4830 }
4831
4832 if (flagLEP2[WeakBox]) {
4833 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
4834 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4835 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4836 }
4837 double sigma_box = average;
4838 SMresult_cache += sigma_box;
4839 }
4840 } else if (s == 167.*167.){
4841 if (!flagLEP2[ISR])
4843 else {
4844 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
4845 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4846 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4847 }
4849 }
4850
4851 if (flagLEP2[WeakBox]) {
4852 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
4853 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4854 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4855 }
4856 double sigma_box = average;
4857 SMresult_cache += sigma_box;
4858 }
4859 } else if (s == 183.*183.) {
4860 if (!flagLEP2[ISR])
4862 else {
4863 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
4864 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4865 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4866 }
4868 }
4869
4870 if (flagLEP2[WeakBox]) {
4871 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
4872 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4873 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4874 }
4875 double sigma_box = average;
4876 SMresult_cache += sigma_box;
4877 }
4878 } else if (s == 189.*189.) {
4879 if (!flagLEP2[ISR])
4881 else {
4882 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
4883 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4884 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4885 }
4887 }
4888
4889 if (flagLEP2[WeakBox]) {
4890 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
4891 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4892 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4893 }
4894 double sigma_box = average;
4895 SMresult_cache += sigma_box;
4896 }
4897 } else if (s == 192.*192.) {
4898 if (!flagLEP2[ISR])
4900 else {
4901 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
4902 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4903 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4904 }
4906 }
4907
4908 if (flagLEP2[WeakBox]) {
4909 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
4910 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4911 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4912 }
4913 double sigma_box = average;
4914 SMresult_cache += sigma_box;
4915 }
4916 } else if (s == 196.*196.) {
4917 if (!flagLEP2[ISR])
4919 else {
4920 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
4921 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4922 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4923 }
4925 }
4926
4927 if (flagLEP2[WeakBox]) {
4928 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
4929 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4930 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4931 }
4932 double sigma_box = average;
4933 SMresult_cache += sigma_box;
4934 }
4935 } else if (s == 200.*200.) {
4936 if (!flagLEP2[ISR])
4938 else {
4939 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
4940 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4941 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4942 }
4944 }
4945
4946 if (flagLEP2[WeakBox]) {
4947 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
4948 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4949 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4950 }
4951 double sigma_box = average;
4952 SMresult_cache += sigma_box;
4953 }
4954 } else if (s == 202.*202.) {
4955 if (!flagLEP2[ISR])
4957 else {
4958 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
4959 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4960 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4961 }
4963 }
4964
4965 if (flagLEP2[WeakBox]) {
4966 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
4967 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4968 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4969 }
4970 double sigma_box = average;
4971 SMresult_cache += sigma_box;
4972 }
4973 } else if (s == 205.*205.) {
4974 if (!flagLEP2[ISR])
4976 else {
4977 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
4978 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4979 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4980 }
4982 }
4983
4984 if (flagLEP2[WeakBox]) {
4985 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
4986 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4987 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4988 }
4989 double sigma_box = average;
4990 SMresult_cache += sigma_box;
4991 }
4992 } else if (s == 207.*207.) {
4993 if (!flagLEP2[ISR])
4995 else {
4996 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
4997 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4998 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4999 }
5001 }
5002
5003 if (flagLEP2[WeakBox]) {
5004 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
5005 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5006 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5007 }
5008 double sigma_box = average;
5009 SMresult_cache += sigma_box;
5010 }
5011 } else {
5012 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaBottom!");
5013 }
5014
5015
5016 double sigma_mu = SMresult_cache;
5017
5018 gsl_set_error_handler(old_handler);
5019
5020 return sigma_mu;
5021
5022}
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 NPbase, and NPSTUVWXY.

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

4604{
4605 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4606 double relerr = 1.e-8;
4607 double abserr = 1.e-20;
4608
4609 if(s == 133.*133.){
4610
4611 if (!flagLEP2[ISR]){
4613 } else {
4614 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
4615 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4616 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4617 }
4619 }
4620
4621 if (flagLEP2[WeakBox]) {
4622 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
4623 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4624 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4625 }
4626 double sigma_box = average;
4627 SMresult_cache += sigma_box;
4628 }
4629 } else if (s == 167.*167.){
4630 if (!flagLEP2[ISR])
4632 else {
4633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
4634 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4636 }
4638 }
4639
4640 if (flagLEP2[WeakBox]) {
4641 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
4642 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4643 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4644 }
4645 double sigma_box = average;
4646 SMresult_cache += sigma_box;
4647 }
4648 } else if (s == 183.*183.) {
4649 if (!flagLEP2[ISR])
4651 else {
4652 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
4653 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4654 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4655 }
4657 }
4658
4659 if (flagLEP2[WeakBox]) {
4660 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
4661 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4662 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4663 }
4664 double sigma_box = average;
4665 SMresult_cache += sigma_box;
4666 }
4667 } else if (s == 189.*189.) {
4668 if (!flagLEP2[ISR])
4670 else {
4671 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
4672 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4673 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4674 }
4676 }
4677
4678 if (flagLEP2[WeakBox]) {
4679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
4680 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4682 }
4683 double sigma_box = average;
4684 SMresult_cache += sigma_box;
4685 }
4686 } else if (s == 192.*192.) {
4687 if (!flagLEP2[ISR])
4689 else {
4690 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
4691 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4692 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4693 }
4695 }
4696
4697 if (flagLEP2[WeakBox]) {
4698 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
4699 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4700 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4701 }
4702 double sigma_box = average;
4703 SMresult_cache += sigma_box;
4704 }
4705 } else if (s == 196.*196.) {
4706 if (!flagLEP2[ISR])
4708 else {
4709 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
4710 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4711 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4712 }
4714 }
4715
4716 if (flagLEP2[WeakBox]) {
4717 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
4718 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4719 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4720 }
4721 double sigma_box = average;
4722 SMresult_cache += sigma_box;
4723 }
4724 } else if (s == 200.*200.) {
4725 if (!flagLEP2[ISR])
4727 else {
4728 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
4729 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4730 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4731 }
4733 }
4734
4735 if (flagLEP2[WeakBox]) {
4736 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
4737 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4738 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4739 }
4740 double sigma_box = average;
4741 SMresult_cache += sigma_box;
4742 }
4743 } else if (s == 202.*202.) {
4744 if (!flagLEP2[ISR])
4746 else {
4747 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
4748 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4749 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4750 }
4752 }
4753
4754 if (flagLEP2[WeakBox]) {
4755 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
4756 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4757 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4758 }
4759 double sigma_box = average;
4760 SMresult_cache += sigma_box;
4761 }
4762 } else if (s == 205.*205.) {
4763 if (!flagLEP2[ISR])
4765 else {
4766 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
4767 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4768 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4769 }
4771 }
4772
4773 if (flagLEP2[WeakBox]) {
4774 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
4775 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4776 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4777 }
4778 double sigma_box = average;
4779 SMresult_cache += sigma_box;
4780 }
4781 } else if (s == 207.*207.) {
4782 if (!flagLEP2[ISR])
4784 else {
4785 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
4786 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4787 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4788 }
4790 }
4791
4792 if (flagLEP2[WeakBox]) {
4793 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
4794 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4795 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4796 }
4797 double sigma_box = average;
4798 SMresult_cache += sigma_box;
4799 }
4800 } else {
4801 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaCharm!");
4802 }
4803
4804
4805 double sigma_mu = SMresult_cache;
4806
4807 gsl_set_error_handler(old_handler);
4808
4809 return sigma_mu;
4810
4811}
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

Reimplemented in NPbase.

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

4084{
4085 return 0.;
4086}

◆ LEP2sigmaHadron()

const double StandardModel::LEP2sigmaHadron ( const double  s) const
virtual

Reimplemented in NPbase, and NPSTUVWXY.

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

5026{
5027 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
5028 double relerr = 1.e-8;
5029 double abserr = 1.e-20;
5030
5031 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
5033
5034 /* SM contribution with the approximate formula */
5036
5037 } else {
5038
5039 if(s == 130.*130.){
5040
5041 if (!flagLEP2[ISR]){
5047 } else {
5048
5049 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up130, &(*this), _1));
5050 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5051 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5052 }
5054
5055 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down130, &(*this), _1));
5056 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5057 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5058 }
5060
5061 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm130, &(*this), _1));
5062 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5063 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5064 }
5066
5067 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange130, &(*this), _1));
5068 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5069 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5070 }
5072
5073 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom130, &(*this), _1));
5074 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5075 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5076 }
5078
5079 }
5080
5081 if (flagLEP2[WeakBox]) {
5082 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up130, &(*this), _1));
5083 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5084 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5085 }
5086 double sigma_box = average;
5087
5088 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down130, &(*this), _1));
5089 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5090 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5091 }
5092 sigma_box += average;
5093
5094 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm130, &(*this), _1));
5095 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5096 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5097 }
5098 sigma_box += average;
5099
5100 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange130, &(*this), _1));
5101 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5103 }
5104 sigma_box += average;
5105
5106 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom130, &(*this), _1));
5107 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5108 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5109 }
5110 sigma_box += average;
5111 SMresult_cache += sigma_box;
5112 }
5113 } else if (s == 133.*133.) {
5114 if (!flagLEP2[ISR]){
5120 } else {
5121
5122 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up133, &(*this), _1));
5123 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5124 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5125 }
5127
5128 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down133, &(*this), _1));
5129 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5130 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5131 }
5133
5134 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm133, &(*this), _1));
5135 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5136 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5137 }
5139
5140 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange133, &(*this), _1));
5141 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5142 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5143 }
5145
5146 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom133, &(*this), _1));
5147 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5148 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5149 }
5151 }
5152
5153 if (flagLEP2[WeakBox]) {
5154 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up133, &(*this), _1));
5155 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5156 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5157 }
5158 double sigma_box = average;
5159
5160 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down133, &(*this), _1));
5161 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5162 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5163 }
5164 sigma_box += average;
5165
5166 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm133, &(*this), _1));
5167 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5168 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5169 }
5170 sigma_box += average;
5171
5172 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange133, &(*this), _1));
5173 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5174 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5175 }
5176 sigma_box += average;
5177
5178 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom133, &(*this), _1));
5179 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5180 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5181 }
5182 sigma_box += average;
5183 SMresult_cache += sigma_box;
5184 }
5185 } else if (s == 136.*136.) {
5186 if (!flagLEP2[ISR]){
5192 } else {
5193
5194 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up136, &(*this), _1));
5195 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5196 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5197 }
5199
5200 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down136, &(*this), _1));
5201 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5202 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5203 }
5205
5206 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm136, &(*this), _1));
5207 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5208 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5209 }
5211
5212 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange136, &(*this), _1));
5213 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5214 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5215 }
5217
5218 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom136, &(*this), _1));
5219 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5220 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5221 }
5223 }
5224
5225 if (flagLEP2[WeakBox]) {
5226 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up136, &(*this), _1));
5227 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5228 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5229 }
5230 double sigma_box = average;
5231
5232 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down136, &(*this), _1));
5233 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5234 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5235 }
5236 sigma_box += average;
5237
5238 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm136, &(*this), _1));
5239 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5240 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5241 }
5242 sigma_box += average;
5243
5244 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange136, &(*this), _1));
5245 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5246 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5247 }
5248 sigma_box += average;
5249
5250 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom136, &(*this), _1));
5251 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5252 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5253 }
5254 sigma_box += average;
5255 SMresult_cache += sigma_box;
5256 }
5257 } else if (s == 161.*161.){
5258 if (!flagLEP2[ISR]){
5264 } else {
5265
5266 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up161, &(*this), _1));
5267 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5268 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5269 }
5271
5272 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down161, &(*this), _1));
5273 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5274 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5275 }
5277
5278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm161, &(*this), _1));
5279 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-12, 1.e-6, 100, w_GSL1, &average, &error) != 0){
5280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5281 }
5283
5284 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange161, &(*this), _1));
5285 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 200, w_GSL1, &average, &error) != 0){
5286 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5287 }
5289
5290 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom161, &(*this), _1));
5291 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5292 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5293 }
5295 }
5296
5297 if (flagLEP2[WeakBox]) {
5298 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up161, &(*this), _1));
5299 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5300 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5301 }
5302 double sigma_box = average;
5303
5304 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down161, &(*this), _1));
5305 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5306 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5307 }
5308 sigma_box += average;
5309
5310 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm161, &(*this), _1));
5311 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5312 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5313 }
5314 sigma_box += average;
5315
5316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange161, &(*this), _1));
5317 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5319 }
5320 sigma_box += average;
5321
5322 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom161, &(*this), _1));
5323 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5324 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5325 }
5326 sigma_box += average;
5327 SMresult_cache += sigma_box;
5328 }
5329 } else if (s == 167.*167.) {
5330 if (!flagLEP2[ISR]){
5336 } else {
5337
5338 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up167, &(*this), _1));
5339 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5340 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5341 }
5342
5344
5345 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down167, &(*this), _1));
5346 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5347 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5348 }
5350
5351 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm167, &(*this), _1));
5352 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5353 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5354 }
5356
5357 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange167, &(*this), _1));
5358 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5359 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5360 }
5362
5363 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom167, &(*this), _1));
5364 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, 1.e-15, 1.e-9, 200, w_GSL1, &average, &error) != 0){
5365 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5366 }
5368 }
5369
5370 if (flagLEP2[WeakBox]) {
5371 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up167, &(*this), _1));
5372 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5373 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5374 }
5375 double sigma_box = average;
5376
5377 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down167, &(*this), _1));
5378 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5379 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5380 }
5381 sigma_box += average;
5382
5383 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm167, &(*this), _1));
5384 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5385 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5386 }
5387 sigma_box += average;
5388
5389 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange167, &(*this), _1));
5390 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5391 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5392 }
5393 sigma_box += average;
5394
5395 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom167, &(*this), _1));
5396 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5397 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5398 }
5399 sigma_box += average;
5400 SMresult_cache += sigma_box;
5401 }
5402 } else if (s == 172.*172.) {
5403 if (!flagLEP2[ISR]){
5409 } else {
5410
5411 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up172, &(*this), _1));
5412 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5413 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5414 }
5416
5417 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down172, &(*this), _1));
5418 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5419 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5420 }
5422
5423 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm172, &(*this), _1));
5424 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5425 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5426 }
5428
5429 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange172, &(*this), _1));
5430 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5431 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5432 }
5434
5435 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom172, &(*this), _1));
5436 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5437 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5438 }
5440 }
5441
5442 if (flagLEP2[WeakBox]) {
5443 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up172, &(*this), _1));
5444 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5445 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5446 }
5447 double sigma_box = average;
5448
5449 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down172, &(*this), _1));
5450 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5451 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5452 }
5453 sigma_box += average;
5454
5455 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm172, &(*this), _1));
5456 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5457 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5458 }
5459 sigma_box += average;
5460
5461 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange172, &(*this), _1));
5462 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5463 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5464 }
5465 sigma_box += average;
5466
5467 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom172, &(*this), _1));
5468 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5469 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5470 }
5471 sigma_box += average;
5472 SMresult_cache += sigma_box;
5473 }
5474 } else if (s == 183.*183.) {
5475 if (!flagLEP2[ISR]){
5481 } else {
5482
5483 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up183, &(*this), _1));
5484 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5485 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5486 }
5488
5489 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down183, &(*this), _1));
5490 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5491 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5492 }
5494
5495 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm183, &(*this), _1));
5496 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5497 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5498 }
5500
5501 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange183, &(*this), _1));
5502 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5503 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5504 }
5506
5507 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom183, &(*this), _1));
5508 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5509 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5510 }
5512 }
5513
5514 if (flagLEP2[WeakBox]) {
5515 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up183, &(*this), _1));
5516 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5517 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5518 }
5519 double sigma_box = average;
5520
5521 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down183, &(*this), _1));
5522 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5523 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5524 }
5525 sigma_box += average;
5526
5527 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm183, &(*this), _1));
5528 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5529 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5530 }
5531 sigma_box += average;
5532
5533 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange183, &(*this), _1));
5534 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5535 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5536 }
5537 sigma_box += average;
5538
5539 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom183, &(*this), _1));
5540 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5541 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5542 }
5543 sigma_box += average;
5544 SMresult_cache += sigma_box;
5545 }
5546 } else if (s == 189.*189.) {
5547 if (!flagLEP2[ISR]){
5553 } else {
5554
5555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up189, &(*this), _1));
5556 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5558 }
5560
5561 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down189, &(*this), _1));
5562 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5563 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5564 }
5566
5567 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm189, &(*this), _1));
5568 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5569 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5570 }
5572
5573 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange189, &(*this), _1));
5574 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5575 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5576 }
5578
5579 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom189, &(*this), _1));
5580 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5581 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5582 }
5584 }
5585
5586 if (flagLEP2[WeakBox]) {
5587 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up189, &(*this), _1));
5588 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5589 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5590 }
5591 double sigma_box = average;
5592
5593 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down189, &(*this), _1));
5594 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5595 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5596 }
5597 sigma_box += average;
5598
5599 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm189, &(*this), _1));
5600 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5601 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5602 }
5603 sigma_box += average;
5604
5605 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange189, &(*this), _1));
5606 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5607 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5608 }
5609 sigma_box += average;
5610
5611 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom189, &(*this), _1));
5612 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5613 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5614 }
5615 sigma_box += average;
5616 SMresult_cache += sigma_box;
5617 }
5618 } else if (s == 192.*192.) {
5619 if (!flagLEP2[ISR]){
5625 } else {
5626
5627 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up192, &(*this), _1));
5628 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5629 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5630 }
5632
5633 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down192, &(*this), _1));
5634 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5635 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5636 }
5638
5639 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm192, &(*this), _1));
5640
5641 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5642 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5643 }
5645
5646 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange192, &(*this), _1));
5647
5648 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5649 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5650 }
5652
5653 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom192, &(*this), _1));
5654 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5655 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5656 }
5658 }
5659
5660 if (flagLEP2[WeakBox]) {
5661 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up192, &(*this), _1));
5662 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5663 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5664 }
5665 double sigma_box = average;
5666
5667 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down192, &(*this), _1));
5668 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5669 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5670 }
5671 sigma_box += average;
5672
5673 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm192, &(*this), _1));
5674 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5675 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5676 }
5677 sigma_box += average;
5678
5679 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange192, &(*this), _1));
5680 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5681 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5682 }
5683 sigma_box += average;
5684
5685 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom192, &(*this), _1));
5686 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5687 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5688 }
5689 sigma_box += average;
5690 SMresult_cache += sigma_box;
5691 }
5692 } else if (s == 196.*196.) {
5693 if (!flagLEP2[ISR]){
5699 } else {
5700
5701 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up196, &(*this), _1));
5702 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5703 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5704 }
5706
5707 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down196, &(*this), _1));
5708 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5709 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5710 }
5712
5713 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm196, &(*this), _1));
5714 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5715 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5716 }
5718
5719 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange196, &(*this), _1));
5720
5721 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5722 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5723 }
5725
5726 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom196, &(*this), _1));
5727 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5728 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5729 }
5731 }
5732
5733 if (flagLEP2[WeakBox]) {
5734 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up196, &(*this), _1));
5735 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5736 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5737 }
5738 double sigma_box = average;
5739
5740 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down196, &(*this), _1));
5741 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5742 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5743 }
5744 sigma_box += average;
5745
5746 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm196, &(*this), _1));
5747 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5748 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5749 }
5750 sigma_box += average;
5751
5752 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange196, &(*this), _1));
5753 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5754 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5755 }
5756 sigma_box += average;
5757
5758 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom196, &(*this), _1));
5759 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5760 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5761 }
5762 sigma_box += average;
5763 SMresult_cache += sigma_box;
5764 }
5765 } else if (s == 200.*200.) {
5766 if (!flagLEP2[ISR]){
5772 } else {
5773
5774 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up200, &(*this), _1));
5775 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5776 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5777 }
5779
5780 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down200, &(*this), _1));
5781 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5782 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5783 }
5785
5786 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm200, &(*this), _1));
5787 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5788 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5789 }
5791
5792 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange200, &(*this), _1));
5793 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5794 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5795 }
5797
5798 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom200, &(*this), _1));
5799 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5800 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5801 }
5803 }
5804
5805 if (flagLEP2[WeakBox]) {
5806 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up200, &(*this), _1));
5807 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5808 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5809 }
5810 double sigma_box = average;
5811
5812 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down200, &(*this), _1));
5813 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5814 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5815 }
5816 sigma_box += average;
5817
5818 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm200, &(*this), _1));
5819 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5820 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5821 }
5822 sigma_box += average;
5823
5824 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange200, &(*this), _1));
5825 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5826 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5827 }
5828 sigma_box += average;
5829
5830 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom200, &(*this), _1));
5831 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5832 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5833 }
5834 sigma_box += average;
5835 SMresult_cache += sigma_box;
5836 }
5837 } else if (s == 202.*202.) {
5838 if (!flagLEP2[ISR]){
5844 } else {
5845
5846 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up202, &(*this), _1));
5847
5848
5849
5850 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5851 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5852 }
5854
5855 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down202, &(*this), _1));
5856
5857
5858
5859 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5860 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5861 }
5863
5864 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm202, &(*this), _1));
5865
5866
5867
5868 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5869 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5870 }
5872
5873 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange202, &(*this), _1));
5874
5875
5876
5877 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5878 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5879 }
5881
5882 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom202, &(*this), _1));
5883
5884
5885
5886 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5887 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5888 }
5890 }
5891
5892 if (flagLEP2[WeakBox]) {
5893 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up202, &(*this), _1));
5894
5895
5896
5897 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5898 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5899 }
5900 double sigma_box = average;
5901
5902 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down202, &(*this), _1));
5903
5904
5905
5906 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5907 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5908 }
5909 sigma_box += average;
5910
5911 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm202, &(*this), _1));
5912
5913
5914
5915 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5916 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5917 }
5918 sigma_box += average;
5919
5920 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange202, &(*this), _1));
5921
5922
5923
5924 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5925 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5926 }
5927 sigma_box += average;
5928
5929 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom202, &(*this), _1));
5930
5931
5932
5933 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5934 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5935 }
5936 sigma_box += average;
5937 SMresult_cache += sigma_box;
5938 }
5939 } else if (s == 205.*205.) {
5940 if (!flagLEP2[ISR]){
5946 } else {
5947
5948 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up205, &(*this), _1));
5949
5950
5951
5952 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5953 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5954 }
5956
5957 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down205, &(*this), _1));
5958
5959
5960
5961 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5962 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5963 }
5965
5966 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm205, &(*this), _1));
5967
5968
5969
5970 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5971 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5972 }
5974
5975 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange205, &(*this), _1));
5976
5977
5978
5979 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5980 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5981 }
5983
5984 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom205, &(*this), _1));
5985
5986
5987
5988 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
5989 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
5990 }
5992 }
5993
5994 if (flagLEP2[WeakBox]) {
5995 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up205, &(*this), _1));
5996
5997
5998
5999 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6000 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6001 }
6002 double sigma_box = average;
6003
6004 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down205, &(*this), _1));
6005
6006
6007
6008 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6009 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6010 }
6011 sigma_box += average;
6012
6013 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm205, &(*this), _1));
6014
6015
6016
6017 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6018 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6019 }
6020 sigma_box += average;
6021
6022 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange205, &(*this), _1));
6023
6024
6025
6026 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6027 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6028 }
6029 sigma_box += average;
6030
6031 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom205, &(*this), _1));
6032
6033
6034
6035 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6036 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6037 }
6038 sigma_box += average;
6039 SMresult_cache += sigma_box;
6040 }
6041 } else if (s == 207.*207.) {
6042 if (!flagLEP2[ISR]){
6048 } else {
6049
6050 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_up207, &(*this), _1));
6051
6052
6053
6054 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6055 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6056 }
6058
6059 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_down207, &(*this), _1));
6060
6061
6062
6063 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6064 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6065 }
6067
6068 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_charm207, &(*this), _1));
6069
6070
6071
6072 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6073 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6074 }
6076
6077 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_strange207, &(*this), _1));
6078
6079
6080
6081 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6082 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6083 }
6085
6086 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_bottom207, &(*this), _1));
6087
6088
6089
6090 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6091 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6092 }
6094 }
6095
6096 if (flagLEP2[WeakBox]) {
6097 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_up207, &(*this), _1));
6098
6099
6100
6101 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6102 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6103 }
6104 double sigma_box = average;
6105
6106 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_down207, &(*this), _1));
6107
6108
6109
6110 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6111 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6112 }
6113 sigma_box += average;
6114
6115 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_charm207, &(*this), _1));
6116
6117
6118
6119 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6120 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6121 }
6122 sigma_box += average;
6123
6124 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_strange207, &(*this), _1));
6125
6126
6127
6128 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6129 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6130 }
6131 sigma_box += average;
6132
6133 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_bottom207, &(*this), _1));
6134
6135
6136
6137 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
6138 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
6139 }
6140 sigma_box += average;
6141 SMresult_cache += sigma_box;
6142 }
6143 } else {
6144 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaHadron!");
6145 }
6146
6147 double sigma_had = SMresult_cache;
6148
6149 gsl_set_error_handler(old_handler);
6150
6151 return sigma_had;
6152
6153 }
6154}
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 NPbase, and NPSTUVWXY.

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

4089{
4090 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4091 double relerr = 1.e-8;
4092 double abserr = 1.e-20;
4093
4094 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4096
4097 /* SM contribution with the approximate formula */
4099
4100 } else {
4101
4102 if(s == 130.*130.){
4103
4104 if (!flagLEP2[ISR]){
4106 } else {
4107 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu130, &(*this), _1));
4108 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4109 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4110 }
4112 }
4113
4114 if (flagLEP2[WeakBox]) {
4115 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu130, &(*this), _1));
4116 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4117 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4118 }
4119 double sigma_box = average;
4120 SMresult_cache += sigma_box;
4121 }
4122 } else if (s == 136.*136.) {
4123 if (!flagLEP2[ISR]){
4125 } else {
4126 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu136, &(*this), _1));
4127 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4128 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4129 }
4131 }
4132
4133 if (flagLEP2[WeakBox]) {
4134 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu136, &(*this), _1));
4135 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4136 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4137 }
4138 double sigma_box = average;
4139 SMresult_cache += sigma_box;
4140 }
4141 } else if (s == 161.*161.){
4142 if (!flagLEP2[ISR])
4144 else {
4145 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu161, &(*this), _1));
4146 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4147 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4148 }
4150 }
4151
4152 if (flagLEP2[WeakBox]) {
4153 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu161, &(*this), _1));
4154 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4155 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4156 }
4157 double sigma_box = average;
4158 SMresult_cache += sigma_box;
4159 }
4160 } else if (s == 172.*172.) {
4161 if (!flagLEP2[ISR])
4163 else {
4164 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu172, &(*this), _1));
4165 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4166 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4167 }
4169 }
4170
4171 if (flagLEP2[WeakBox]) {
4172 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu172, &(*this), _1));
4173 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4174 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4175 }
4176 double sigma_box = average;
4177 SMresult_cache += sigma_box;
4178 }
4179 } else if (s == 183.*183.) {
4180 if (!flagLEP2[ISR])
4182 else {
4183 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu183, &(*this), _1));
4184 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4185 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4186 }
4188 }
4189
4190 if (flagLEP2[WeakBox]) {
4191 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu183, &(*this), _1));
4192 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4193 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4194 }
4195 double sigma_box = average;
4196 SMresult_cache += sigma_box;
4197 }
4198 } else if (s == 189.*189.) {
4199 if (!flagLEP2[ISR])
4201 else {
4202 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu189, &(*this), _1));
4203 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4204 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4205 }
4207 }
4208
4209 if (flagLEP2[WeakBox]) {
4210 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu189, &(*this), _1));
4211 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4212 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4213 }
4214 double sigma_box = average;
4215 SMresult_cache += sigma_box;
4216 }
4217 } else if (s == 192.*192.) {
4218 if (!flagLEP2[ISR])
4220 else {
4221 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu192, &(*this), _1));
4222 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4223 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4224 }
4226 }
4227
4228 if (flagLEP2[WeakBox]) {
4229 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu192, &(*this), _1));
4230 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4231 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4232 }
4233 double sigma_box = average;
4234 SMresult_cache += sigma_box;
4235 }
4236 } else if (s == 196.*196.) {
4237 if (!flagLEP2[ISR])
4239 else {
4240 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu196, &(*this), _1));
4241 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4242 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4243 }
4245 }
4246
4247 if (flagLEP2[WeakBox]) {
4248 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu196, &(*this), _1));
4249 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4250 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4251 }
4252 double sigma_box = average;
4253 SMresult_cache += sigma_box;
4254 }
4255 } else if (s == 200.*200.) {
4256 if (!flagLEP2[ISR])
4258 else {
4259 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu200, &(*this), _1));
4260 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4261 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4262 }
4264 }
4265
4266 if (flagLEP2[WeakBox]) {
4267 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu200, &(*this), _1));
4268 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4269 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4270 }
4271 double sigma_box = average;
4272 SMresult_cache += sigma_box;
4273 }
4274 } else if (s == 202.*202.) {
4275 if (!flagLEP2[ISR])
4277 else {
4278 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu202, &(*this), _1));
4279 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4280 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4281 }
4283 }
4284
4285 if (flagLEP2[WeakBox]) {
4286 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu202, &(*this), _1));
4287 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4288 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4289 }
4290 double sigma_box = average;
4291 SMresult_cache += sigma_box;
4292 }
4293 } else if (s == 205.*205.) {
4294 if (!flagLEP2[ISR])
4296 else {
4297 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu205, &(*this), _1));
4298 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4299 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4300 }
4302 }
4303
4304 if (flagLEP2[WeakBox]) {
4305 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu205, &(*this), _1));
4306 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4307 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4308 }
4309 double sigma_box = average;
4310 SMresult_cache += sigma_box;
4311 }
4312 } else if (s == 207.*207.) {
4313 if (!flagLEP2[ISR])
4315 else {
4316 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_mu207, &(*this), _1));
4317 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4318 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4319 }
4321 }
4322
4323 if (flagLEP2[WeakBox]) {
4324 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_mu207, &(*this), _1));
4325 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4326 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4327 }
4328 double sigma_box = average;
4329 SMresult_cache += sigma_box;
4330 }
4331 } else {
4332 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2AFBmu!");
4333 }
4334
4335 double sigma_mu = SMresult_cache;
4336
4337 gsl_set_error_handler(old_handler);
4338
4339 return sigma_mu;
4340
4341 }
4342}
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 NPbase, and NPSTUVWXY.

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

4346{
4347
4348 gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
4349 double relerr = 1.e-7;
4350 double abserr = 1.e-17;
4351
4352 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
4354
4355 /* SM contribution with the approximate formula */
4357
4358 } else {
4359
4360 if(s == 130.*130.){
4361
4362 if (!flagLEP2[ISR]){
4364 } else {
4365 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau130, &(*this), _1));
4366 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4367 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4368 }
4370 }
4371
4372 if (flagLEP2[WeakBox]) {
4373 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau130, &(*this), _1));
4374 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4375 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4376 }
4377 double sigma_box = average;
4378 SMresult_cache += sigma_box;
4379 }
4380 } else if (s == 136.*136.) {
4381 if (!flagLEP2[ISR]){
4383 } else {
4384 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau136, &(*this), _1));
4385 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4386 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4387 }
4389 }
4390
4391 if (flagLEP2[WeakBox]) {
4392 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau136, &(*this), _1));
4393 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4394 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4395 }
4396 double sigma_box = average;
4397 SMresult_cache += sigma_box;
4398 }
4399 } else if (s == 161.*161.){
4400 if (!flagLEP2[ISR])
4402 else {
4403 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau161, &(*this), _1));
4404 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4405 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4406 }
4408 }
4409
4410 if (flagLEP2[WeakBox]) {
4411 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau161, &(*this), _1));
4412 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4413 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4414 }
4415 double sigma_box = average;
4416 SMresult_cache += sigma_box;
4417 }
4418 } else if (s == 172.*172.) {
4419 if (!flagLEP2[ISR])
4421 else {
4422 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau172, &(*this), _1));
4423 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4424 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4425 }
4427 }
4428
4429 if (flagLEP2[WeakBox]) {
4430 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau172, &(*this), _1));
4431 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4432 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4433 }
4434 double sigma_box = average;
4435 SMresult_cache += sigma_box;
4436 }
4437 } else if (s == 183.*183.) {
4438 if (!flagLEP2[ISR])
4440 else {
4441 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau183, &(*this), _1));
4442 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4443 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4444 }
4446 }
4447
4448 if (flagLEP2[WeakBox]) {
4449 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau183, &(*this), _1));
4450 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4451 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4452 }
4453 double sigma_box = average;
4454 SMresult_cache += sigma_box;
4455 }
4456 } else if (s == 189.*189.) {
4457 if (!flagLEP2[ISR])
4459 else {
4460 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau189, &(*this), _1));
4461 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4462 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4463 }
4465 }
4466
4467 if (flagLEP2[WeakBox]) {
4468 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau189, &(*this), _1));
4469 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4470 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4471 }
4472 double sigma_box = average;
4473 SMresult_cache += sigma_box;
4474 }
4475 } else if (s == 192.*192.) {
4476 if (!flagLEP2[ISR])
4478 else {
4479 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau192, &(*this), _1));
4480 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4481 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4482 }
4484 }
4485
4486 if (flagLEP2[WeakBox]) {
4487 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau192, &(*this), _1));
4488 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4489 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4490 }
4491 double sigma_box = average;
4492 SMresult_cache += sigma_box;
4493 }
4494 } else if (s == 196.*196.) {
4495 if (!flagLEP2[ISR])
4497 else {
4498 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau196, &(*this), _1));
4499 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4500 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4501 }
4503 }
4504
4505 if (flagLEP2[WeakBox]) {
4506 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau196, &(*this), _1));
4507 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4508 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4509 }
4510 double sigma_box = average;
4511 SMresult_cache += sigma_box;
4512 }
4513 } else if (s == 200.*200.) {
4514 if (!flagLEP2[ISR])
4516 else {
4517 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau200, &(*this), _1));
4518 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4519 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4520 }
4522 }
4523
4524 if (flagLEP2[WeakBox]) {
4525 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau200, &(*this), _1));
4526 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4527 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4528 }
4529 double sigma_box = average;
4530 SMresult_cache += sigma_box;
4531 }
4532 } else if (s == 202.*202.) {
4533 if (!flagLEP2[ISR])
4535 else {
4536 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau202, &(*this), _1));
4537 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4538 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4539 }
4541 }
4542
4543 if (flagLEP2[WeakBox]) {
4544 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau202, &(*this), _1));
4545 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4546 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4547 }
4548 double sigma_box = average;
4549 SMresult_cache += sigma_box;
4550 }
4551 } else if (s == 205.*205.) {
4552 if (!flagLEP2[ISR])
4554 else {
4555 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau205, &(*this), _1));
4556 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4557 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4558 }
4560 }
4561
4562 if (flagLEP2[WeakBox]) {
4563 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau205, &(*this), _1));
4564 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4565 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4566 }
4567 double sigma_box = average;
4568 SMresult_cache += sigma_box;
4569 }
4570 } else if (s == 207.*207.) {
4571 if (!flagLEP2[ISR])
4573 else {
4574 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_sigmaWithISR_tau207, &(*this), _1));
4575 if (gsl_integration_qags(&f_GSL, 0., 1.-0.85*0.85, abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4576 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4577 }
4579 }
4580
4581 if (flagLEP2[WeakBox]) {
4582 f_GSL = convertToGslFunction(bind(&StandardModel::getIntegrand_dsigmaBox_tau207, &(*this), _1));
4583 if (gsl_integration_qags(&f_GSL, -1., 1., abserr, relerr, 100, w_GSL1, &average, &error) != 0){
4584 SMresult_cache = std::numeric_limits<double>::quiet_NaN();
4585 }
4586 double sigma_box = average;
4587 SMresult_cache += sigma_box;
4588 }
4589 } else {
4590 throw std::runtime_error("ERROR: wrong LEP2 energy in StandardModel::LEP2sigmaTau!");
4591 }
4592
4593 double sigma_tau = SMresult_cache;
4594
4595 gsl_set_error_handler(old_handler);
4596
4597 return sigma_tau;
4598
4599 }
4600}
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 3531 of file StandardModel.h.

3532 {
3533 switch(q) {
3534 case QCD::UP:
3535 case QCD::DOWN:
3536 case QCD::STRANGE:
3537 return Mrun(mu, getQuarks(q).getMass_scale(),
3538 getQuarks(q).getMass(), q, order);
3539 case QCD::CHARM:
3540 case QCD::BOTTOM:
3541 case QCD::TOP:
3542 return Mrun(mu, getQuarks(q).getMass(), q, order);
3543 default:
3544 throw std::runtime_error("Error in StandardModel::m_q()");
3545 }
3546 }

◆ MLL2eeff()

const double StandardModel::MLL2eeff ( const Particle  f,
const double  s,
const double  t 
) const

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

3806 {
3807
3808 // Definitions
3809 double Qf, geLSM, gfLSM, is2c2, GZ, Mz2s;
3810
3811 double MLL2SM;
3812
3813 // -------------------------------------------
3814
3815 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3816
3817 is2c2 = 1. / s02() / c02();
3818
3819 GZ = Gamma_Z();
3820
3821 Mz2s = Mz * Mz - s;
3822
3823 if (f.is("ELECTRON")) {
3824 Qf = leptons[ELECTRON].getCharge();
3825 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3826 } else if (f.is("MU")) {
3827 Qf = leptons[MU].getCharge();
3828 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3829 } else if (f.is("TAU")) {
3830 Qf = leptons[TAU].getCharge();
3831 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3832 } else if (f.is("UP")) {
3833 Qf = quarks[UP].getCharge();
3834 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3835 } else if (f.is("CHARM")) {
3836 Qf = quarks[CHARM].getCharge();
3837 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3838 } else if (f.is("DOWN")) {
3839 Qf = quarks[DOWN].getCharge();
3840 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3841 } else if (f.is("STRANGE")) {
3842 Qf = quarks[STRANGE].getCharge();
3843 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3844 } else if (f.is("BOTTOM")) {
3845 Qf = quarks[BOTTOM].getCharge();
3846 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3847 } else
3848 throw std::runtime_error("StandardModel::MLL2eeff: wrong argument");
3849
3850 // LL SM squared amplitude
3851 MLL2SM = Qf * Qf
3852 + (is2c2 * is2c2 * (geLSM * geLSM * gfLSM * gfLSM) * s * s
3853 + 2.0 * Qf * is2c2 * (geLSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3854
3855 return MLL2SM;
3856
3857}

◆ MLR2eeff()

const double StandardModel::MLR2eeff ( const Particle  f,
const double  s 
) const

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

3703 {
3704
3705 // Definitions
3706 double Qf, geLSM, gfRSM, is2c2, GZ, Mz2s;
3707
3708 double MLR2SM;
3709
3710 // -------------------------------------------
3711
3712 geLSM = (leptons[ELECTRON].getIsospin()) - (leptons[ELECTRON].getCharge()) * s02();
3713
3714 is2c2 = 1. / s02() / c02();
3715
3716 GZ = Gamma_Z();
3717
3718 Mz2s = Mz * Mz - s;
3719
3720 if (f.is("ELECTRON")) {
3721 Qf = leptons[ELECTRON].getCharge();
3722 gfRSM = - Qf * s02();
3723 } else if (f.is("MU")) {
3724 Qf = leptons[MU].getCharge();
3725 gfRSM = - Qf * s02();
3726 } else if (f.is("TAU")) {
3727 Qf = leptons[TAU].getCharge();
3728 gfRSM = - Qf * s02();
3729 } else if (f.is("UP")) {
3730 Qf = quarks[UP].getCharge();
3731 gfRSM = - Qf * s02();
3732 } else if (f.is("CHARM")) {
3733 Qf = quarks[CHARM].getCharge();
3734 gfRSM = - Qf * s02();
3735 } else if (f.is("DOWN")) {
3736 Qf = quarks[DOWN].getCharge();
3737 gfRSM = - Qf * s02();
3738 } else if (f.is("STRANGE")) {
3739 Qf = quarks[STRANGE].getCharge();
3740 gfRSM = - Qf * s02();
3741 } else if (f.is("BOTTOM")) {
3742 Qf = quarks[BOTTOM].getCharge();
3743 gfRSM = - Qf * s02();
3744 } else
3745 throw std::runtime_error("StandardModel::MLR2eeff: wrong argument");
3746
3747 // LR, RL, LL and RR SM squared amplitudes
3748 MLR2SM = Qf * Qf
3749 + (is2c2 * is2c2 * (geLSM * geLSM * gfRSM * gfRSM) * s * s
3750 + 2.0 * Qf * is2c2 * (geLSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3751
3752 return MLR2SM;
3753}

◆ MRL2eeff()

const double StandardModel::MRL2eeff ( const Particle  f,
const double  s 
) const

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

3754 {
3755
3756 // Definitions
3757 double Qf, geRSM, gfLSM, is2c2, GZ, Mz2s;
3758
3759 double MRL2SM;
3760
3761 // -------------------------------------------
3762
3763 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3764
3765 is2c2 = 1. / s02() / c02();
3766
3767 GZ = Gamma_Z();
3768
3769 Mz2s = Mz * Mz - s;
3770
3771 if (f.is("ELECTRON")) {
3772 Qf = leptons[ELECTRON].getCharge();
3773 gfLSM = (leptons[ELECTRON].getIsospin()) - Qf * s02();
3774 } else if (f.is("MU")) {
3775 Qf = leptons[MU].getCharge();
3776 gfLSM = (leptons[MU].getIsospin()) - Qf * s02();
3777 } else if (f.is("TAU")) {
3778 Qf = leptons[TAU].getCharge();
3779 gfLSM = (leptons[TAU].getIsospin()) - Qf * s02();
3780 } else if (f.is("UP")) {
3781 Qf = quarks[UP].getCharge();
3782 gfLSM = (quarks[UP].getIsospin()) - Qf * s02();
3783 } else if (f.is("CHARM")) {
3784 Qf = quarks[CHARM].getCharge();
3785 gfLSM = (quarks[CHARM].getIsospin()) - Qf * s02();
3786 } else if (f.is("DOWN")) {
3787 Qf = quarks[DOWN].getCharge();
3788 gfLSM = (quarks[DOWN].getIsospin()) - Qf * s02();
3789 } else if (f.is("STRANGE")) {
3790 Qf = quarks[STRANGE].getCharge();
3791 gfLSM = (quarks[STRANGE].getIsospin()) - Qf * s02();
3792 } else if (f.is("BOTTOM")) {
3793 Qf = quarks[BOTTOM].getCharge();
3794 gfLSM = (quarks[BOTTOM].getIsospin()) - Qf * s02();
3795 } else
3796 throw std::runtime_error("StandardModel::MRL2eeff: wrong argument");
3797
3798 // RL SM squared amplitude
3799 MRL2SM = Qf * Qf
3800 + (is2c2 * is2c2 * (geRSM * geRSM * gfLSM * gfLSM) * s * s
3801 + 2.0 * Qf * is2c2 * (geRSM * gfLSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3802
3803 return MRL2SM;
3804}

◆ MRR2eeff()

const double StandardModel::MRR2eeff ( const Particle  f,
const double  s,
const double  t 
) const

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

3858 {
3859
3860 // Definitions
3861 double Qf, geRSM, gfRSM, is2c2, GZ, Mz2s;
3862
3863 double MRR2SM;
3864
3865 // -------------------------------------------
3866
3867 geRSM = - (leptons[ELECTRON].getCharge()) * s02();
3868
3869 is2c2 = 1. / s02() / c02();
3870
3871 GZ = Gamma_Z();
3872
3873 Mz2s = Mz * Mz - s;
3874
3875 if (f.is("ELECTRON")) {
3876 Qf = leptons[ELECTRON].getCharge();
3877 gfRSM = - Qf * s02();
3878 } else if (f.is("MU")) {
3879 Qf = leptons[MU].getCharge();
3880 gfRSM = - Qf * s02();
3881 } else if (f.is("TAU")) {
3882 Qf = leptons[TAU].getCharge();
3883 gfRSM = - Qf * s02();
3884 } else if (f.is("UP")) {
3885 Qf = quarks[UP].getCharge();
3886 gfRSM = - Qf * s02();
3887 } else if (f.is("CHARM")) {
3888 Qf = quarks[CHARM].getCharge();
3889 gfRSM = - Qf * s02();
3890 } else if (f.is("DOWN")) {
3891 Qf = quarks[DOWN].getCharge();
3892 gfRSM = - Qf * s02();
3893 } else if (f.is("STRANGE")) {
3894 Qf = quarks[STRANGE].getCharge();
3895 gfRSM = - Qf * s02();
3896 } else if (f.is("BOTTOM")) {
3897 Qf = quarks[BOTTOM].getCharge();
3898 gfRSM = - Qf * s02();
3899 } else
3900 throw std::runtime_error("StandardModel::MRR2eeff: wrong argument");
3901
3902 // RR SM squared amplitude
3903 MRR2SM = Qf * Qf
3904 + (is2c2 * is2c2 * (geRSM * geRSM * gfRSM * gfRSM) * s * s
3905 + 2.0 * Qf * is2c2 * (geRSM * gfRSM) * Mz2s * s) / (Mz2s * Mz2s + Mz * Mz * GZ * GZ);
3906
3907 return MRR2SM;
3908}

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

1020{
1021 /* Debug */
1022 //std::cout << std::boolalpha
1023 // << checkScheme(schemeMw_cache,schemeMw,false)
1024 // << " [cache:" << schemeMw_cache
1025 // << " current:" << schemeMw << "]" << std::endl;
1026
1027 if (FlagMWinput)
1028 return Mw_inp;
1029
1031 if (useMw_cache)
1032 return Mw_cache;
1033
1034 double Mw;
1035 if (FlagMw.compare("APPROXIMATEFORMULA") == 0)
1037 else {
1038 //std::cout << std::setprecision(12)
1039 // << "TEST: Mw_tree = " << Mw_tree() << std::endl;
1040
1041 double DeltaRho[orders_EW_size], DeltaR_rem[orders_EW_size];
1042 ComputeDeltaRho(Mw_tree(), DeltaRho);
1043 ComputeDeltaR_rem(Mw_tree(), DeltaR_rem);
1044 Mw = resumMw(Mw_tree(), DeltaRho, DeltaR_rem);
1045
1046 /* Mw from iterations */
1047 double Mw_org = Mw_tree();
1048 while (fabs(Mw - Mw_org) > Mw_error) {
1049 Mw_org = Mw;
1050 ComputeDeltaRho(Mw, DeltaRho);
1051 ComputeDeltaR_rem(Mw, DeltaR_rem);
1052 Mw = resumMw(Mw, DeltaRho, DeltaR_rem);
1053 /* TEST */
1054 //int prec_def = std::cout.precision();
1055 //std::cout << std::setprecision(12) << "TEST: Mw_org = " << Mw_org
1056 // << " Mw_new = " << Mw << std::endl;
1057 //std::cout.precision(prec_def);
1058 }
1059 }
1060
1061// Mw = 80.426; // FOR HEFFDF1 TEST: VALUE IN hep-ph/0512066
1062// Mw = 80.379; // FOR HEFFDF1 TEST: VALUE IN 2007.04191
1063 Mw_cache = Mw;
1064 useMw_cache = true;
1065 return Mw;
1066}
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 997 of file StandardModel/src/StandardModel.cpp.

998{
999 if (FlagMWinput){
1000 return Mw_inp;
1001 } else
1002 return ( Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz)));
1003}

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

1205{
1206 double AlsMw = Als(Mw, FULLNLO);
1207 double Gw_SM = 3.0 * GF * pow(Mw, 3.0) / 2.0 / sqrt(2.0) / M_PI
1208 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1209
1210 return ( Mw - Gw_SM * Gw_SM / 2.0 / Mw);
1211}

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

1214{
1215 double AlsMw = Als(Mwbar, FULLNNLO);
1216 double Gw_SM = 3.0 * GF * pow(Mwbar, 3.0) / 2.0 / sqrt(2.0) / M_PI
1217 * (1.0 + 2.0 * AlsMw / 3.0 / M_PI);
1218
1219 return (Mwbar + Gw_SM * Gw_SM / 2.0 / Mwbar);
1220}

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

1188{
1189 double G0 = GF * pow(Mz, 3.0) / 24.0 / sqrt(2.0) / M_PI;
1190 double sW2tree = 1.0 - Mw_tree() * Mw_tree() / Mz / Mz;
1191 double Gz = 6.0 * G0; // neutrinos
1192 Gz += 3.0 * G0 * (pow(1.0 - 4.0 * sW2tree, 2.0) + 1.0); // e, mu and tau
1193 Gz += 6.0 * G0 * (pow(1.0 - 8.0 / 3.0 * sW2tree, 2.0) + 1.0)
1194 * (1.0 + AlsMz / M_PI); // u and c
1195 Gz += 9.0 * G0 * (pow(1.0 - 4.0 / 3.0 * sW2tree, 2.0) + 1.0)
1196 * (1.0 + AlsMz / M_PI); // d, s and b
1197
1198 //Gz = 2.4952; // experimental data
1199 //std::cout << "Gz=" << Gz << std::endl; // for test
1200
1201 return ( Mz - Gz * Gz / 2.0 / Mz);
1202}

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

1557{
1558 double Nnu = 0.0;
1559 double Gl = 0.0;
1560 double Rl = 0.0;
1561
1562 // Don't assume lepton universality: average over lepton flavours
1564 Rl = (1.0/3.0) * ( R0_f(leptons[ELECTRON]) + R0_f(leptons[MU]) + R0_f(leptons[TAU]) );
1565
1566 Nnu = sqrt( 12.0 * M_PI * Rl / Mz / Mz / sigma0_had() ) - Rl -3.0;
1567
1568 Nnu = (Gl/Gamma_inv()) * Nnu;
1569
1570 return Nnu;
1571
1572}
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, NPSMEFTd6U2, NPSMEFTd6U2qU1le, NPSMEFTd6U3, NPZbbbar, NPZbbbarLinearized, pMSSM, SUSY, SUSYMassInsertion, THDM, and THDMW.

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

242{
243 if (!QCD::PostUpdate()) return (false);
244
245 SMSuccess = true;
246 /* Set the CKM and PMNS matrices if not already set in the derived classes */
247 if(requireCKM)
248 computeCKM();
249
250 /* Compute the 5-quark contribution to the running of alpha*/
251 dAl5hMz = Dalpha5hMz();
252
253 /* Set the Yukawa matrices */
254 if (!isModelSUSY()) {
256 }
257
258 /* Check whether the parameters for the EWPO are updated or not */
259 if (!checkSMparamsForEWPO()) {
261 useDeltaAlpha_cache = false;
262 useMw_cache = false;
263 useGammaW_cache = false;
264 for (int i = 0; i < 12; ++i) {
265 useRhoZ_f_cache[i] = false;
266 useKappaZ_f_cache[i] = false;
267 }
268 }
270 /* Necessary for updating StandardModel parameters in StandardModelMatching */
271 if (!isModelSUSY()) SMM.getObj().updateSMParameters();
272
273 iterationNo++;
274
275 return (true);
276}
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:373
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 214 of file StandardModel/src/StandardModel.cpp.

215{
216 requireCKM = false;
217 requireYe = false;
218 requireYn = false;
219
220 if (!QCD::PreUpdate()) return (false);
221
222 return (true);
223}
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)\)

Reimplemented in NPbase.

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

2666{
2667 // Weak charge
2668 double Qwe;
2669
2670 // definitions
2671 double MwSM,f1,fy,f2,af2;
2672 const double mpion=134.9766e-3;
2673
2674 // -----------------------------------------------------------------
2675
2676 double dalfos, dalfms, alfams;
2677 double rhoNC, kappa0, s2MSbar,c2MSbar;
2678 double xi;
2679 double leptk0,quarkk0;
2680 double elm=leptons[ELECTRON].getMass(), mum=leptons[MU].getMass(), taum=leptons[TAU].getMass();
2681
2682 // -----------------------------------------------------------------
2683
2684 // w mass
2685 MwSM=Mw();
2686
2687 // xi factor
2688 xi=mHl*mHl/Mz/Mz;
2689
2690 // -----------------------------------------------------------------
2691
2692 // universal corrections
2693 // ---------------------
2694
2695 // obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2696 // -----------------------------------------------
2697
2698 // on-shell value of delta alpha(mz)
2699 dalfos=1.0-ale/alphaMz();
2700 // msbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2701 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2702 // msbar value of alfa(mz)
2703 alfams=ale/(1.0-dalfms);
2704
2705 // ms bar weinberg's angle from the effective leptonic angle
2706 // (formula from PDG, Erler & Langacker ew review)
2707 // ---------------------------------------------------------
2708 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2709 c2MSbar=1.0-s2MSbar;
2710
2711 // rho parameter (expansion in alfams)
2712 // -------------
2713
2714 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)));
2715
2716 // kappa at zero momentum (expansion in alfa)
2717 // ----------------------
2718
2719 // lepton contribution to kappa0
2720 leptk0=((-0.5)*(-1)-2.0*s2MSbar)*2.0*(log(elm/Mz)+log(mum/Mz)+log(taum/Mz))/3.0;
2721
2722 // quark contribution to kappa0 (updated from hep-ph/0302149)
2723 quarkk0=-6.802;
2724
2725 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));
2726
2727 // -----------------------------------------------------------------
2728
2729 // f1(y,q2) (expansion in alfa)
2730 // --------
2731
2732 // f(y)
2733 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)));
2734
2735 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);
2736
2737 // note that i have used 1-4*kappa*s2MSbar instead of 1-4*s2MSbar or an average as suggested in the
2738 // reference
2739
2740
2741 // f2(y,q2) (expansion in alfa)
2742 // --------
2743 // (y=1/2 approximattion using a pion loop calculation)
2744
2745 // af2
2746 af2=sqrt(1.0+4.0*mpion*mpion/q2);
2747 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);
2748
2749
2750 // electron's weak charge
2751 // ----------------------
2752 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));
2753
2754 // again, i have used 1-4*kappa*s2MSbar even in the loop contributions
2755
2756 return Qwe;
2757}
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)\)

Reimplemented in NPbase.

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

2890{
2891 // Definitions
2892 double qwneutron;
2893
2894 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxnww,boxnzz,boxnaz;
2895 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2896 const double lambda=775.49e-3;
2897 const double caz=1.5;
2898
2899 // lepton masses
2900 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2901
2902 // -----------------------------------------------------------------
2903 double dalfos, dalfms, alfams;
2904 double rhoNC, s2MSbar,c2MSbar;
2905 double xi;
2906 double elm=leptons[ELECTRON].getMass();
2907 // -----------------------------------------------------------------
2908
2909 // W mass
2910 MwSM=Mw();
2911
2912 // xi factor
2913 xi=mHl*mHl/Mz/Mz;
2914
2915 // alfa/pi
2916 alfapi=ale/M_PI;
2917
2918 // alfa_s(Mw)
2919 asMw = Als(MwSM, FULLNLO);
2920
2921 // -----------------------------------------------------------------
2922
2923 // Universal corrections
2924 // ---------------------
2925
2926 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2927 // -----------------------------------------------
2928
2929 // on-shell value of delta alpha(mz)
2930 dalfos=1.0-ale/alphaMz();
2931 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2932 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2933 // MSbar value of alfa(mz)
2934 alfams=ale/(1.0-dalfms);
2935
2936 // MS bar weinberg's angle from the effective leptonic angle
2937 // (formula from PDG, Erler & Langacker ew review)
2938 // ---------------------------------------------------------
2939 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2940 c2MSbar=1.0-s2MSbar;
2941
2942 // rho parameter (expansion in alfams)
2943 // -------------
2944
2945 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)));
2946
2947 // -----------------------------------------------------------------
2948
2949 // sin2w_ms(0) eq.14
2950 // -----------------
2951
2952 // hadronic contribution
2953 dkappa5h=7.9e-3;
2954
2955 s2MSbar0=0.0;
2956
2957 for (int i = 0; i < 3; ++i) {
2958 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2959 }
2960
2961 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);
2962
2963 // -----------------------------------------------------------------
2964
2965 // external leg corrections
2966
2967 deltae=-0.5*alfapi;
2968
2969 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2970
2971 // -----------------------------------------------------------------
2972
2973 // boxes
2974 // -----
2975
2976 boxnww=alfams*(-2.0+4.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2977
2978 // pure zz and az boxes from prd 17 3055 app.a
2979
2980 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);
2981
2982 // i assumme the same caz as in the proton enters for the neutron
2983 boxnaz=alfams*(4.0-16.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2984
2985 // -----------------------------------------------------------------
2986
2987 // weak charges
2988 // ------------
2989
2990 qwneutron=-(rhoNC+deltae)*(1.0+deltaep)+boxnww+boxnzz+boxnaz;
2991
2992 return qwneutron;
2993
2994}
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)\)

Reimplemented in NPbase.

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

2782{
2783 // Definitions
2784 double qwproton;
2785
2786 double MwSM,alfapi,asMw,dkappa5h,s2MSbar0,deltae,deltaep,boxpww,boxpzz,boxpaz;
2787 // I choose as lambda m_rho (pdg rho(770)) --> caz=3/2
2788 const double lambda=775.49e-3;
2789 const double caz=1.5;
2790
2791 // lepton masses
2792 double mlept[3]={leptons[ELECTRON].getMass(),leptons[MU].getMass(),leptons[TAU].getMass()};
2793
2794 // -----------------------------------------------------------------
2795 double dalfos, dalfms, alfams;
2796 double rhoNC, s2MSbar,c2MSbar;
2797 double xi;
2798 double elm=leptons[ELECTRON].getMass();
2799 // -----------------------------------------------------------------
2800
2801 // W mass
2802 MwSM=Mw();
2803
2804 // xi factor
2805 xi=mHl*mHl/Mz/Mz;
2806
2807 // alfa/pi
2808 alfapi=ale/M_PI;
2809
2810 // alfa_s(Mw)
2811 asMw = Als(MwSM, FULLNLO);
2812
2813 // -----------------------------------------------------------------
2814
2815 // Universal corrections
2816 // ---------------------
2817
2818 // Obtaining alfa(mz)_msbar from alfa(mz)_on-shell
2819 // -----------------------------------------------
2820
2821 // on-shell value of delta alpha(mz)
2822 dalfos=1.0-ale/alphaMz();
2823 // MSbar value of delta alpha(mz) (formula from PDG, Erler & Langacker ew review)
2824 dalfms=dalfos+ale/M_PI*(100.0/27.0-1.0/6.0-7.0*2.0*log(Mz/MwSM)/4.0);
2825 // MSbar value of alfa(mz)
2826 alfams=ale/(1.0-dalfms);
2827
2828 // MS bar weinberg's angle from the effective leptonic angle
2829 // (formula from PDG, Erler & Langacker ew review)
2830 // ---------------------------------------------------------
2831 s2MSbar=(myApproximateFormulae->sin2thetaEff_l_full())-0.00029;
2832 c2MSbar=1.0-s2MSbar;
2833
2834 // rho parameter (expansion in alfams)
2835 // -------------
2836
2837 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)));
2838
2839 // -----------------------------------------------------------------
2840
2841 // sin2w_ms(0) eq.14
2842 // -----------------
2843
2844 // hadronic contribution
2845 dkappa5h=7.9e-3;
2846
2847 s2MSbar0=0.0;
2848
2849 for (int i = 0; i < 3; ++i) {
2850 s2MSbar0=s2MSbar0+2.0*log(Mz/mlept[i]);
2851 }
2852
2853 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);
2854
2855 // -----------------------------------------------------------------
2856
2857 // external leg corrections
2858
2859 deltae=-0.5*alfapi;
2860
2861 deltaep=-alfapi/3.0*(1.0-4.0*s2MSbar)*(2.0*log(Mz/elm)+1.0/6.0);
2862
2863 // -----------------------------------------------------------------
2864
2865 // boxes
2866 // -----
2867
2868 boxpww=alfams*(2.0+5.0*(1.0-asMw/M_PI))/(4.0*M_PI*s2MSbar);
2869
2870 // pure zz and az boxes from prd 17 3055 app.a
2871
2872 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);
2873
2874 boxpaz=5.0*alfams*(1.0-4.0*s2MSbar)*(2.0*log(Mz/lambda)+caz)/(2.0*M_PI);
2875
2876 // i assumme the same caz as in the proton enters for the neutron
2877 // -----------------------------------------------------------------
2878
2879 // weak charges
2880 // ------------
2881
2882 qwproton=(rhoNC+deltae)*(1.0-4.0*s2MSbar0+deltaep)+boxpww+boxpzz+boxpaz;
2883
2884 return qwproton;
2885
2886}

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

1480{
1481
1482 if (f.is("ELECTRON")) {
1484 /* SM contribution with the approximate formula */
1485 return (myApproximateFormulae->X_full("R0_electron"));
1486 else
1487 return (Gamma_had() / GammaZ(leptons[ELECTRON]));
1488 } else if (f.is("MU")) {
1490 /* SM contribution with the approximate formula */
1491 return (myApproximateFormulae->X_full("R0_muon"));
1492 else
1493 return (Gamma_had() / GammaZ(leptons[MU]));
1494 } else if (f.is("TAU")) {
1496 /* SM contribution with the approximate formula */
1497 return (myApproximateFormulae->X_full("R0_tau"));
1498 else
1499 return (Gamma_had() / GammaZ(leptons[TAU]));
1500 } else if (f.is("NEUTRINO_1")) {
1502 /* SM contribution with the approximate formula */
1503 return (myApproximateFormulae->X_full("R0_neutrino"));
1504 else
1505 return (GammaZ(leptons[NEUTRINO_1]) / Gamma_had());
1506 } else if (f.is("NEUTRINO_2")) {
1508 /* SM contribution with the approximate formula */
1509 return (myApproximateFormulae->X_full("R0_neutrino"));
1510 else
1511 return (GammaZ(leptons[NEUTRINO_2]) / Gamma_had());
1512 } else if (f.is("NEUTRINO_3")) {
1514 /* SM contribution with the approximate formula */
1515 return (myApproximateFormulae->X_full("R0_neutrino"));
1516 else
1517 return (GammaZ(leptons[NEUTRINO_3]) / Gamma_had());
1518 } else if (f.is("UP")) {
1520 /* SM contribution with the approximate formula */
1521 return (myApproximateFormulae->X_full("R0_up"));
1522 else
1523 return (GammaZ(quarks[UP]) / Gamma_had());
1524
1525 } else if (f.is("STRANGE")) {
1527 /* SM contribution with the approximate formula */
1528 return (myApproximateFormulae->X_full("R0_strange"));
1529 else
1530 return (GammaZ(quarks[STRANGE]) / Gamma_had());
1531
1532 } else if (f.is("CHARM")) {
1534 /* SM contribution with the approximate formula */
1535 return (myApproximateFormulae->X_full("R0_charm"));
1536 else
1537 return (GammaZ(quarks[CHARM]) / Gamma_had());
1538
1539 } else if (f.is("BOTTOM")) {
1541 /* SM contribution with the approximate formula */
1542 return (myApproximateFormulae->X_full("R0_bottom"));
1543 else
1544 return (GammaZ(quarks[BOTTOM]) / Gamma_had());
1545
1546 } else throw std::runtime_error("StandardModel::R0_f called with wrong argument");
1547
1548}

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

1551{
1552 return (Gamma_inv() / GammaZ(leptons[ELECTRON]));
1553
1554}

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

2272{
2273 if (q == QCD::TOP) return 0.0;
2274
2275 double mcMz, mbMz;
2278 //mcMz = 0.56381685; /* for debug */
2279 //mbMz = 2.8194352; /* for debug */
2280
2281 double MtPole = mtpole;
2282
2283 /* z-component of isospin */
2284 double I3q = quarks[q].getIsospin();
2285 /* electric charge squared */
2286 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2287
2288 /* s = Mz^2 */
2289 double s = Mz * Mz;
2290
2291 /* products of the charm and bottom masses at Mz */
2292 double mcMz2 = mcMz*mcMz;
2293 double mbMz2 = mbMz*mbMz;
2294 double mqMz2, mqdash4;
2295 switch (q) {
2296 case QCD::CHARM:
2297 mqMz2 = mcMz*mcMz;
2298 mqdash4 = mbMz2*mbMz2;
2299 break;
2300 case QCD::BOTTOM:
2301 mqMz2 = mbMz*mbMz;
2302 mqdash4 = mcMz2*mcMz2;
2303 break;
2304 default:
2305 mqMz2 = 0.0;
2306 mqdash4 = 0.0;
2307 break;
2308 }
2309
2310 /* Logarithms */
2311 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2312 double log_t = log(MtPole * MtPole / s); // the pole mass
2313 double log_c = log(mcMz2 / s);
2314 double log_b = log(mbMz2 / s);
2315 double log_q;
2316 switch (q) {
2317 case QCD::CHARM:
2318 case QCD::BOTTOM:
2319 log_q = log(mqMz2 / s);
2320 break;
2321 default:
2322 log_q = 0.0;
2323 break;
2324 }
2325
2326 /* the active number of flavour */
2327 double nf = 5.0;
2328
2329 /* zeta functions */
2330 double zeta2 = getMyEWSMcache()->getZeta2();
2331 double zeta3 = getMyEWSMcache()->getZeta3();
2332 double zeta4 = getMyEWSMcache()->getZeta4();
2333 double zeta5 = getMyEWSMcache()->getZeta5();
2334
2335 /* massless non-singlet corrections */
2336 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2337 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2338 + 275.0 / 6.0 * zeta5
2339 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2340 - 25.0 / 9.0 * zeta5) * nf
2341 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2342 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2343 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2344 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2345 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2346
2347 /* quadratic massive corrections */
2348 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2349 double C20A = -6.0;
2350 double C21A = -22.0;
2351 double C22A = -8221.0 / 24.0 + 57.0 * zeta2 + 117.0 * zeta3
2352 + (151.0 / 12.0 - 2.0 * zeta2 - 4.0 * zeta3) * nf;
2353 double C23A = -4544045.0 / 864.0 + 1340.0 * zeta2 + 118915.0 / 36.0 * zeta3
2354 - 127.0 * zeta5
2355 + (71621.0 / 162.0 - 209.0 / 2.0 * zeta2 - 216.0 * zeta3
2356 + 5.0 * zeta4 + 55.0 * zeta5) * nf
2357 + (-13171.0 / 1944.0 + 16.0 / 9.0 * zeta2 + 26.0 / 9.0 * zeta3) * nf*nf;
2358
2359 /* quartic massive corrections */
2360 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2361 double C40A = 6.0;
2362 double C41A = 10.0;
2363 double C42A = 3389.0 / 12.0 - 162.0 * zeta2 - 220.0 * zeta3
2364 + (-41.0 / 6.0 + 4.0 * zeta2 + 16.0 / 3.0 * zeta3) * nf;
2365 double C42AL = 77.0 / 2.0 - 7.0 / 3.0 * nf;
2366
2367 /* power suppressed top-mass correction */
2368 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2369 double xt = s / MtPole / MtPole; // the pole mass
2370 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2371
2372 /* singlet axial-vector corrections */
2373 double I2 = -37.0 / 12.0 + (-log_t) + 7.0 / 81.0 * xt + 0.0132 * xt*xt;
2374 double I3 = -5075.0 / 216.0 + 23.0 / 6.0 * zeta2 + zeta3 + 67.0 / 18.0 * (-log_t)
2375 + 23.0 / 12.0 * log_t*log_t;
2376 double I4 = 49.0309 - 17.6637 * (-log_t) + 14.6597 * log_t * log_t
2377 + 3.6736 * (-log_t * log_t * log_t);
2378
2379 /* rescaled strong coupling constant */
2380 double AlsMzPi = AlsMz / M_PI;
2381 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2382 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2383 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2384
2385 /* electromagnetic coupling at Mz */
2386 double alpMz = alphaMz();
2387
2388 /* radiator function to the axial-vector current */
2389 double RAf;
2390 RAf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2391 + (C02 + C2t - 2.0 * I3q * I2) * AlsMzPi2
2392 + (C03 - 2.0 * I3q * I3) * AlsMzPi3
2393 + (C04 - 2.0 * I3q * I4) * AlsMzPi4
2394 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2395 + mqMz2 / s * (C20A + C21A * AlsMzPi + C22A * AlsMzPi2
2396 + 6.0 * (3.0 + log_t) * AlsMzPi2 + C23A * AlsMzPi3)
2397 //- 10.0*mqMz2/pow(quarks[TOP].getMass(),2.0)
2398 - 10.0 * mqMz2 / MtPole / MtPole // the pole mass
2399 * (8.0 / 81.0 + log_t / 54.0) * AlsMzPi2
2400 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2401 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2402 + mqMz2 * mqMz2 / s / s * (C40A + C41A * AlsMzPi
2403 + (C42A + C42AL * log_q) * AlsMzPi2)
2404 - 12.0 * mqdash4 / s / s*AlsMzPi2;
2405 return RAf;
2406}
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 2036 of file StandardModel/src/StandardModel.cpp.

2039{
2040 if ((FlagKappaZ.compare("APPROXIMATEFORMULA") == 0)
2041 || (deltaKappa_rem[EW2QCD1] != 0.0)
2042 || (deltaKappa_rem[EW3] != 0.0))
2043 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2044
2045 if (!flag_order[EW2] && FlagKappaZ.compare("NORESUM") != 0)
2046 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2047
2048 double Mw_TMP = Mw();
2049 double cW2_TMP = cW2();
2050 double sW2_TMP = sW2();
2051
2052 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
2053 double DeltaRbar_rem_G, deltaKappa_rem_G, deltaKappa_rem_G2;
2054 // conversion: alpha(0) --> G_F
2055 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
2056 * sW2_TMP * cW2_TMP / M_PI / ale;
2057 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
2058 + f_AlphaToGF * DeltaRho[EW1QCD1]
2059 + f_AlphaToGF * DeltaRho[EW1QCD2]
2060 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
2061 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
2062 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
2063 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
2064 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
2065 deltaKappa_rem_G = f_AlphaToGF * (deltaKappa_rem[EW1]
2066 + deltaKappa_rem[EW1QCD1]
2067 + deltaKappa_rem[EW1QCD2]);
2068 deltaKappa_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaKappa_rem[EW2];
2069
2070 /* Real parts */
2071 double kappaZ;
2072 if (!bool_Zbb) {
2073 if (FlagKappaZ.compare("OMSI") == 0) {
2074 kappaZ = (1.0 + deltaKappa_rem_G + deltaKappa_rem_G2)
2075 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
2076 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0) {
2077 kappaZ = (1.0 + deltaKappa_rem_G)
2078 *(1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2079 + deltaKappa_rem_G2;
2080 } else if (FlagKappaZ.compare("NORESUM") == 0
2081 || FlagKappaZ.compare("OMSII") == 0) {
2082 kappaZ = 1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2083 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2084 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2085 + deltaKappa_rem_G2;
2086 } else
2087 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2088 } else {
2089 /* Z to bb */
2090 double OnePlusTaub = 1.0 + taub();
2091 double kappaZbL;
2092 deltaKappa_rem_G -= f_AlphaToGF * ale / 8.0 / M_PI / sW2_TMP
2093 * pow(mtpole / Mw_TMP, 2.0);
2094 if (FlagKappaZ.compare("NORESUM") == 0) {
2095 kappaZ = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum
2096 - cW2_TMP / sW2_TMP * DeltaRho_G * DeltaRbar_rem_G
2097 + deltaKappa_rem_G * (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G)
2098 + deltaKappa_rem_G2) / OnePlusTaub;
2099 } else if (FlagKappaZ.compare("OMSI") == 0) {
2100 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2101 kappaZ = kappaZbL * (1.0 + deltaKappa_rem_G);
2102 } else if (FlagKappaZ.compare("INTERMEDIATE") == 0
2103 || FlagKappaZ.compare("OMSII") == 0) {
2104 kappaZbL = (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum) / OnePlusTaub;
2105 kappaZ = kappaZbL + deltaKappa_rem_G;
2106 } else
2107 throw std::runtime_error("Error in StandardModel::resumKappaZ()");
2108 }
2109
2110 return kappaZ;
2111}
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 1870 of file StandardModel/src/StandardModel.cpp.

1872{
1873 if ((FlagMw.compare("APPROXIMATEFORMULA") == 0)
1874 || (DeltaR_rem[EW2QCD1] != 0.0)
1875 || (DeltaR_rem[EW3] != 0.0))
1876 throw std::runtime_error("Error in StandardModel::resumMw()");
1877
1878 if (!flag_order[EW2] && FlagMw.compare("NORESUM") != 0)
1879 throw std::runtime_error("Error in StandardModel::resumMw()");
1880
1881 double cW2_TMP = Mw_i * Mw_i / Mz / Mz;
1882 double sW2_TMP = 1.0 - cW2_TMP;
1883
1884 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G = 0.0;
1885 if (FlagMw.compare("NORESUM") == 0) {
1886 for (int j = 0; j < orders_EW_size; ++j) {
1887 DeltaRho_sum += DeltaRho[(orders_EW) j];
1888 }
1889 } else {
1890 // conversion: alpha(0) --> G_F
1891 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0) * sW2_TMP * cW2_TMP / M_PI / ale;
1892 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1893 + f_AlphaToGF * DeltaRho[EW1QCD1]
1894 + f_AlphaToGF * DeltaRho[EW1QCD2]
1895 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1896 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1897 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1898 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1899 }
1900
1901 double R;
1902 double DeltaR_rem_sum = 0.0;
1903 double DeltaR_EW1 = 0.0, DeltaR_EW2_rem = 0.0;
1904 if (FlagMw.compare("NORESUM") == 0) {
1905 for (int j = 0; j < orders_EW_size; ++j)
1906 DeltaR_rem_sum += DeltaR_rem[(orders_EW) j];
1907
1908 // Full EW one-loop contribution (without the full DeltaAlphaL5q)
1909 DeltaR_EW1 = -cW2_TMP / sW2_TMP * DeltaRho[EW1] + DeltaR_rem[EW1];
1910
1911 // Full EW two-loop contribution without reducible corrections
1912 DeltaR_EW2_rem = myApproximateFormulae->DeltaR_TwoLoopEW_rem(Mw_i);
1913
1914 // subtract the EW two-loop contributions from DeltaRho_sum and DeltaR_rem_sum
1915 DeltaRho_sum -= DeltaRho[EW2];
1916 DeltaR_rem_sum -= DeltaR_rem[EW2];
1917
1918 // R = 1 + Delta r, including the full EW two-loop contribution
1919 R = 1.0 + DeltaAlphaL5q() - cW2_TMP / sW2_TMP * DeltaRho_sum
1920 + DeltaR_rem_sum;
1921 R += DeltaAlphaL5q() * DeltaAlphaL5q() + 2.0 * DeltaAlphaL5q() * DeltaR_EW1
1922 + DeltaR_EW2_rem;
1923 } else if (FlagMw.compare("OMSI") == 0) {
1924 // R = 1/(1 - Delta r)
1925 R = 1.0 / (1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1926 / (1.0 - DeltaAlphaL5q()
1927 - DeltaR_rem[EW1] - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1928 } else if (FlagMw.compare("INTERMEDIATE") == 0) {
1929 // R = 1/(1 - Delta r)
1930 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)
1931 *(1.0 - DeltaAlphaL5q() - DeltaR_rem[EW1])
1932 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1933 } else if (FlagMw.compare("OMSII") == 0) {
1934 // R = 1/(1 - Delta r)
1935 R = 1.0 / ((1.0 + cW2_TMP / sW2_TMP * DeltaRho_sum)*(1.0 - DeltaAlphaL5q())
1936 - (1.0 + cW2_TMP / sW2_TMP * DeltaRho_G) * DeltaR_rem[EW1]
1937 - DeltaR_rem[EW1QCD1] - DeltaR_rem[EW2]);
1938 } else
1939 throw std::runtime_error("Error in StandardModel::resumMw()");
1940
1941 if (FlagMw.compare("NORESUM") == 0) {
1942 /* Mzbar and Mwbar are defined in the complex-pole scheme. */
1943
1944 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mzbar() / Mzbar();
1945 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1946 double Mwbar = Mzbar() / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R));
1947
1948 return MwFromMwbar(Mwbar);
1949 } else {
1950 double tmp = 4.0 * M_PI * ale / sqrt(2.0) / GF / Mz / Mz;
1951 if (tmp * R > 1.0) throw std::runtime_error("StandardModel::resumMw(): Negative (1-tmp*R)");
1952
1953 return (Mz / sqrt(2.0) * sqrt(1.0 + sqrt(1.0 - tmp * R)));
1954 }
1955}
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 1957 of file StandardModel/src/StandardModel.cpp.

1960{
1961 if ((FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1962 || (deltaRho_rem[EW1QCD2] != 0.0)
1963 || (deltaRho_rem[EW2QCD1] != 0.0)
1964 || (deltaRho_rem[EW3] != 0.0))
1965 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1966
1967 if (!flag_order[EW2] && FlagRhoZ.compare("NORESUM") != 0)
1968 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
1969
1970 double Mw_TMP = Mw();
1971 double cW2_TMP = cW2();
1972 double sW2_TMP = sW2();
1973
1974 double f_AlphaToGF, DeltaRho_sum = 0.0, DeltaRho_G;
1975 double DeltaRbar_rem_G, deltaRho_rem_G, deltaRho_rem_G2;
1976 // conversion: alpha(0) --> G_F
1977 f_AlphaToGF = sqrt(2.0) * GF * pow(Mz, 2.0)
1978 * sW2_TMP * cW2_TMP / M_PI / ale;
1979 DeltaRho_sum = f_AlphaToGF * DeltaRho[EW1]
1980 + f_AlphaToGF * DeltaRho[EW1QCD1]
1981 + f_AlphaToGF * DeltaRho[EW1QCD2]
1982 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2]
1983 + pow(f_AlphaToGF, 2.0) * DeltaRho[EW2QCD1]
1984 + pow(f_AlphaToGF, 3.0) * DeltaRho[EW3];
1985 DeltaRho_G = f_AlphaToGF * DeltaRho[EW1];
1986 DeltaRbar_rem_G = f_AlphaToGF*DeltaRbar_rem;
1987 deltaRho_rem_G = f_AlphaToGF * (deltaRho_rem[EW1]
1988 + deltaRho_rem[EW1QCD1]);
1989 deltaRho_rem_G2 = pow(f_AlphaToGF, 2.0) * deltaRho_rem[EW2];
1990
1991 /* Real parts */
1992 double rhoZ;
1993 if (!bool_Zbb) {
1994 if (FlagRhoZ.compare("OMSI") == 0) {
1995 rhoZ = (1.0 + deltaRho_rem_G + deltaRho_rem_G2)
1996 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G));
1997 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
1998 rhoZ = (1.0 + deltaRho_rem_G)
1999 / (1.0 - DeltaRho_sum * (1.0 - DeltaRbar_rem_G))
2000 + deltaRho_rem_G2;
2001 } else if (FlagRhoZ.compare("NORESUM") == 0
2002 || FlagRhoZ.compare("OMSII") == 0) {
2003 rhoZ = 1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2004 + DeltaRho_G * DeltaRho_G
2005 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2;
2006 } else
2007 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2008 } else {
2009 /* Z to bb */
2010 double OnePlusTaub = 1.0 + taub();
2011 double OnePlusTaub2 = OnePlusTaub*OnePlusTaub;
2012 double rhoZbL;
2013 deltaRho_rem_G += f_AlphaToGF * ale / 4.0 / M_PI / sW2_TMP
2014 * pow(mtpole / Mw_TMP, 2.0);
2015 if (FlagRhoZ.compare("NORESUM") == 0) {
2016 rhoZ = (1.0 + DeltaRho_sum - DeltaRho_G * DeltaRbar_rem_G
2017 + DeltaRho_G * DeltaRho_G
2018 + deltaRho_rem_G * (1.0 + DeltaRho_G) + deltaRho_rem_G2)
2019 * OnePlusTaub2;
2020 } else if (FlagRhoZ.compare("OMSI") == 0) {
2021 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2022 rhoZ = rhoZbL / (1.0 - rhoZbL * deltaRho_rem_G);
2023 } else if (FlagRhoZ.compare("INTERMEDIATE") == 0) {
2024 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2025 rhoZ = rhoZbL * (1.0 + rhoZbL * deltaRho_rem_G);
2026 } else if (FlagRhoZ.compare("OMSII") == 0) {
2027 rhoZbL = OnePlusTaub2 / (1.0 - DeltaRho_sum);
2028 rhoZ = rhoZbL * (1.0 + deltaRho_rem_G);
2029 } else
2030 throw std::runtime_error("Error in StandardModel::resumRhoZ()");
2031 }
2032
2033 return rhoZ;
2034}

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

1235{
1236 double rhoW = 0.0;
1237 if (flag_order[EW1])
1238 rhoW = myOneLoopEW->rho_GammaW(fi, fj, Mw());
1239 return rhoW;
1240}
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 1588 of file StandardModel/src/StandardModel.cpp.

1589{
1590 if (f.getName().compare("TOP") == 0) return (gslpp::complex(0.0, 0.0, false));
1591 if (FlagRhoZ.compare("APPROXIMATEFORMULA") == 0)
1592 throw std::runtime_error("No approximate formula is available for rhoZ^f");
1593 else {
1594
1596 if (useRhoZ_f_cache[f.getIndex()])
1597 return rhoZ_f_cache[f.getIndex()];
1598
1599 double myMw = Mw();
1600
1601 /* compute Delta rho */
1602 double DeltaRho[orders_EW_size];
1603 ComputeDeltaRho(myMw, DeltaRho);
1604
1605 /* compute delta rho_rem^f */
1606 gslpp::complex deltaRho_remf[orders_EW_size];
1607 deltaRho_remf[EW1] = gslpp::complex(0.0, 0.0, false);
1608 deltaRho_remf[EW1QCD1] = gslpp::complex(0.0, 0.0, false);
1609 deltaRho_remf[EW1QCD2] = gslpp::complex(0.0, 0.0, false);
1610 deltaRho_remf[EW2] = gslpp::complex(0.0, 0.0, false);
1611 deltaRho_remf[EW2QCD1] = gslpp::complex(0.0, 0.0, false);
1612 deltaRho_remf[EW3] = gslpp::complex(0.0, 0.0, false);
1613 if (flag_order[EW1])
1614 deltaRho_remf[EW1] = myOneLoopEW->deltaRho_rem_f(f, myMw);
1615 if (flag_order[EW1QCD1])
1616#ifdef WITHIMTWOLOOPQCD
1617 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(),
1618 myTwoLoopQCD->deltaRho_rem_f(f, myMw).imag(), false);
1619#else
1620 deltaRho_remf[EW1QCD1] = gslpp::complex(myTwoLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1621#endif
1622 if (flag_order[EW1QCD2])
1623 deltaRho_remf[EW1QCD2] = gslpp::complex(myThreeLoopQCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1624 if (flag_order[EW2])
1625 deltaRho_remf[EW2] = gslpp::complex(myTwoLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1626 if (flag_order[EW2QCD1])
1627 deltaRho_remf[EW2QCD1] = gslpp::complex(myThreeLoopEW2QCD->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1628 if (flag_order[EW3])
1629 deltaRho_remf[EW3] = gslpp::complex(myThreeLoopEW->deltaRho_rem_f(f, myMw).real(), 0.0, false);
1630
1631 /* compute Delta rbar_rem */
1632 double DeltaRbar_rem = 0.0;
1633 if (flag_order[EW1])
1634 DeltaRbar_rem = myOneLoopEW->DeltaRbar_rem(myMw);
1635
1636 /* Re[rho_Z^f] with or without resummation */
1637 double deltaRho_rem_f_real[orders_EW_size];
1638 for (int j = 0; j < orders_EW_size; ++j)
1639 deltaRho_rem_f_real[j] = deltaRho_remf[j].real();
1640 double ReRhoZf = resumRhoZ(DeltaRho, deltaRho_rem_f_real, DeltaRbar_rem, f.is("BOTTOM"));
1641
1642 /* Im[rho_Z^f] without resummation */
1643 double ImRhoZf = 0.0;
1644 for (int j = 0; j < orders_EW_size; ++j)
1645 ImRhoZf += deltaRho_remf[j].imag();
1646
1647 rhoZ_f_cache[f.getIndex()] = gslpp::complex(ReRhoZf, ImRhoZf, false);
1648 useRhoZ_f_cache[f.getIndex()] = true;
1649 return (gslpp::complex(ReRhoZf, ImRhoZf, false));
1650 }
1651}
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 1317 of file StandardModel/src/StandardModel.cpp.

1318{
1319 return 0.5 * ( R0_f(quarks[UP]) + R0_f(quarks[CHARM]) );
1320}

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

2409{
2410 /* rescaled strong coupling constant */
2411 double AlsMzPi = AlsMz / M_PI;
2412 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2413 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2414 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2415
2416 gslpp::complex gV_sum(0.0, 0.0);
2417 gslpp::complex gV_q;
2418 for (int q = 0; q < 6; q++) {
2419 gV_q = gV_f(QCD::quarks[(QCD::quark)q]);
2420 if (q == (int) (QCD::TOP))
2421 gV_q = 0.0;
2422 gV_sum += gV_q;
2423 }
2424
2425 // singlet vector corrections
2426 return ( gV_sum.abs2()*(-0.4132 * AlsMzPi3 - 4.9841 * AlsMzPi4));
2427}

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

2152{
2153 if (q == QCD::TOP) return 0.0;
2154
2155 double mcMz, mbMz;
2158 //mcMz = 0.56381685; /* for debug */
2159 //mbMz = 2.8194352; /* for debug */
2160
2161 double MtPole = mtpole;
2162
2163 /* electric charge squared */
2164 double Qf2 = pow(quarks[q].getCharge(), 2.0);
2165
2166 /* s = Mz^2 */
2167 double s = Mz * Mz;
2168
2169 /* products of the charm and bottom masses at Mz */
2170 double mcMz2 = mcMz*mcMz;
2171 double mbMz2 = mbMz*mbMz;
2172 double mqMz2, mqdash4;
2173 switch (q) {
2174 case QCD::CHARM:
2175 mqMz2 = mcMz*mcMz;
2176 mqdash4 = mbMz2*mbMz2;
2177 break;
2178 case QCD::BOTTOM:
2179 mqMz2 = mbMz*mbMz;
2180 mqdash4 = mcMz2*mcMz2;
2181 break;
2182 default:
2183 mqMz2 = 0.0;
2184 mqdash4 = 0.0;
2185 break;
2186 }
2187
2188 /* Logarithms */
2189 //double log_t = log(pow(quarks[TOP].getMass(),2.0)/s);
2190 double log_t = log(MtPole * MtPole / s); // the pole mass
2191 double log_c = log(mcMz2 / s);
2192 double log_b = log(mbMz2 / s);
2193 double log_q;
2194 switch (q) {
2195 case QCD::CHARM:
2196 case QCD::BOTTOM:
2197 log_q = log(mqMz2 / s);
2198 break;
2199 default:
2200 log_q = 0.0;
2201 break;
2202 }
2203
2204 /* the active number of flavour */
2205 double nf = 5.0;
2206
2207 /* zeta functions */
2208 double zeta2 = getMyEWSMcache()->getZeta2();
2209 double zeta3 = getMyEWSMcache()->getZeta3();
2210 //double zeta4 = getMyCache()->GetZeta4();
2211 double zeta5 = getMyEWSMcache()->getZeta5();
2212
2213 /* massless non-singlet corrections */
2214 double C02 = 365.0 / 24.0 - 11.0 * zeta3 + (-11.0 / 12.0 + 2.0 / 3.0 * zeta3) * nf;
2215 double C03 = 87029.0 / 288.0 - 121.0 / 8.0 * zeta2 - 1103.0 / 4.0 * zeta3
2216 + 275.0 / 6.0 * zeta5
2217 + (-7847.0 / 216.0 + 11.0 / 6.0 * zeta2 + 262.0 / 9.0 * zeta3
2218 - 25.0 / 9.0 * zeta5) * nf
2219 + (151.0 / 162.0 - zeta2 / 18.0 - 19.0 / 27.0 * zeta3) * nf*nf;
2220 double C04 = -156.61 + 18.77 * nf - 0.7974 * nf * nf + 0.0215 * nf * nf*nf;
2221 //std::cout << "TEST: C02 = " << C02 << std::endl;// TEST (should be 1.40923)
2222 //std::cout << "TEST: C03 = " << C03 << std::endl;// TEST (should be -12.7671)
2223 //std::cout << "TEST: C04 = " << C04 << std::endl;// TEST (should be -80.0075)
2224
2225 /* quadratic massive corrections */
2226 double C23 = -80.0 + 60.0 * zeta3 + (32.0 / 9.0 - 8.0 / 3.0 * zeta3) * nf;
2227 double C21V = 12.0;
2228 double C22V = 253.0 / 2.0 - 13.0 / 3.0 * nf;
2229 double C23V = 2522.0 - 855.0 / 2.0 * zeta2 + 310.0 / 3.0 * zeta3 - 5225.0 / 6.0 * zeta5
2230 + (-4942.0 / 27.0 + 34.0 * zeta2 - 394.0 / 27.0 * zeta3
2231 + 1045.0 / 27.0 * zeta5) * nf
2232 + (125.0 / 54.0 - 2.0 / 3.0 * zeta2) * nf*nf;
2233
2234 /* quartic massive corrections */
2235 double C42 = 13.0 / 3.0 - 4.0 * zeta3;
2236 double C40V = -6.0;
2237 double C41V = -22.0;
2238 double C42V = -3029.0 / 12.0 + 162.0 * zeta2 + 112.0 * zeta3
2239 + (143.0 / 18.0 - 4.0 * zeta2 - 8.0 / 3.0 * zeta3) * nf;
2240 double C42VL = -11.0 / 2.0 + nf / 3.0;
2241
2242 /* power suppressed top-mass correction */
2243 //double xt = s/pow(quarks[TOP].getMass(),2.0);
2244 double xt = s / MtPole / MtPole; // the pole mass
2245 double C2t = xt * (44.0 / 675.0 - 2.0 / 135.0 * (-log_t));
2246
2247 /* rescaled strong coupling constant */
2248 double AlsMzPi = AlsMz / M_PI;
2249 double AlsMzPi2 = AlsMzPi*AlsMzPi;
2250 double AlsMzPi3 = AlsMzPi2*AlsMzPi;
2251 double AlsMzPi4 = AlsMzPi3*AlsMzPi;
2252
2253 /* electromagnetic coupling at Mz */
2254 double alpMz = alphaMz();
2255
2256 /* radiator function to the vector current */
2257 double RVf;
2258 RVf = 1.0 + 3.0 / 4.0 * Qf2 * alpMz / M_PI + AlsMzPi - Qf2 / 4.0 * alpMz / M_PI * AlsMzPi
2259 + (C02 + C2t) * AlsMzPi2 + C03 * AlsMzPi3 + C04 * AlsMzPi4
2260 + (mcMz2 + mbMz2) / s * C23 * AlsMzPi3
2261 + mqMz2 / s * (C21V * AlsMzPi + C22V * AlsMzPi2 + C23V * AlsMzPi3)
2262 + mcMz2 * mcMz2 / s / s * (C42 - log_c) * AlsMzPi2
2263 + mbMz2 * mbMz2 / s / s * (C42 - log_b) * AlsMzPi2
2264 + mqMz2 * mqMz2 / s / s * (C40V + C41V * AlsMzPi + (C42V + C42VL * log_q) * AlsMzPi2)
2265 + 12.0 * mqdash4 / s / s * AlsMzPi2
2266 - mqMz2 * mqMz2 * mqMz2 / s / s / s
2267 * (8.0 + 16.0 / 27.0 * (155.0 + 6.0 * log_q) * AlsMzPi);
2268 return RVf;
2269}

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

1323{
1324 double GammWcX, GammWhad;
1325
1326// Add all the W-> cX decays
1327// In GammaW fermion masses are ignored and CKM=1 but uses that SM CKM is unitary => I only need W->cs
1328 GammWcX = GammaW(quarks[CHARM], quarks[STRANGE]);
1329
1330// For the same reasons, I only need to add the W-> ud decays into the hadronic part
1331 GammWhad = GammWcX
1332 + GammaW(quarks[UP], quarks[DOWN]);
1333
1334 return GammWcX/GammWhad;
1335}

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

1293{
1294 double GammWli, GammWlj;
1295
1296 if (li.is("ELECTRON"))
1297 GammWli = GammaW(leptons[NEUTRINO_1],li);
1298 else if (li.is("MU"))
1299 GammWli = GammaW(leptons[NEUTRINO_2],li);
1300 else if (li.is("TAU"))
1301 GammWli = GammaW(leptons[NEUTRINO_3],li);
1302 else
1303 throw std::runtime_error("Error in StandardModel::RWlilj. li must be a charged lepton");
1304
1305 if (lj.is("ELECTRON"))
1306 GammWlj = GammaW(leptons[NEUTRINO_1],lj);
1307 else if (lj.is("MU"))
1308 GammWlj = GammaW(leptons[NEUTRINO_2],lj);
1309 else if (lj.is("TAU"))
1310 GammWlj = GammaW(leptons[NEUTRINO_3],lj);
1311 else
1312 throw std::runtime_error("Error in StandardModel::RWlilj. lj must be a charged lepton");
1313
1314 return GammWli/GammWlj;
1315}

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

1448{
1449 double GammZli, GammZlj;
1450
1451 if ( li.is("ELECTRON") || li.is("MU") || li.is("TAU") )
1452 GammZli = GammaZ(li);
1453 else
1454 throw std::runtime_error("Error in StandardModel::RZlilj. li must be a charged lepton");
1455
1456 if ( lj.is("ELECTRON") || lj.is("MU") || lj.is("TAU") )
1457 GammZlj = GammaZ(lj);
1458 else
1459 throw std::runtime_error("Error in StandardModel::RZlilj. lj must be a charged lepton");
1460
1461 return GammZli/GammZlj;
1462}

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

1006{
1007 double tmp = 1.0 - 4.0 * M_PI * alphaMz() / sqrt(2.0) / GF / Mz / Mz;
1008 if (tmp < 0.0)
1009 throw std::runtime_error("Error in s02()");
1010
1011 return ( (1.0 - sqrt(tmp)) / 2.0);
1012}

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

3498 {
3499 if (scheme.compare("NORESUM") == 0)
3500 return 0.0;
3501 else if (scheme.compare("OMSI") == 0)
3502 return 1.0;
3503 else if (scheme.compare("INTERMEDIATE") == 0)
3504 return 2.0;
3505 else if (scheme.compare("OMSII") == 0)
3506 return 3.0;
3507 else if (scheme.compare("APPROXIMATEFORMULA") == 0)
3508 return 4.0;
3509 else
3510 throw std::runtime_error("EWSM::SchemeToDouble: bad scheme");
3511 }

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

3329 {
3330 myCKM = CKMMatrix;
3331 }

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

444{
445 bool res = false;
446 if (name.compare("CacheInStandardModel") == 0) {
448 res = true;
449 } else if (name.compare("CacheInEWSMcache") == 0) {
451 res = true;
452 } else if (name.compare("Wolfenstein") == 0) {
453 FlagWolfenstein = value;
454 if(!FlagWolfenstein) {
455 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"lambda"))] = "V_us";
456 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"A"))] = "V_cb";
457 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"rhob"))] = "V_ub";
458 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"etab"))] = "gamma";
459
460 ModelParamMap.insert(std::make_pair("V_us", std::cref(Vus)));
461 ModelParamMap.insert(std::make_pair("V_cb", std::cref(Vcb)));
462 ModelParamMap.insert(std::make_pair("V_ub", std::cref(Vub)));
463 ModelParamMap.insert(std::make_pair("gamma", std::cref(gamma)));
464 }
465 res = true;
466 } else if (name.compare("WithoutNonUniversalVC") == 0) {
468 res = true;
469 } else if (name.compare("NoApproximateGammaZ") == 0) {
471 res = true;
472 } else if (name.compare("MWinput") == 0) {
473 FlagMWinput = value;
474 if (FlagMWinput) {
475 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"dAle5Mz"))] = "Mw_inp";
476 ModelParamMap.insert(std::make_pair("Mw_inp", std::cref(Mw_inp)));
477 // Point the different flags towards the approximate formulae, when available
479 FlagMw = "APPROXIMATEFORMULA";
480 FlagRhoZ = "NORESUM";
481 FlagKappaZ = "APPROXIMATEFORMULA";
482 }
483 res = true;
484 } else if (name.compare("SMAux") == 0) {
485 FlagSMAux = value;
486 res = true;
487 } else if (name.compare("FixMuwMut") == 0) {
488 FlagFixMuwMut = value;
489 res = true;
490 } else if (name.compare("UseVud") == 0) {
491 FlagUseVud = value;
493 throw std::runtime_error("UseVud can only be used when Wolfenstein is false");
494 else if(FlagUseVud) {
495 SMvars[std::distance(SMvars,std::find(SMvars,SMvars+NSMvars,"V_us"))] = "V_ud";
496 ModelParamMap.erase("V_us");
497 ModelParamMap.insert(std::make_pair("V_ud", std::cref(Vud)));
498 }
499 res = true;
500 } else
501 res = QCD::setFlag(name, value);
502
503 if (!res) res = SMFlavour.setFlag(name, value);
504
505 return (res);
506}
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:37
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 730 of file StandardModel.h.

◆ setFlagNoApproximateGammaZ()

void StandardModel::setFlagNoApproximateGammaZ ( bool  FlagNoApproximateGammaZ)
inline

Definition at line 684 of file StandardModel.h.

◆ setFlagSigmaForAFB()

bool StandardModel::setFlagSigmaForAFB ( const bool  flagSigmaForAFB_i)
inline

Definition at line 3292 of file StandardModel.h.

3293{
3294 bSigmaForAFB = flagSigmaForAFB_i;
3295 return true;
3296}

◆ setFlagSigmaForR()

bool StandardModel::setFlagSigmaForR ( const bool  flagSigmaForR_i)
inline

Definition at line 3298 of file StandardModel.h.

3299{
3300 bSigmaForR = flagSigmaForR_i;
3301 return true;
3302}

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

509{
510 bool res = false;
511 if (name.compare("Mw") == 0) {
512 if (checkEWPOscheme(value)) {
513 FlagMw = value;
514 res = true;
515 } else
516 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
517 + name + "=" + value);
518
519 } else if (name.compare("RhoZ") == 0) {
520 if (checkEWPOscheme(value)) {
521 FlagRhoZ = value;
522 res = true;
523 } else
524 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
525 + name + "=" + value);
526 } else if (name.compare("KappaZ") == 0) {
527 if (checkEWPOscheme(value)) {
528 FlagKappaZ = value;
529 res = true;
530 } else
531 throw std::runtime_error("StandardModel::setFlagStr(): Invalid flag "
532 + name + "=" + value);
533 } else
534 res = QCD::setFlagStr(name, value);
535
536 if (FlagMWinput) {
537 // Point the different flags towards the approximate formulae, when available
539 FlagMw = "APPROXIMATEFORMULA";
540 FlagRhoZ = "NORESUM";
541 FlagKappaZ = "APPROXIMATEFORMULA";
542 }
543
544 return (res);
545}
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, NPSMEFTd6General, 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 278 of file StandardModel/src/StandardModel.cpp.

279{
280 if (name.compare("Mz") == 0) {
281 Mz = value;
282 QCD::setParameter("MAls", value);
283 } else if (name.compare("AlsMz") == 0) {
284 AlsMz = value;
285 QCD::setParameter("AlsM", value);
286 } else if (name.compare("GF") == 0)
287 GF = value;
288 else if (name.compare("ale") == 0)
289 ale = value;
290 else if (name.compare("dAle5Mz") == 0 && !FlagMWinput)
291 dAle5Mz = value;
292 else if (name.compare("Mw_inp") == 0 && FlagMWinput)
293 Mw_inp = value;
294 else if (name.compare("mHl") == 0)
295 mHl = value;
296 else if (name.compare("delMw") == 0)
297 delMw = value;
298 else if (name.compare("delSin2th_l") == 0)
299 delSin2th_l = value;
300 else if (name.compare("delSin2th_q") == 0)
301 delSin2th_q = value;
302 else if (name.compare("delSin2th_b") == 0)
303 delSin2th_b = value;
304 else if (name.compare("delGammaZ") == 0)
305 delGammaZ = value;
306 else if (name.compare("delsigma0H") == 0)
307 delsigma0H = value;
308 else if (name.compare("delR0l") == 0)
309 delR0l = value;
310 else if (name.compare("delR0c") == 0)
311 delR0c = value;
312 else if (name.compare("delR0b") == 0)
313 delR0b = value;
314 else if (name.compare("mneutrino_1") == 0)
315 leptons[NEUTRINO_1].setMass(value);
316 else if (name.compare("mneutrino_2") == 0)
317 leptons[NEUTRINO_2].setMass(value);
318 else if (name.compare("mneutrino_3") == 0)
319 leptons[NEUTRINO_3].setMass(value);
320 else if (name.compare("melectron") == 0)
321 leptons[ELECTRON].setMass(value);
322 else if (name.compare("mmu") == 0)
323 leptons[MU].setMass(value);
324 else if (name.compare("mtau") == 0)
325 leptons[TAU].setMass(value);
326 else if (name.compare("lambda") == 0 && FlagWolfenstein) {
327 lambda = value;
328 requireCKM = true;
329 } else if (name.compare("A") == 0 && FlagWolfenstein) {
330 A = value;
331 requireCKM = true;
332 } else if (name.compare("rhob") == 0 && FlagWolfenstein) {
333 rhob = value;
334 requireCKM = true;
335 } else if (name.compare("etab") == 0 && FlagWolfenstein) {
336 etab = value;
337 requireCKM = true;
338 } else if (name.compare("V_us") == 0 && !FlagWolfenstein && !FlagUseVud) {
339 Vus = value;
340 requireCKM = true;
341 } else if (name.compare("V_ud") == 0 && !FlagWolfenstein && FlagUseVud) {
342 Vud = value;
343 requireCKM = true;
344 } else if (name.compare("V_cb") == 0 && !FlagWolfenstein) {
345 Vcb = value;
346 requireCKM = true;
347 } else if (name.compare("V_ub") == 0 && !FlagWolfenstein) {
348 Vub = value;
349 requireCKM = true;
350 } else if (name.compare("gamma") == 0 && !FlagWolfenstein) {
351 gamma = value;
352 requireCKM = true;
353 } else if (name.compare("muw") == 0) {
354 /* Update mut if FlagFixMuwMut is activated */
355 muw = value;
356 if (FlagFixMuwMut) {
357 mut = muw / 80.4 * 163.;
358 }
359 }
360 else
361 QCD::setParameter(name, value);
362}
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 3319 of file StandardModel.h.

3320 {
3321 this->requireCKM = requireCKM;
3322 }

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

3407 {
3408 SMSuccess = success;
3409 }

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

3369 {
3370 this->Yd = Yd;
3371 }

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

3389 {
3390 this->Ye = Ye;
3391 }

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

3349 {
3350 this->Yu = Yu;
3351 }

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

1466{
1468
1469 /* SM contribution with the approximate formula */
1470 return (myApproximateFormulae->X_full("sigmaHadron")
1471 / GeVminus2_to_nb);
1472
1473 } else {
1474 return (12.0 * M_PI * GammaZ(leptons[ELECTRON]) * Gamma_had()
1475 / Mz / Mz / Gamma_Z() / Gamma_Z());
1476 }
1477}
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 8001 of file StandardModel/src/StandardModel.cpp.

8002{
8003 double ml = getLeptons(l_flavor).getMass();
8004 double l_charge = getLeptons(l_flavor).getCharge();
8005 double sigma = myTwoFermionsLEP2->sigma_l(l_flavor, ml, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8006
8007 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8008 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, l_charge);
8009
8010 return sigma;
8011}

◆ sigma_NoISR_q()

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

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

8014{
8015 double mq = m_q(q_flavor, sqrt(s));
8016 double q_charge = getQuarks(q_flavor).getCharge();
8017 double sigma = myTwoFermionsLEP2->sigma_q(q_flavor, mq, s, Mw(), Gamma_Z(), flagLEP2[Weak]);
8018
8019 if (!bSigmaForAFB && flagLEP2[QEDFSR])
8020 sigma *= myTwoFermionsLEP2->QED_FSR_forSigma(s, q_charge);
8021
8022 if (!bSigmaForAFB && flagLEP2[QCDFSR])
8024
8025 return sigma;
8026}

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

3352{
3353 double xsLH=0.0, xsRH=0.0;
3354
3355 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3356}

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

3345{
3346 double xsLH=1.0, xsRH=0.0;
3347
3348 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3349}

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

3323{
3324 double xsLH, xsRH;
3325 double gL,gR,lam,fact;
3326 double s = sqrt_s*sqrt_s;
3327
3328 // From https://arxiv.org/pdf/hep-ph/9605437
3329
3330 gL = -0.5 + sW2();
3331
3332 gR = sW2();
3333
3334 lam = (1.0-(mHl+Mz)*(mHl+Mz)/s)*(1.0-(mHl-Mz)*(mHl-Mz)/s);
3335
3336 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 );
3337
3338 xsLH = 32.0 * gL * gL * fact;
3339 xsRH = 32.0 * gR * gR * fact;
3340
3341 return 0.25*( (1.0 - Pe)*(1.0 + Pp)*xsLH + (1.0 + Pe)*(1.0 - Pp)*xsRH );
3342}

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

1352{
1353 double Re_kappa = kappaZ_f(f).real();
1354 return ( Re_kappa * sW2());
1355}

◆ sW2() [1/2]

const double StandardModel::sW2 ( ) const

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

1093{
1094 return ( 1.0 - cW2());
1095}

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

1088{
1089 return ( 1.0 - cW2(Mw_i));
1090}

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

1098{
1099 //double rho_t= 3. * getGF() * getMtpole() * getMtpole() / (8. * sqrt(2.) * M_PI * M_PI );
1100 return ( sW2()*1.0351 ); //PDG 22 electroweak review eq. (10.19)
1101}

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

1104{
1105 double d = 1. / 3. * (1. / sW2_MSbar_Approx() - 8. / 3.) *
1106 ( (1 + getAlsMz()/M_PI)*log(getMtpole()/getMz()) - 15.*getAlsMz()/(8.*M_PI) );
1107
1108 return sW2_MSbar_Approx()*(1. + Ale(getMz(),FULLNLO)*d/M_PI);
1109
1110}
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 2113 of file StandardModel/src/StandardModel.cpp.

2114{
2115 double taub_tmp = 0.0;
2116 double Xt = myEWSMcache->Xt_GF();
2117 if (flag_order[EW1])
2118 taub_tmp += -2.0 * Xt;
2119 if (flag_order[EW1QCD1])
2120 taub_tmp += 2.0 / 3.0 * M_PI * Xt * myEWSMcache->alsMt();
2121 if (flag_order[EW1QCD2])
2122 taub_tmp += 0.0;
2123 if (flag_order[EW2])
2124 taub_tmp += -2.0 * Xt * Xt * myTwoLoopEW->tau_2();
2125 if (flag_order[EW2QCD1])
2126 taub_tmp += 0.0;
2127 if (flag_order[EW3])
2128 taub_tmp += 0.0;
2129
2130 return taub_tmp;
2131}
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 \)

Reimplemented in NPbase.

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

3166{
3167 double g2LFU;
3168
3169 double me, mmu, mtau, xe, Fxe, xmu, Fxmu;
3170
3171 me = leptons[ELECTRON].getMass();
3172 mmu = leptons[MU].getMass();
3173 mtau = leptons[TAU].getMass();
3174
3175 xe = me*me/mtau/mtau;
3176 Fxe = 1. - 8. * xe + 8. * xe*xe*xe - xe*xe*xe*xe -12. * xe*xe * log(xe);
3177
3178 xmu = mmu*mmu/mtau/mtau;
3179 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3180
3182
3183 g2LFU = g2LFU * (Fxe/Fxmu);
3184
3185 return sqrt(g2LFU);
3186}
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 \)

Reimplemented in NPbase.

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

3212{
3213 double g2LFU;
3214
3215 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3216
3217 me = leptons[ELECTRON].getMass();
3218 mmu = leptons[MU].getMass();
3219 mtau = leptons[TAU].getMass();
3220
3221 xtau = mmu*mmu/mtau/mtau;
3222 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3223
3224 xmu = me*me/mmu/mmu;
3225 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3226
3227 g2LFU = (Gamma_tau_l_nunu(leptons[MU])/Gamma_muon());
3228
3229 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3230
3231 return sqrt(g2LFU);
3232}
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 \)

Reimplemented in NPbase.

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

3189{
3190 double g2LFU;
3191
3192 double me, mmu, mtau, xtau, Fxtau, xmu, Fxmu;
3193
3194 me = leptons[ELECTRON].getMass();
3195 mmu = leptons[MU].getMass();
3196 mtau = leptons[TAU].getMass();
3197
3198 xtau = me*me/mtau/mtau;
3199 Fxtau = 1. - 8. * xtau + 8. * xtau*xtau*xtau - xtau*xtau*xtau*xtau -12. * xtau*xtau * log(xtau);
3200
3201 xmu = me*me/mmu/mmu;
3202 Fxmu = 1. - 8. * xmu + 8. * xmu*xmu*xmu - xmu*xmu*xmu*xmu -12. * xmu*xmu * log(xmu);
3203
3205
3206 g2LFU = g2LFU * (pow(mmu,5)*Fxmu/pow(mtau,5)/Fxtau);
3207
3208 return sqrt(g2LFU);
3209}

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

Reimplemented in NPbase.

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

3243{
3244 // 1st approx.
3245
3246 return 1.0;
3247}

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

Reimplemented in NPbase.

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

3236{
3237 // 1st approx.
3238
3239 return 1.0;
3240}

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

3029{
3030 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3032
3033 /* SM contribution with the approximate formula */
3035
3036 } else {
3037 throw std::runtime_error("ERROR: StandardModel::ThetaLnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3038 }
3039}
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 3042 of file StandardModel/src/StandardModel.cpp.

3043{
3044 // Use same flag as other Z pole observables for the moment to decide whether to use approx formulae
3046
3047 /* SM contribution with the approximate formula */
3049
3050 } else {
3051 throw std::runtime_error("ERROR: StandardModel::ThetaRnuN, prediction implemented only via semianalytical approximate formula. Check flags!");
3052 }
3053}
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 3912 of file StandardModel/src/StandardModel.cpp.

3912 {
3913 return 0.25 * (cosmax * (1.0 - cosmax * (1.0 - cosmax / 3.0)) - cosmin * (1.0 - cosmin * (1.0 - cosmin / 3.0)));
3914}

◆ uovers2()

const double StandardModel::uovers2 ( const double  cosmin,
const double  cosmax 
) const

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

3916 {
3917 return 0.25 * (cosmax * (1.0 + cosmax * (1.0 + cosmax / 3.0)) - cosmin * (1.0 + cosmin * (1.0 + cosmin / 3.0)));
3918}

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

226{
227 if (!PreUpdate()) return (false);
228
229 UpdateError = false;
230
231 for (std::map<std::string, double>::const_iterator it = DPars.begin(); it != DPars.end(); it++)
232 setParameter(it->first, it->second);
233
234 if (UpdateError) return (false);
235
236 if (!PostUpdate()) return (false);
237
238 return (true);
239}
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 989 of file StandardModel/src/StandardModel.cpp.

990{
991 return ( 1. / sqrt(sqrt(2.) * GF));
992}

Member Data Documentation

◆ A

double StandardModel::A
protected

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

Definition at line 3462 of file StandardModel.h.

◆ ale

double StandardModel::ale
protected

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

Definition at line 3449 of file StandardModel.h.

◆ ale_cache

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

Cache for \(\alpha_e\).

Definition at line 4080 of file StandardModel.h.

◆ alpha21

double StandardModel::alpha21
protected

Definition at line 3471 of file StandardModel.h.

◆ alpha31

double StandardModel::alpha31
protected

Definition at line 3471 of file StandardModel.h.

◆ als_cache

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

Cache for \(\alpha_s\).

Definition at line 4079 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 3445 of file StandardModel.h.

◆ average

double StandardModel::average
mutableprivate

GSL integral variable

Definition at line 4065 of file StandardModel.h.

◆ bSigmaForAFB

bool StandardModel::bSigmaForAFB
mutableprotected

Definition at line 3729 of file StandardModel.h.

◆ bSigmaForR

bool StandardModel::bSigmaForR
mutableprotected

Definition at line 3730 of file StandardModel.h.

◆ CacheSize

const int StandardModel::CacheSize = 5
staticprivate

Defines the depth of the cache.

Definition at line 4078 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 3474 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 3450 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 3456 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 3452 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 3460 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 3459 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 3458 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 3457 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 3455 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 3453 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 3454 of file StandardModel.h.

◆ delta

double StandardModel::delta
protected

Definition at line 3471 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 4046 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 4045 of file StandardModel.h.

◆ error

double StandardModel::error
mutableprivate

GSL integral variable

Definition at line 4066 of file StandardModel.h.

◆ etab

double StandardModel::etab
protected

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

Definition at line 3464 of file StandardModel.h.

◆ f_GSL

gsl_function StandardModel::f_GSL
mutableprivate

GSL integral variable

Definition at line 4067 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 3485 of file StandardModel.h.

◆ FlagCacheInStandardModel

bool StandardModel::FlagCacheInStandardModel
private

A flag for caching (true by default).

Definition at line 4043 of file StandardModel.h.

◆ FlagFixMuwMut

bool StandardModel::FlagFixMuwMut
protected

A boolean for the model flag FixMuwMut.

Definition at line 3719 of file StandardModel.h.

◆ FlagKappaZ

std::string StandardModel::FlagKappaZ
private

A string for the model flag KappaZ.

Definition at line 4031 of file StandardModel.h.

◆ flagLEP2

bool StandardModel::flagLEP2[NUMofLEP2RCs]
protected

Definition at line 3728 of file StandardModel.h.

◆ FlagMw

std::string StandardModel::FlagMw
private

A string for the model flag Mw.

Definition at line 4029 of file StandardModel.h.

◆ FlagMWinput

bool StandardModel::FlagMWinput
private

A boolean for the model flag MWinput.

Definition at line 4035 of file StandardModel.h.

◆ FlagNoApproximateGammaZ

bool StandardModel::FlagNoApproximateGammaZ
private

A boolean for the model flag NoApproximateGammaZ.

Definition at line 4028 of file StandardModel.h.

◆ FlagRhoZ

std::string StandardModel::FlagRhoZ
private

A string for the model flag RhoZ.

Definition at line 4030 of file StandardModel.h.

◆ FlagSMAux

bool StandardModel::FlagSMAux
private

A boolean for the model flag SMAux.

Definition at line 4036 of file StandardModel.h.

◆ FlagUseVud

bool StandardModel::FlagUseVud
private

A boolean for the model flag UseVud.

Definition at line 4033 of file StandardModel.h.

◆ FlagWithoutNonUniversalVC

bool StandardModel::FlagWithoutNonUniversalVC
private

A boolean for the model flag WithoutNonUniversalVC.

Definition at line 4027 of file StandardModel.h.

◆ FlagWolfenstein

bool StandardModel::FlagWolfenstein
private

A boolean for the model flag Wolfenstein.

Definition at line 4032 of file StandardModel.h.

◆ gamma

double StandardModel::gamma
protected

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

Definition at line 3469 of file StandardModel.h.

◆ GammaW_cache

double StandardModel::GammaW_cache
mutableprivate

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

Definition at line 4048 of file StandardModel.h.

◆ GeVminus2_to_nb

const double StandardModel::GeVminus2_to_nb = 389379.338
static

Definition at line 546 of file StandardModel.h.

◆ GF

double StandardModel::GF
protected

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

Definition at line 3448 of file StandardModel.h.

◆ iterationNo

int StandardModel::iterationNo
private

Definition at line 4071 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 4050 of file StandardModel.h.

◆ lambda

double StandardModel::lambda
protected

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

Definition at line 3461 of file StandardModel.h.

◆ leptons

Particle StandardModel::leptons[6]
protected

An array of Particle objects for the leptons.

Definition at line 3432 of file StandardModel.h.

◆ mHl

double StandardModel::mHl
protected

The Higgs mass \(m_h\) in GeV.

Definition at line 3451 of file StandardModel.h.

◆ muw

double StandardModel::muw
protected

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

Definition at line 3470 of file StandardModel.h.

◆ Mw_cache

double StandardModel::Mw_cache
mutableprivate

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

Definition at line 4047 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 552 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 3447 of file StandardModel.h.

◆ myApproximateFormulae

EWSMApproximateFormulae* StandardModel::myApproximateFormulae
private

A pointer to an object of type EWSMApproximateFormulae.

Definition at line 4021 of file StandardModel.h.

◆ myCKM

CKM StandardModel::myCKM
protected

An object of type CKM.

Definition at line 3433 of file StandardModel.h.

◆ myEWSMcache

EWSMcache* StandardModel::myEWSMcache
private

A pointer to an object of type EWSMcache.

Definition at line 4014 of file StandardModel.h.

◆ myLeptonFlavour

LeptonFlavour* StandardModel::myLeptonFlavour
private

A pointer to an object of the type LeptonFlavour.

Definition at line 4022 of file StandardModel.h.

◆ myOneLoopEW

EWSMOneLoopEW* StandardModel::myOneLoopEW
private

A pointer to an object of type EWSMOneLoopEW.

Definition at line 4015 of file StandardModel.h.

◆ myPMNS

PMNS StandardModel::myPMNS
protected

Definition at line 3434 of file StandardModel.h.

◆ myThreeLoopEW

EWSMThreeLoopEW* StandardModel::myThreeLoopEW
private

A pointer to an object of type EWSMThreeLoopEW.

Definition at line 4020 of file StandardModel.h.

◆ myThreeLoopEW2QCD

EWSMThreeLoopEW2QCD* StandardModel::myThreeLoopEW2QCD
private

A pointer to an object of type EWSMThreeLoopEW2QCD.

Definition at line 4019 of file StandardModel.h.

◆ myThreeLoopQCD

EWSMThreeLoopQCD* StandardModel::myThreeLoopQCD
private

A pointer to an object of type EWSMThreeLoopQCD.

Definition at line 4017 of file StandardModel.h.

◆ myTwoFermionsLEP2

EWSMTwoFermionsLEP2* StandardModel::myTwoFermionsLEP2
private

A pointer to an object of type EWSMTwoFermionsLEP2.

Definition at line 4024 of file StandardModel.h.

◆ myTwoLoopEW

EWSMTwoLoopEW* StandardModel::myTwoLoopEW
private

A pointer to an object of type EWSMTwoLoopEW.

Definition at line 4018 of file StandardModel.h.

◆ myTwoLoopQCD

EWSMTwoLoopQCD* StandardModel::myTwoLoopQCD
private

A pointer to an object of type EWSMTwoLoopQCD.

Definition at line 4016 of file StandardModel.h.

◆ Mz

double StandardModel::Mz
protected

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

Definition at line 3446 of file StandardModel.h.

◆ NSMvars

const int StandardModel::NSMvars = 26
static

The number of the model parameters in StandardModel.

Definition at line 540 of file StandardModel.h.

◆ NumSMParamsForEWPO

const int StandardModel::NumSMParamsForEWPO = 33
static

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

This constant is used for the cashing method.

See also
checkSMparamsForEWPO()

Definition at line 2100 of file StandardModel.h.

◆ realorder

orders StandardModel::realorder
mutableprivate

Definition at line 4081 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 3714 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 3715 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 3716 of file StandardModel.h.

◆ rhob

double StandardModel::rhob
protected

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

Definition at line 3463 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 4049 of file StandardModel.h.

◆ s12

double StandardModel::s12
protected

Definition at line 3471 of file StandardModel.h.

◆ s13

double StandardModel::s13
protected

Definition at line 3471 of file StandardModel.h.

◆ s23

double StandardModel::s23
protected

Definition at line 3471 of file StandardModel.h.

◆ SMFlavour

Flavour StandardModel::SMFlavour
protected

An object of type Flavour.

Definition at line 3718 of file StandardModel.h.

◆ SMM

Matching<StandardModelMatching,StandardModel> StandardModel::SMM
mutableprotected

An object of type Matching.

Definition at line 3437 of file StandardModel.h.

◆ SMparamsForEWPO_cache

double StandardModel::SMparamsForEWPO_cache[NumSMParamsForEWPO]
mutableprivate

Definition at line 4044 of file StandardModel.h.

◆ SMresult_cache

double StandardModel::SMresult_cache
mutableprivate

Definition at line 4061 of file StandardModel.h.

◆ SMSuccess

bool StandardModel::SMSuccess
mutableprivate

A boolean for the success of the Standard Model update and matching.

Definition at line 4038 of file StandardModel.h.

◆ SMvars

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

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

Definition at line 544 of file StandardModel.h.

◆ useDeltaAlpha_cache

bool StandardModel::useDeltaAlpha_cache
mutableprivate

Definition at line 4052 of file StandardModel.h.

◆ useDeltaAlphaLepton_cache

bool StandardModel::useDeltaAlphaLepton_cache
mutableprivate

Definition at line 4051 of file StandardModel.h.

◆ useGammaW_cache

bool StandardModel::useGammaW_cache
mutableprivate

Definition at line 4054 of file StandardModel.h.

◆ useKappaZ_f_cache

bool StandardModel::useKappaZ_f_cache[12]
mutableprivate

Definition at line 4056 of file StandardModel.h.

◆ useMw_cache

bool StandardModel::useMw_cache
mutableprivate

Definition at line 4053 of file StandardModel.h.

◆ useRhoZ_f_cache

bool StandardModel::useRhoZ_f_cache[12]
mutableprivate

Definition at line 4055 of file StandardModel.h.

◆ Vcb

double StandardModel::Vcb
protected

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

Definition at line 3467 of file StandardModel.h.

◆ Vub

double StandardModel::Vub
protected

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

Definition at line 3468 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 3466 of file StandardModel.h.

◆ Vus

double StandardModel::Vus
protected

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

Definition at line 3465 of file StandardModel.h.

◆ w_GSL1

gsl_integration_workspace* StandardModel::w_GSL1
private

GSL integral variable

Definition at line 4068 of file StandardModel.h.

◆ Yd

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

The Yukawa matrix of the down-type quarks.

Definition at line 3439 of file StandardModel.h.

◆ Ye

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

The Yukawa matrix of the charged leptons.

Definition at line 3441 of file StandardModel.h.

◆ Yn

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

The Yukawa matrix of the neutrinos.

Definition at line 3440 of file StandardModel.h.

◆ Yu

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

The Yukawa matrix of the up-type quarks.

Definition at line 3438 of file StandardModel.h.


The documentation for this class was generated from the following files: