a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
Public Member Functions | Private Member Functions | Private Attributes | List of all members
EWSMApproximateFormulae Class Reference
StandardModel

A class for approximate formulae of the EW precision observables. More...

#include <EWSMApproximateFormulae.h>

Detailed Description

A class for approximate formulae of the EW precision observables.

Author
HEPfit Collaboration
Copyright
GNU General Public License

The member functions in the current class compute the EW precision observables \(M_W\), \(\sin\theta_{\rm eff}^f\), \(\Gamma_f\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\) \(R^0_c\) and \(R^0_b\), based on the approximate formulae given in [22], [24], [25], [23], [123], [124] and [125]. (The actual implementation for \(M_W\) corresponds to arXiv:hep-ph/0311148v2, which updates the results presented in the journal version of [22].) The maximal deviations to the full results and the valid ranges of input parameters are summarized in the description of each function.

Definition at line 33 of file EWSMApproximateFormulae.h.

Public Member Functions

double DeltaKappa_b_TwoLoopEW_rem (const double Mw_i) const
 \(\Delta\kappa_Z^{b, (\alpha^2)}\). More...
 
double DeltaKappa_l_TwoLoopEW_rem (const double Mw_i) const
 \(\Delta\kappa_Z^{\ell, (\alpha^2)}\). More...
 
double DeltaR_TwoLoopEW_rem (const double Mw_i) const
 \(\Delta r_{\rm rem}^{(\alpha^2)}\). More...
 
 EWSMApproximateFormulae (const EWSMcache &cache_i)
 Constructor. More...
 
double Gd_over_Gb_OLD () const
 \(\Gamma_d/\Gamma_b\). More...
 
double Gu_over_Gb_OLD () const
 \(\Gamma_u/\Gamma_b\). More...
 
double Mw () const
 The \(W\)-boson mass with the full two-loop EW corrections. More...
 
double R0_bottom_OLD () const
 \(R_b^0\). More...
 
double sin2thetaEff (const Particle p) const
 
double sin2thetaEff_b_full () const
 \(\sin^2\theta_{\rm eff}^b\) with the full two-loop EW corrections. More...
 
double sin2thetaEff_l_full () const
 \(\sin^2\theta_{\rm eff}^l\) with the full two-loop EW corrections. More...
 
double X (const std::string observable) const
 \(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\). More...
 
double X_extended (const std::string observable) const
 \(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\). More...
 
double X_full (const std::string observable) const
 \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_\nu\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\). More...
 
double X_full_2_loop (const std::string observable) const
 \(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\). More...
 

Private Member Functions

double sin2thetaEff_b () const
 \(\sin^2\theta_{\rm eff}^b\) with the full two-loop EW corrections. More...
 
double sin2thetaEff_l (const QCD::lepton l) const
 \(\sin^2\theta_{\rm eff}^\ell\) with the full two-loop EW corrections. More...
 
double sin2thetaEff_q (const QCD::quark q) const
 \(\sin^2\theta_{\rm eff}^q\) with the full two-loop EW corrections (bosonic two-loop EW corrections are missing for \(q=b\)). More...
 

Private Attributes

const EWSMcache & mycache
 A reference to an object of type StandardModel. More...
 

Constructor & Destructor Documentation

◆ EWSMApproximateFormulae()

EWSMApproximateFormulae::EWSMApproximateFormulae ( const EWSMcache &  cache_i)

Constructor.

Parameters
[in]cache_ia reference to an object of type EWSMcache

Definition at line 15 of file EWSMApproximateFormulae.cpp.

16 : mycache(cache_i)
17 {
18 }

Member Function Documentation

◆ DeltaKappa_b_TwoLoopEW_rem()

double EWSMApproximateFormulae::DeltaKappa_b_TwoLoopEW_rem ( const double  Mw_i) const

\(\Delta\kappa_Z^{b, (\alpha^2)}\).

This function is based on the approximate formula for the irreducible EW two-loop contribution to \(\Delta\kappa_Z^b = \kappa_Z^b - 1\) presented in [23], which includes the complete fermionic two-loop EW corrections as well as leading three-loop corrections. The bosonic two-loop EW corrections are not included. The approximate formula reproduces the full result to be better than \(1.4\times 10^{-5}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.119\pm 0.002\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05907\pm 0.00036\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 172.5\pm 2.3\) GeV.

Parameters
[in]Mw_ithe \(W\)-boson mass
Returns
irreducible fermionic two-loop EW contribution to \(\Delta\kappa_Z^b\)

Definition at line 321 of file EWSMApproximateFormulae.cpp.

322 {
323  // applicable for 10 GeV <= mHl <= 1 TeV
324  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
325  std::stringstream out;
326  out << mycache.getSM().getMHl();
327  throw std::runtime_error("ApproximateFormulae::DeltaKappa_b_TwoLoopEW_rem(): mh=" + out.str() + " is out of range");
328  }
329 
330  double k0 = -0.002666;
331  double k1 = -0.0000592;
332  double k2 = -0.00000329;
333  double k3 = 0.00000349;
334  double k4 = 0.00000283;
335  double k5 = -0.00534;
336  double k6 = -0.00210;
337  double k7 = -0.000219;
338  double k8 = -0.0631;
339  double k9 = -0.126;
340  double k10 = 0.0647;
341 
342  double L_H = log(mycache.getSM().getMHl() / 100.0);
343  double Delta_H = mycache.getSM().getMHl() / 100.0;
344  double Delta_t = pow((mycache.getSM().getMtpole() / 178.0), 2.0) - 1.0;
345  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
346  double Delta_W = Mw_i / 80.404 - 1.0;
347 
348  return ( k0 + k1 * L_H + k2 * L_H * L_H + k3 * pow(L_H, 4.0)
349  + k4 * (Delta_H * Delta_H - 1.0) + k5 * Delta_t
350  + k6 * Delta_t * Delta_t + k7 * Delta_t * L_H
351  + k8 * Delta_W + k9 * Delta_W * Delta_t + k10 * Delta_Z);
352 }

◆ DeltaKappa_l_TwoLoopEW_rem()

double EWSMApproximateFormulae::DeltaKappa_l_TwoLoopEW_rem ( const double  Mw_i) const

\(\Delta\kappa_Z^{\ell, (\alpha^2)}\).

This function is based on the approximate formula for the irreducible EW two-loop contribution to \(\Delta\kappa_Z^\ell = \kappa_Z^\ell - 1\) presented in [25], which includes the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formula reproduces the full result to be better than \(1.8\times 10^{-5}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.119\pm 0.002\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05907\pm 0.00036\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 172.5\pm 2.3\) GeV.

Parameters
[in]Mw_ithe \(W\)-boson mass
Returns
irreducible two-loop EW contribution to \(\Delta\kappa_Z^\ell\)

Definition at line 288 of file EWSMApproximateFormulae.cpp.

289 {
290  // applicable for 10 GeV <= mHl <= 1 TeV
291  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
292  std::stringstream out;
293  out << mycache.getSM().getMHl();
294  throw std::runtime_error("ApproximateFormulae::DeltaKappa_l_TwoLoopEW_rem(): mh=" + out.str() + " is out of range");
295  }
296 
297  double k0 = -0.002711;
298  double k1 = -0.0000312;
299  double k2 = -0.0000412;
300  double k3 = 0.00000528;
301  double k4 = 0.00000375;
302  double k5 = -0.00516;
303  double k6 = -0.00206;
304  double k7 = -0.000232;
305  double k8 = -0.0647;
306  double k9 = -0.129;
307  double k10 = 0.0712;
308 
309  double L_H = log(mycache.getSM().getMHl() / 100.0);
310  double Delta_H = mycache.getSM().getMHl() / 100.0;
311  double Delta_t = pow((mycache.getSM().getMtpole() / 178.0), 2.0) - 1.0;
312  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
313  double Delta_W = Mw_i / 80.404 - 1.0;
314 
315  return ( k0 + k1 * L_H + k2 * L_H * L_H + k3 * pow(L_H, 4.0)
316  + k4 * (Delta_H * Delta_H - 1.0) + k5 * Delta_t
317  + k6 * Delta_t * Delta_t + k7 * Delta_t * L_H
318  + k8 * Delta_W + k9 * Delta_W * Delta_t + k10 * Delta_Z);
319 }

◆ DeltaR_TwoLoopEW_rem()

double EWSMApproximateFormulae::DeltaR_TwoLoopEW_rem ( const double  Mw_i) const

\(\Delta r_{\rm rem}^{(\alpha^2)}\).

This function is based on the approximate formula for the irreducible EW two-loop contribution to \(\Delta r\) presented in [25], which includes the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formula reproduces the full result to be better than \(2.7\times 10^{-5}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.119\pm 0.002\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05907\pm 0.00036\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 172.5\pm 2.3\) GeV.

Parameters
[in]Mw_ithe \(W\)-boson mass
Returns
irreducible two-loop EW contribution to \(\Delta r\)

Definition at line 252 of file EWSMApproximateFormulae.cpp.

253 {
254  // applicable for 10 GeV <= mHl <= 1 TeV
255  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
256  std::stringstream out;
257  out << mycache.getSM().getMHl();
258  throw std::runtime_error("ApproximateFormulae::DeltaR_TwoLoopEW_rem(): mh=" + out.str() + " is out of range");
259  }
260 
261  double r0 = 0.003354;
262  double r1 = -0.000209;
263  double r2 = 0.0000254;
264  double r3 = -0.00000785;
265  double r4 = -0.00000233;
266  double r5 = 0.00783;
267  double r6 = 0.00338;
268  double r7 = -0.00000989;
269  double r8 = 0.0939;
270  double r9 = 0.204;
271  double r10 = -0.103;
272 
273  //double Mw = Mw(DeltaAlphaL5q_i); /* for test */
274  double Mw = Mw_i;
275 
276  double L_H = log(mycache.getSM().getMHl() / 100.0);
277  double Delta_H = mycache.getSM().getMHl() / 100.0;
278  double Delta_t = pow((mycache.getSM().getMtpole() / 178.0), 2.0) - 1.0;
279  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
280  double Delta_W = Mw / 80.404 - 1.0;
281 
282  return ( r0 + r1 * L_H + r2 * L_H * L_H + r3 * pow(L_H, 4.0)
283  + r4 * (Delta_H * Delta_H - 1.0) + r5 * Delta_t
284  + r6 * Delta_t * Delta_t + r7 * Delta_t * L_H + r8 * Delta_W
285  + r9 * Delta_W * Delta_t + r10 * Delta_Z);
286 }

◆ Gd_over_Gb_OLD()

double EWSMApproximateFormulae::Gd_over_Gb_OLD ( ) const

\(\Gamma_d/\Gamma_b\).

This function is based on the approximate formula for the ratio \(\Gamma_d/\Gamma_b\) obtained from A. Freitas in private communication on Sep. 21, 2013, which includes the complete fermionic two-loop EW corrections as well as leading three-loop corrections. The bosonic two-loop EW corrections are not included. The approximate formula reproduces the full result to be better than \(3.0\times 10^{-6}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.1184\pm 0.0007\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05900\pm 0.00033\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 173.2\pm 0.9\) GeV.

Returns
\(\Gamma_d/\Gamma_b\)

Definition at line 511 of file EWSMApproximateFormulae.cpp.

512 {
513  // applicable for 10 GeV <= mHl <= 1 TeV
514  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
515  std::stringstream out;
516  out << mycache.getSM().getMHl();
517  throw std::runtime_error("ApproximateFormulae::Gd_over_Gb(): mh=" + out.str() + " is out of range");
518  }
519 
520  // obtained from Freitas on Apr. 23, 2013
521  /*
522  double R = 1.0239191;
523  double c1 = -5.093e-5;
524  double c2 = -7.08e-6;
525  double c3 = 7.4e-7;
526  double c4 = 3.27e-8;
527  double c5 = 8.68e-4;
528  double c6 = 1.064e-4;
529  double c7 = 1.8875e-2;
530  double c8 = 7.093e-3;
531  double c9 = -4.128e-4;
532  double c10 = 1.898e-4;
533  double c11 = -8.0e-6;
534  double c12 = -0.513;
535  */
536 
537  // obtained from Freitas on Sep. 21, 2013
538  double R = 1.0204024;
539  double c1 = -2.242e-5;
540  double c2 = -1.70e-6;
541  double c3 = 2.1e-7;
542  double c4 = 6.38e-8;
543  double c5 = 5.28e-4;
544  double c6 = 0.999e-4;
545  double c7 = 1.7539e-2;
546  double c8 = 7.138e-3;
547  double c9 = -4.041e-4;
548  double c10 = 2.290e-4;
549  double c11 = -8.0e-6;
550  double c12 = -0.530;
551 
552  double LH = log(mycache.getSM().getMHl() / 100.0);
553  double DH = pow((mycache.getSM().getMHl() / 100.0), 2.0) - 1.0;
554  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
555  double Dt = pow((mycache.getSM().getMtpole() / 173.2), 2.0) - 1.0;
556  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
557  double Dmz = mycache.getSM().getMz() / 91.1876 - 1.0;
558 
559  return ( R + c1 * LH + c2 * LH * LH + c3 * pow(LH, 4.0) + c4 * DH + c5 * Dal + c6 * LH * Dal
560  + c7 * Dt + c8 * Dt * Dt + c9 * LH * Dt + c10 * Das + c11 * Das * Das + c12 * Dmz);
561 }

◆ Gu_over_Gb_OLD()

double EWSMApproximateFormulae::Gu_over_Gb_OLD ( ) const

\(\Gamma_u/\Gamma_b\).

This function is based on the approximate formula for the ratio \(\Gamma_u/\Gamma_b\) obtained from A. Freitas in private communication on Sep. 21, 2013, which includes the complete fermionic two-loop EW corrections as well as leading three-loop corrections. The bosonic two-loop EW corrections are not included. The approximate formula reproduces the full result to be better than \(3.3\times 10^{-6}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.1184\pm 0.0007\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05900\pm 0.00033\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 173.2\pm 0.9\) GeV.

Returns
\(\Gamma_u/\Gamma_b\)

Definition at line 459 of file EWSMApproximateFormulae.cpp.

460 {
461  // applicable for 10 GeV <= mHl <= 1 TeV
462  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
463  std::stringstream out;
464  out << mycache.getSM().getMHl();
465  throw std::runtime_error("ApproximateFormulae::Gu_over_Gb(): mh=" + out.str() + " is out of range");
466  }
467 
468  // obtained from Freitas on Apr. 23, 2013
469  /*
470  double R = 0.8024769;
471  double c1 = -1.9007e-4;
472  double c2 = -2.112e-5;
473  double c3 = 6.63e-6;
474  double c4 = -1.0284e-6;
475  double c5 = -8.081e-3;
476  double c6 = 1.830e-4;
477  double c7 = 1.7522e-2;
478  double c8 = 4.440e-3;
479  double c9 = -3.245e-4;
480  double c10 = 1.8079e-2;
481  double c11 = 1.0720e-2;
482  double c12 = -0.129;
483  */
484 
485  // obtained from Freitas on Sep. 21, 2013
486  double R = 0.7997930;
487  double c1 = -1.7991e-4;
488  double c2 = -1.980e-5;
489  double c3 = 6.24e-6;
490  double c4 = -0.9829e-6;
491  double c5 = -8.200e-3;
492  double c6 = 1.657e-4;
493  double c7 = 1.6476e-2;
494  double c8 = 4.463e-3;
495  double c9 = -3.187e-4;
496  double c10 = 1.8113e-2;
497  double c11 = 1.0720e-2;
498  double c12 = -0.144;
499 
500  double LH = log(mycache.getSM().getMHl() / 100.0);
501  double DH = pow((mycache.getSM().getMHl() / 100.0), 2.0) - 1.0;
502  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
503  double Dt = pow((mycache.getSM().getMtpole() / 173.2), 2.0) - 1.0;
504  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
505  double Dmz = mycache.getSM().getMz() / 91.1876 - 1.0;
506 
507  return ( R + c1 * LH + c2 * LH * LH + c3 * pow(LH, 4.0) + c4 * DH + c5 * Dal + c6 * LH * Dal
508  + c7 * Dt + c8 * Dt * Dt + c9 * LH * Dt + c10 * Das + c11 * Das * Das + c12 * Dmz);
509 }

◆ Mw()

double EWSMApproximateFormulae::Mw ( ) const

The \(W\)-boson mass with the full two-loop EW corrections.

This function is based on the approximate formula for \(M_W\) presented in [22], which includes the complete two-loop EW corrections as well as leading three-loop corrections, and the four-loop corrections to the rho parameter. (The four-loop effects are not included in the results presented in the journal version of [22]. The parametrization used here corresponds to the results in arXiv:hep-ph/0311148v2, which updates the the ones presented in the published version.) The approximate formula reproduces the full result to be better than 0.5 (0.25) MeV over the range of 10 GeV \(\leq m_h\leq\) 1 TeV (100 GeV \(\leq m_h \leq\) 1 TeV), if other inputs vary within their \(2\sigma\) ranges of the 2003 data, where their \(1\sigma\) ranges are given by \(\alpha_s = 0.1190\pm 0.0027\), \(\Delta\alpha^{\ell+5q} = 0.05907\pm 0.00036\), \(M_Z = 91.1875\pm 0.0021\) GeV, and \(m_t = 174.3\pm 5.1\) GeV.

Returns
the \(W\)-boson mass in units of GeV

Definition at line 23 of file EWSMApproximateFormulae.cpp.

24 {
25  // Parametrization from arXiv:hep-ph/0311148v2 (updates from the journal version)
26  double Mw0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11;
27  if (mycache.getSM().getMHl() >= 100.0 && mycache.getSM().getMHl() <= UpperBoundForApproximateFormulae) {
28  // applicable for 100 GeV <= mHl <= 1 TeV
29  Mw0 = 80.3779;
30  c1 = 0.05263;
31  c2 = 0.010239;
32  c3 = 0.000954;
33  c4 = -0.000054;
34  c5 = 1.077;
35  c6 = 0.5252;
36  c7 = 0.0700;
37  c8 = 0.004102;
38  c9 = 0.000111;
39  c10 = 0.0774;
40  c11 = 115.0;
41  } else if (mycache.getSM().getMHl() >= 10.0 && mycache.getSM().getMHl() <= 1000.0) {
42  // applicable for 10 GeV <= mHl <= 1 TeV
43  Mw0 = 80.3799;
44  c1 = 0.05427;
45  c2 = 0.008931;
46  c3 = 0.0000882;
47  c4 = 0.000161;
48  c5 = 1.070;
49  c6 = 0.5237;
50  c7 = 0.0679;
51  c8 = 0.00179;
52  c9 = 0.0000664;
53  c10 = 0.0795;
54  c11 = 114.9;
55  } else {
56  std::stringstream out;
57  out << mycache.getSM().getMHl();
58  throw std::runtime_error("ApproximateFormulae::Mw(): mh=" + out.str() + " is out of range");
59  }
60 
61  double dH = log(mycache.getSM().getMHl() / 100.0);
62  double dh = pow((mycache.getSM().getMHl() / 100.0), 2.0);
63  double dt = pow((mycache.getSM().getMtpole() / 174.3), 2.0) - 1.0;
64  double dZ = mycache.getSM().getMz() / 91.1875 - 1.0;
65  double dalphae = mycache.getSM().DeltaAlphaL5q() / 0.05907 - 1.0;
66  double dalphas = mycache.getSM().getAlsMz() / 0.119 - 1.0;
67 
68  return (Mw0 - c1 * dH - c2 * dH * dH + c3 * pow(dH, 4.0)
69  + c4 * (dh - 1.0) - c5 * dalphae + c6 * dt - c7 * dt * dt
70  - c8 * dH * dt + c9 * dh * dt - c10 * dalphas + c11 * dZ
71  + mycache.getSM().getDelMw());
72 }

◆ R0_bottom_OLD()

double EWSMApproximateFormulae::R0_bottom_OLD ( ) const

\(R_b^0\).

This function is based on the approximate formula for \(R_b^0=\Gamma_b/\Gamma_h\) presented in [123], which includes the complete fermionic two-loop EW corrections as well as leading three-loop corrections. The bosonic two-loop EW corrections are not included. The approximate formula reproduces the full result to be better than \(10^{-6}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.1184\pm 0.0007\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05900\pm 0.00033\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 173.2\pm 0.9\) GeV.

Returns
\(R_b^0=\Gamma_b/\Gamma_h\)

Definition at line 354 of file EWSMApproximateFormulae.cpp.

355 {
356  // applicable for 10 GeV <= mHl <= 1 TeV
357  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
358  std::stringstream out;
359  out << mycache.getSM().getMHl();
360  throw std::runtime_error("ApproximateFormulae::R0_bottom(): mh=" + out.str() + " is out of range");
361  }
362 
363  /*-----------------------------------------------*/
364  /* arXiv:1205.0299v1 by Freitas and Huang */
365  /*
366  double Rb00 = 0.2147464;
367  double c1 = 0.0000221;
368  double c2 = 0.0000026;
369  double c3 = -0.00000067;
370  double c4 = 0.0000000911;
371  double c5 = 0.000647;
372  double c6 = -0.003239;
373  double c7 = 0.0000673;
374  double c8 = -0.000324;
375  double c9 = 0.0610;
376 
377  double L_H = log(mycache.getSM().getMHl()/100.0);
378  double Delta_H = mycache.getSM().getMHl()/100.0;
379  double Delta_ale = mycache.getSM().mycache.getSM().DeltaAlphaL5q()/0.05900 - 1.0;
380  double Delta_t = pow((mycache.getSM().getMtpole()/173.2), 2.0) - 1.0;
381  double Delta_alphas = mycache.getSM().getAlsMz()/0.1184 - 1.0;
382  double Delta_Z = mycache.getSM().getMz()/91.1876 - 1.0;
383 
384  return (Rb00 + c1*L_H + c2*L_H*L_H + c3*pow(L_H, 4.0)
385  + c4*(Delta_H*Delta_H - 1.0) + c5*Delta_ale + c6*Delta_t
386  + c7*Delta_t*L_H + c8*Delta_alphas + c9*Delta_Z );
387  */
388 
389  /*-----------------------------------------------*/
390  /* arXiv:1205.0299v2 by Freitas and Huang */
391  /*
392  double Rb00 = 0.2149246;
393  double c1 = 2.23 * pow(10.0, -5.);
394  double c2 = 2.6 * pow(10.0, -6.);
395  double c3 = -6.8 * pow(10.0, -7.);
396  double c4 = 9.19 *pow(10.0, -8.);
397  double c5 = 6.58 * pow(10.0, -4.);
398  double c6 = -3.363 * pow(10.0, -3.);
399  double c7 = 6.74 * pow(10.0, -5.);
400  double c8 = -1.688 * pow(10.0, -3.);
401  double c9 = -9.26 * pow(10.0, -4.);
402  double c10 = 5.93 * pow(10.0, -2.);
403 
404  double L_H = log(mycache.getSM().getMHl()/100.0);
405  double Delta_H = mycache.getSM().getMHl()/100.0;
406  double Delta_ale = mycache.getSM().mycache.getSM().DeltaAlphaL5q()/0.05900 - 1.0;
407  double Delta_t = pow((mycache.getSM().getMtpole()/173.2), 2.0) - 1.0;
408  double Delta_alphas = mycache.getSM().getAlsMz()/0.1184 - 1.0;
409  double Delta_Z = mycache.getSM().getMz()/91.1876 - 1.0;
410 
411  return (Rb00 + c1*L_H + c2*L_H*L_H + c3*pow(L_H, 4.0)
412  + c4*(Delta_H*Delta_H - 1.0) + c5*Delta_ale + c6*Delta_t
413  + c7*Delta_t*L_H + c8*Delta_alphas + c9*Delta_alphas*Delta_alphas
414  + c10*Delta_Z );
415  */
416 
417  /*-----------------------------------------------*/
418  /* arXiv:1205.0299v3 by Freitas and Huang */
419 
420  double Rb00 = 0.2154940;
421  double c1 = 1.88 * pow(10.0, -5.);
422  double c2 = 2.0 * pow(10.0, -6.);
423  double c3 = -6.0 * pow(10.0, -7.);
424  double c4 = 8.53 * pow(10.0, -8.);
425  double c5 = 7.05 * pow(10.0, -4.);
426  double c6 = -3.159 * pow(10.0, -3.);
427  double c7 = 6.65 * pow(10.0, -5.);
428  double c8 = -1.704 * pow(10.0, -3.);
429  double c9 = -9.30 * pow(10.0, -4.);
430  double c10 = 6.26 * pow(10.0, -2.);
431 
432  double L_H = log(mycache.getSM().getMHl() / 100.0);
433  double Delta_H = mycache.getSM().getMHl() / 100.0;
434  double Delta_ale = mycache.getSM().DeltaAlphaL5q() / 0.05900 - 1.0;
435  double Delta_t = pow((mycache.getSM().getMtpole() / 173.2), 2.0) - 1.0;
436  double Delta_alphas = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
437  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
438 
439  /* Debug (parameters in arXiv:1205.0299v3) */
440  //double mHpaper = 100.0;
441  //double mHpaper = 200.0;
442  //double mHpaper = 400.0;
443  //double mHpaper = 600.0;
444  //double mHpaper = 1000.0;
445  //L_H = log(mHpaper/100.0);
446  //Delta_H = mHpaper/100.0;
447  //Delta_ale = 0.0;//0.05900/0.05900 - 1.0;
448  //Delta_t = 0.0;//pow((173.2/173.2), 2.0) - 1.0;
449  //Delta_alphas = 0.0;//0.1184/0.1184 - 1.0;
450  //Delta_Z = 0.0;//91.1876/91.1876 - 1.0;
451 
452  return (Rb00 + c1 * L_H + c2 * L_H * L_H + c3 * pow(L_H, 4.0)
453  + c4 * (Delta_H * Delta_H - 1.0) + c5 * Delta_ale + c6 * Delta_t
454  + c7 * Delta_t * L_H + c8 * Delta_alphas + c9 * Delta_alphas * Delta_alphas
455  + c10 * Delta_Z);
456 
457 }

◆ sin2thetaEff()

double EWSMApproximateFormulae::sin2thetaEff ( const Particle  p) const
inline

Definition at line 68 of file EWSMApproximateFormulae.h.

69  {
70  if (p.is("QUARK"))
71  return sin2thetaEff_q((QCD::quark) (p.getIndex() - 6));
72  else if (p.is("LEPTON"))
73  return sin2thetaEff_l((QCD::lepton) p.getIndex());
74  else
75  throw std::runtime_error("EWSMApproximateFormulae::sin2thetaEff() called with wrong argument");
76  }

◆ sin2thetaEff_b()

double EWSMApproximateFormulae::sin2thetaEff_b ( ) const
private

\(\sin^2\theta_{\rm eff}^b\) with the full two-loop EW corrections.

This function is based on the approximate formulae for the weak mixing angle presented in [arXiv:1607.08375 hep-ph] (add citation), which include the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formulae reproduce the full results with average and maximal deviations of \(2\times 10^{-7}\) and \(1.3\times 10^{-6}\), respectively, for the input parameters in the following ranges: \(m_h = 125.1 \pm 5\) GeV, \(\alpha_s(M_Z^2) = 0.1184\pm 0.005\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.059\pm 0.0005\), \(M_Z = 91.1876\pm 0.0042\) GeV and \(m_t = 173.2\pm 4.0\) GeV.

Returns
the effective weak mixing angle for \(Z\to b\bar{b}\)

Definition at line 216 of file EWSMApproximateFormulae.cpp.

217 {
218  // applicable for 120.1 GeV <= mHl <= 130.1 GeV
219  if (mycache.getSM().getMHl() < 120.1 || mycache.getSM().getMHl() > 130.1) {
220  std::stringstream out;
221  out << mycache.getSM().getMHl();
222  throw std::runtime_error("ApproximateFormulae::sin2thetaEff_b(): mh=" + out.str() + " is out of range");
223  }
224 
225  double s0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
226 
227  s0 = 0.232704;
228  d1 = 4.723 * 0.0001;
229  d2 = 1.97 * 0.0001;
230  d3 = 2.07 * 0.01;
231  d4 = -9.733 * 0.0001;
232  d5 = 3.93 * 0.0001;
233  d6 = -1.38 * 0.0001;
234  d7 = 2.42 * 0.0001;
235  d8 = -8.10 * 0.0001;
236  d9 = -0.664;
237 
238  double L_H = log(mycache.getSM().getMHl() / 125.7);
239  double Delta_ale = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
240  double Delta_t = pow((mycache.getSM().getMtpole() / 173.2), 2.0) - 1.0;
241  double Delta_alphas = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
242  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
243 
244  return (s0 + d1 * L_H + d2 * L_H * L_H
245  + d3 * Delta_ale
246  + d4 * Delta_t + d5 * Delta_t * Delta_t + d6 * Delta_t * L_H
247  + d7 * Delta_alphas + d8 * Delta_t * Delta_alphas
248  + d9 * Delta_Z
249  + mycache.getSM().getDelSin2th_b());
250 }

◆ sin2thetaEff_b_full()

double EWSMApproximateFormulae::sin2thetaEff_b_full ( ) const

\(\sin^2\theta_{\rm eff}^b\) with the full two-loop EW corrections.

This function is based on the approximate formulae for presented in arXiv: 1906.08815, which include the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formulae reproduce the full results to be better than 0.0025 * 10^-4, if inputs vary within the ranges \(\alpha_s(M_Z^2) = 0.1184\pm 0.0050\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.0590\pm 0.0005\), \(M_Z = 91.1876\pm 0.0084\) GeV, \(155 < m_t < 192\) GeV and \(25 < m_h < 225\) GeV.

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

Definition at line 1481 of file EWSMApproximateFormulae.cpp.

1482 {
1483  // applicable for 25 GeV <= mHl <= 225 GeV. Remove boundaries for the moment
1484  //if (mycache.getSM().getMHl() < 25.0 || mycache.getSM().getMHl() > 225.0) {
1485  // std::stringstream out;
1486  // out << mycache.getSM().getMHl();
1487  // throw std::runtime_error("ApproximateFormulae::sin2thetaEff_b_full(): mh=" + out.str() + " is out of range");
1488  //}
1489 
1490 // Full 2-loop implementation
1491 
1492  double LH = log(mycache.getSM().getMHl() / 125.7);
1493 
1494  double LH2 = LH * LH;
1495 
1496  double Dt = pow(mycache.getSM().getMtpole() / 173.2, 2.0) - 1.0;
1497 
1498  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
1499 
1500  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
1501 
1502  double DZ = mycache.getSM().getMz() / 91.1876 - 1.0;
1503 
1504  double X0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
1505 
1506  double ThError = 0.0; // Theoretical uncertainty
1507 
1508  X0 = 2327.04;
1509  d1 = 4.638;
1510  d2 = 0.558;
1511  d3 = -0.0700;
1512  d4 = 207.0;
1513  d5 = -9.554;
1514  d6 = 3.83;
1515  d7 = 0.179;
1516  d8 = 2.41;
1517  d9 = -8.24;
1518  d10 = -6630.0;
1519 
1520  ThError = mycache.getSM().getDelSin2th_b();
1521 
1522  return ( 0.0001*( X0 + d1 * LH + d2 * LH2 + d3 * LH2 * LH2
1523  + d4 * Dal
1524  + d5 * Dt + d6 * Dt * Dt
1525  + d7 * Dt * LH
1526  + d8 * Das + d9 * Das * Dt
1527  + d10 * DZ ) + ThError);
1528 }

◆ sin2thetaEff_l()

double EWSMApproximateFormulae::sin2thetaEff_l ( const QCD::lepton  l) const
private

\(\sin^2\theta_{\rm eff}^\ell\) with the full two-loop EW corrections.

This function is based on the approximate formulae for the leptonic weak mixing angles presented in [25] (see also [24]), which include the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formulae reproduce the full results to be better than \(4.5\times 10^{-6}\) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV, if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.119\pm 0.002\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05907\pm 0.00036\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 172.5\pm 2.3\) GeV.

Parameters
[in]lname of a lepton (see QCD::lepton)
Returns
the effective weak mixing angle for \(Z\to\ell\bar{\ell}\)

Definition at line 74 of file EWSMApproximateFormulae.cpp.

75 {
76  // applicable for 10 GeV <= mHl <= 1 TeV
77  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
78  std::stringstream out;
79  out << mycache.getSM().getMHl();
80  throw std::runtime_error("ApproximateFormulae::sin2thetaEff_l(): mh=" + out.str() + " is out of range");
81  }
82 
83  double s0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
84  switch (l) {
85  case StandardModel::NEUTRINO_1:
86  case StandardModel::NEUTRINO_2:
87  case StandardModel::NEUTRINO_3:
88  s0 = 0.2308772;
89  d1 = 4.713 * 0.0001;
90  d2 = 2.05 * 0.00001;
91  d3 = 3.85 * 0.000001;
92  d4 = -1.85 * 0.000001;
93  d5 = 2.06 * 0.01;
94  d6 = -2.850 * 0.001;
95  d7 = 1.82 * 0.0001;
96  d8 = -9.71 * 0.000001;
97  d9 = 3.96 * 0.0001;
98  d10 = -6.54 * 0.1;
99  break;
100  case StandardModel::ELECTRON:
101  case StandardModel::MU:
102  case StandardModel::TAU:
103  s0 = 0.2312527;
104  d1 = 4.729 * 0.0001;
105  d2 = 2.07 * 0.00001;
106  d3 = 3.85 * 0.000001;
107  d4 = -1.85 * 0.000001;
108  d5 = 2.07 * 0.01;
109  d6 = -2.851 * 0.001;
110  d7 = 1.82 * 0.0001;
111  d8 = -9.74 * 0.000001;
112  d9 = 3.98 * 0.0001;
113  d10 = -6.55 * 0.1;
114  break;
115  default:
116  throw std::runtime_error("Error in ApproximateFormulae::sin2thetaEff_l()");
117  }
118 
119  double L_H = log(mycache.getSM().getMHl() / 100.0);
120  double Delta_H = mycache.getSM().getMHl() / 100.0;
121  double Delta_ale = mycache.getSM().DeltaAlphaL5q() / 0.05907 - 1.0;
122  double Delta_t = pow((mycache.getSM().getMtpole() / 178.0), 2.0) - 1.0;
123  double Delta_alphas = mycache.getSM().getAlsMz() / 0.117 - 1.0;
124  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
125 
126  return (s0 + d1 * L_H + d2 * L_H * L_H + d3 * pow(L_H, 4.0)
127  + d4 * (Delta_H * Delta_H - 1.0) + d5 * Delta_ale + d6 * Delta_t
128  + d7 * Delta_t * Delta_t + d8 * Delta_t * (Delta_H - 1.0)
129  + d9 * Delta_alphas + d10 * Delta_Z
130  + mycache.getSM().getDelSin2th_l());
131 }

◆ sin2thetaEff_l_full()

double EWSMApproximateFormulae::sin2thetaEff_l_full ( ) const

\(\sin^2\theta_{\rm eff}^l\) with the full two-loop EW corrections.

This function is based on the approximate formulae for presented in arXiv: 1906.08815, which include the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formulae reproduce the full results to be better than 0.0056 * 10^-4, if inputs vary within the ranges \(\alpha_s(M_Z^2) = 0.1184\pm 0.0050\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.0590\pm 0.0005\), \(M_Z = 91.1876\pm 0.0084\) GeV, \(155 < m_t < 192\) GeV and \(25 < m_h < 225\) GeV.

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

Definition at line 1531 of file EWSMApproximateFormulae.cpp.

1532 {
1533  // applicable for 25 GeV <= mHl <= 225 GeV. Remove boundaries for the moment
1534  //if (mycache.getSM().getMHl() < 25.0 || mycache.getSM().getMHl() > 225.0) {
1535  // std::stringstream out;
1536  // out << mycache.getSM().getMHl();
1537  // throw std::runtime_error("ApproximateFormulae::sin2thetaEff_l_full(): mh=" + out.str() + " is out of range");
1538  //}
1539 
1540 // Full 2-loop implementation
1541 
1542  double LH = log(mycache.getSM().getMHl() / 125.7);
1543 
1544  double LH2 = LH * LH;
1545 
1546  double Dt = pow(mycache.getSM().getMtpole() / 173.2, 2.0) - 1.0;
1547 
1548  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
1549 
1550  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
1551 
1552  double DZ = mycache.getSM().getMz() / 91.1876 - 1.0;
1553 
1554  double X0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
1555 
1556  double ThError = 0.0; // Theoretical uncertainty
1557 
1558  X0 = 2314.64;
1559  d1 = 4.616;
1560  d2 = 0.539;
1561  d3 = -0.0737;
1562  d4 = 206.0;
1563  d5 = -25.71;
1564  d6 = 4.00;
1565  d7 = 0.288;
1566  d8 = 3.88;
1567  d9 = -6.49;
1568  d10 = -6560.0;
1569 
1570  ThError = mycache.getSM().getDelSin2th_l();
1571 
1572  return ( 0.0001*( X0 + d1 * LH + d2 * LH2 + d3 * LH2 * LH2
1573  + d4 * Dal
1574  + d5 * Dt + d6 * Dt * Dt
1575  + d7 * Dt * LH
1576  + d8 * Das + d9 * Das * Dt
1577  + d10 * DZ ) + ThError);
1578 }

◆ sin2thetaEff_q()

double EWSMApproximateFormulae::sin2thetaEff_q ( const QCD::quark  q) const
private

\(\sin^2\theta_{\rm eff}^q\) with the full two-loop EW corrections (bosonic two-loop EW corrections are missing for \(q=b\)).

This function is based on the approximate formulae for the weak mixing angles presented in [25] and [23], which include the complete two-loop EW corrections as well as leading three-loop corrections. It is noted that bosonic two-loop EW corrections are missing for \(q=b\). The approximate formulae reproduce the full results to be better than \(4.5\times 10^{-6}\) ( \(4.3\times 10^{-6}\)) for the Higgs mass 10 GeV \(\leq m_h\leq\) 1 TeV in the case of \(q=u,d,s,c\) ( \(q=b\)), if other inputs vary within their \(2\sigma\) ranges of the following outdated data: \(\alpha_s(M_Z^2) = 0.119\pm 0.002\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.05907\pm 0.00036\), \(M_Z = 91.1876\pm 0.0021\) GeV and \(m_t = 172.5\pm 2.3\) GeV.

Parameters
[in]qname of a quark (see QCD::quark)
Returns
the effective weak mixing angle for \(Z\to q\bar{q}\)

Definition at line 133 of file EWSMApproximateFormulae.cpp.

134 {
135  // applicable for 10 GeV <= mHl <= 1 TeV
136  if (mycache.getSM().getMHl() < 10.0 || mycache.getSM().getMHl() > UpperBoundForApproximateFormulae) {
137  std::stringstream out;
138  out << mycache.getSM().getMHl();
139  throw std::runtime_error("ApproximateFormulae::sin2thetaEff_q(): mh=" + out.str() + " is out of range");
140  }
141 
142  double s0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
143  double ThError = 0.0; // Theoretical uncertainty
144 
145  switch (q) {
146  case QCD::UP:
147  case QCD::CHARM:
148  s0 = 0.2311395;
149  d1 = 4.726 * 0.0001;
150  d2 = 2.07 * 0.00001;
151  d3 = 3.85 * 0.000001;
152  d4 = -1.85 * 0.000001;
153  d5 = 2.07 * 0.01;
154  d6 = -2.853 * 0.001;
155  d7 = 1.83 * 0.0001;
156  d8 = -9.73 * 0.000001;
157  d9 = 3.98 * 0.0001;
158  d10 = -6.55 * 0.1;
159  ThError = mycache.getSM().getDelSin2th_q();
160  break;
161  case QCD::DOWN:
162  case QCD::STRANGE:
163  s0 = 0.2310286;
164  d1 = 4.720 * 0.0001;
165  d2 = 2.06 * 0.00001;
166  d3 = 3.85 * 0.000001;
167  d4 = -1.85 * 0.000001;
168  d5 = 2.07 * 0.01;
169  d6 = -2.848 * 0.001;
170  d7 = 1.81 * 0.0001;
171  d8 = -9.73 * 0.000001;
172  d9 = 3.97 * 0.0001;
173  d10 = -6.55 * 0.1;
174  ThError = mycache.getSM().getDelSin2th_q();
175  break;
176  case QCD::BOTTOM:
177 
178  if (mycache.getSM().getMHl() < 120.1 || mycache.getSM().getMHl() > 130.1) {
179  s0 = 0.2327580;
180  d1 = 4.749 * 0.0001;
181  d2 = 2.03 * 0.00001;
182  d3 = 3.94 * 0.000001;
183  d4 = -1.84 * 0.000001;
184  d5 = 2.08 * 0.01;
185  d6 = -0.993 * 0.001;
186  d7 = 0.708 * 0.0001;
187  d8 = -7.61 * 0.000001;
188  d9 = 4.03 * 0.0001;
189  d10 = 6.61 * 0.1;
190  ThError = mycache.getSM().getDelSin2th_b();
191  break;
192 
193  } else {
194  return sin2thetaEff_b();
195  }
196  case QCD::TOP:
197  return 0.0;
198  default:
199  throw std::runtime_error("Error in ApproximateFormulae::sin2thetaEff_q()");
200  }
201 
202  double L_H = log(mycache.getSM().getMHl() / 100.0);
203  double Delta_H = mycache.getSM().getMHl() / 100.0;
204  double Delta_ale = mycache.getSM().DeltaAlphaL5q() / 0.05907 - 1.0;
205  double Delta_t = pow((mycache.getSM().getMtpole() / 178.0), 2.0) - 1.0;
206  double Delta_alphas = mycache.getSM().getAlsMz() / 0.117 - 1.0;
207  double Delta_Z = mycache.getSM().getMz() / 91.1876 - 1.0;
208 
209  return (s0 + d1 * L_H + d2 * L_H * L_H + d3 * pow(L_H, 4.0)
210  + d4 * (Delta_H * Delta_H - 1.0) + d5 * Delta_ale + d6 * Delta_t
211  + d7 * Delta_t * Delta_t + d8 * Delta_t * (Delta_H - 1.0)
212  + d9 * Delta_alphas + d10 * Delta_Z
213  + ThError);
214 }

◆ X()

double EWSMApproximateFormulae::X ( const std::string  observable) const

\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\).

This function is based on the approximate formulae for partial and total widths of the \(Z\) boson and hadronic \(Z\)-pole cross section presented in [125], which include the complete fermionic two-loop EW corrections as well as leading three-loop corrections. The bosonic two-loop EW corrections are not included. The approximate formulae reproduce the full results to be better than 0.001 MeV, 0.01 MeV, 0.1 pb, \(0.1\times 10^{-3}\) and \(0.01\times 10^{-3}\) for \(\Gamma_f\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\) and \(R^0_{c,b}\), respectively, if inputs vary within the ranges \(\alpha_s(M_Z^2) = 0.1184\pm 0.0050\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.0590\pm 0.0005\), \(M_Z = 91.1876\pm 0.0042\) GeV, \(m_t = 173.2\pm 2.0\) GeV and \(m_h = 125.7\pm 2.5\) GeV.

Parameters
[in]observablename of the observable to be computed: "Gamma_nu", "Gamma_e_mu", "Gamma_tau", "Gamma_u", "Gamma_c", "Gamma_d_s", "Gamma_b", "GammaZ", "sigmaHadron", "R0_lepton", "R0_charm", "R0_bottom"
Returns
\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\), \(R^0_c\), or \(R^0_b\)
Attention
The function EWSMApproximateFormulae::X_extended is applicable to larger ranges of \(M_Z\), \(m_t\) and \(m_h\).

Definition at line 563 of file EWSMApproximateFormulae.cpp.

564 {
565  double LH = log(mycache.getSM().getMHl() / 125.7);
566  double Dt = pow(mycache.getSM().getMtpole() / 173.2, 2.0) - 1.0;
567  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
568  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
569  double DZ = mycache.getSM().getMz() / 91.1876 - 1.0;
570 
571  double X0, c1, c2, c3, c4, c5, c6, c7;
572  if (observable.compare("Gamma_nu") == 0) {
573  X0 = 167.157;
574  c1 = -0.055;
575  c2 = 1.26;
576  c3 = -0.19;
577  c4 = -0.02;
578  c5 = 0.36;
579  c6 = -0.1;
580  c7 = 503.0;
581  } else if (observable.compare("Gamma_e_mu") == 0) {
582  X0 = 83.966;
583  c1 = -0.047;
584  c2 = 0.807;
585  c3 = -0.095;
586  c4 = -0.01;
587  c5 = 0.25;
588  c6 = -1.1;
589  c7 = 285.0;
590  } else if (observable.compare("Gamma_tau") == 0) {
591  X0 = 83.776;
592  c1 = -0.047;
593  c2 = 0.806;
594  c3 = -0.095;
595  c4 = -0.01;
596  c5 = 0.25;
597  c6 = -1.1;
598  c7 = 285.0;
599  } else if (observable.compare("Gamma_u") == 0) {
600  X0 = 299.936;
601  c1 = -0.34;
602  c2 = 4.07;
603  c3 = 14.27;
604  c4 = 1.6;
605  c5 = 1.8;
606  c6 = -11.1;
607  c7 = 1253.0;
608  } else if (observable.compare("Gamma_c") == 0) {
609  X0 = 299.860;
610  c1 = -0.34;
611  c2 = 4.07;
612  c3 = 14.27;
613  c4 = 1.6;
614  c5 = 1.8;
615  c6 = -11.1;
616  c7 = 1253.0;
617  } else if (observable.compare("Gamma_d_s") == 0) {
618  X0 = 382.770;
619  c1 = -0.34;
620  c2 = 3.83;
621  c3 = 10.20;
622  c4 = -2.4;
623  c5 = 0.67;
624  c6 = -10.1;
625  c7 = 1469.0;
626  } else if (observable.compare("Gamma_b") == 0) {
627  X0 = 375.724;
628  c1 = -0.30;
629  c2 = -2.28;
630  c3 = 10.53;
631  c4 = -2.4;
632  c5 = 1.2;
633  c6 = -10.0;
634  c7 = 1458.0;
635  } else if (observable.compare("GammaZ") == 0) {
636  X0 = 2494.24;
637  c1 = -2.0;
638  c2 = 19.7;
639  c3 = 58.60;
640  c4 = -4.0;
641  c5 = 8.0;
642  c6 = -55.9;
643  c7 = 9267.0;
644  } else if (observable.compare("sigmaHadron") == 0) {
645  X0 = 41488.4;
646  c1 = 3.0;
647  c2 = 60.9;
648  c3 = -579.4;
649  c4 = 38.0;
650  c5 = 7.3;
651  c6 = 85.0;
652  c7 = -86027.0;
653  } else if (observable.compare("R0_lepton") == 0) {
654  X0 = 20750.9;
655  c1 = -8.1;
656  c2 = -39.0;
657  c3 = 732.1;
658  c4 = -44.0;
659  c5 = 5.5;
660  c6 = -358.0;
661  c7 = 11702.0;
662  } else if (observable.compare("R0_charm") == 0) {
663  X0 = 172.23;
664  c1 = -0.029;
665  c2 = 1.0;
666  c3 = 2.3;
667  c4 = 1.3;
668  c5 = 0.38;
669  c6 = -1.2;
670  c7 = 37.0;
671  } else if (observable.compare("R0_bottom") == 0) {
672  X0 = 215.80;
673  c1 = 0.031;
674  c2 = -2.98;
675  c3 = -1.32;
676  c4 = -0.84;
677  c5 = 0.035;
678  c6 = 0.73;
679  c7 = -18.0;
680  } else
681  throw std::runtime_error("ApproximateFormulae::X(): " + observable + " is not defined");
682 
683  return ( 0.001
684  * (X0 + c1 * LH + c2 * Dt + c3 * Das + c4 * Das * Das + c5 * Das * Dt + c6 * Dal + c7 * DZ));
685 }

◆ X_extended()

double EWSMApproximateFormulae::X_extended ( const std::string  observable) const

\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\).

This function is based on the approximate formulae for partial and total widths of the \(Z\) boson and hadronic \(Z\)-pole cross section presented in [125], which include the complete fermionic two-loop EW corrections as well as leading three-loop corrections. The bosonic two-loop EW corrections are not included. The approximate formulae reproduce the full results to be better than 0.001 MeV, 0.01 MeV, 0.1 pb, \(0.1\times 10^{-3}\) and \(0.01\times 10^{-3}\) for \(\Gamma_f\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\) and \(R^0_{c,b}\), respectively, if inputs vary within the ranges \(\alpha_s(M_Z^2) = 0.1184\pm 0.0050\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.0590\pm 0.0005\), \(M_Z = 91.1876\pm 0.0084\) GeV, \(165 < m_t < 190\) GeV and \(70 < m_h < 1000\) GeV.

Parameters
[in]observablename of the observable to be computed: "Gamma_nu", "Gamma_e_mu", "Gamma_tau", "Gamma_u", "Gamma_c", "Gamma_d_s", "Gamma_b", "GammaZ", "sigmaHadron", "R0_lepton", "R0_charm", "R0_bottom"
Returns
\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\), \(R^0_c\), or \(R^0_b\)
Attention
The function EWSMApproximateFormulae::X is applicable to smaller ranges of \(M_Z\), \(m_t\) and \(m_h\).

Definition at line 687 of file EWSMApproximateFormulae.cpp.

688 {
689  double LH = log(mycache.getSM().getMHl() / 125.7);
690  double DH = mycache.getSM().getMHl() / 125.7 - 1.0;
691  double Dt = pow(mycache.getSM().getMtpole() / 173.2, 2.0) - 1.0;
692  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
693  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
694  double DZ = mycache.getSM().getMz() / 91.1876 - 1.0;
695 
696  double X0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15;
697  double ThError = 0.0; // Theoretical uncertainty
698  if (observable.compare("Gamma_nu") == 0) {
699  X0 = 167.157;
700  a1 = -0.1567;
701  a2 = -0.1194;
702  a3 = 0.1031;
703  a4 = -0.00269;
704  a5 = 1.258;
705  a6 = -0.13;
706  a7 = -0.020;
707  a8 = 0.0133;
708  a9 = -0.19;
709  a10 = -0.018;
710  a11 = -0.021;
711  a12 = 0.34;
712  a13 = -0.084;
713  a14 = 0.064;
714  a15 = 503.0;
715  } else if (observable.compare("Gamma_e_mu") == 0) {
716  X0 = 83.966;
717  a1 = -0.1017;
718  a2 = -0.06352;
719  a3 = 0.05500;
720  a4 = -0.00145;
721  a5 = 0.8051;
722  a6 = -0.027;
723  a7 = -0.017;
724  a8 = 0.0066;
725  a9 = -0.095;
726  a10 = -0.010;
727  a11 = -0.015;
728  a12 = 0.23;
729  a13 = -1.1;
730  a14 = 0.064;
731  a15 = 285.0;
732  } else if (observable.compare("Gamma_tau") == 0) {
733  X0 = 83.776;
734  a1 = -0.1016;
735  a2 = -0.06339;
736  a3 = 0.05488;
737  a4 = -0.00145;
738  a5 = 0.8036;
739  a6 = -0.026;
740  a7 = -0.017;
741  a8 = 0.0066;
742  a9 = -0.095;
743  a10 = -0.010;
744  a11 = -0.015;
745  a12 = 0.23;
746  a13 = -1.1;
747  a14 = 0.064;
748  a15 = 285.0;
749  } else if (observable.compare("Gamma_u") == 0) {
750  X0 = 299.936;
751  a1 = -0.5681;
752  a2 = -0.2636;
753  a3 = 0.2334;
754  a4 = -0.00592;
755  a5 = 4.057;
756  a6 = -0.50;
757  a7 = -0.058;
758  a8 = 0.0352;
759  a9 = 14.26;
760  a10 = 1.6;
761  a11 = -0.081;
762  a12 = 1.7;
763  a13 = -11.1;
764  a14 = 0.19;
765  a15 = 1251.0;
766  } else if (observable.compare("Gamma_c") == 0) {
767  X0 = 299.859;
768  a1 = -0.5680;
769  a2 = -0.2635;
770  a3 = 0.2334;
771  a4 = -0.00592;
772  a5 = 4.056;
773  a6 = -0.50;
774  a7 = -0.058;
775  a8 = 0.0352;
776  a9 = 14.26;
777  a10 = 1.6;
778  a11 = -0.081;
779  a12 = 1.7;
780  a13 = -11.1;
781  a14 = 0.19;
782  a15 = 1251.0;
783  } else if (observable.compare("Gamma_d_s") == 0) {
784  X0 = 382.770;
785  a1 = -0.6199;
786  a2 = -0.3182;
787  a3 = 0.2800;
788  a4 = -0.00711;
789  a5 = 3.810;
790  a6 = -0.25;
791  a7 = -0.060;
792  a8 = 0.0420;
793  a9 = 10.20;
794  a10 = -2.4;
795  a11 = -0.083;
796  a12 = 0.65;
797  a13 = -10.1;
798  a14 = 0.19;
799  a15 = 1468.0;
800  } else if (observable.compare("Gamma_b") == 0) {
801  X0 = 375.723;
802  a1 = -0.5744;
803  a2 = -0.3074;
804  a3 = 0.2725;
805  a4 = -0.00703;
806  a5 = -2.292;
807  a6 = -0.027;
808  a7 = -0.013;
809  a8 = 0.0428;
810  a9 = 10.53;
811  a10 = -2.4;
812  a11 = -0.088;
813  a12 = 1.2;
814  a13 = -10.1;
815  a14 = 0.19;
816  a15 = 1456.0;
817  } else if (observable.compare("Gamma_had") == 0) {
818 // Removing leptonic contributions from GammaZ
819 // X0 = 1741.06;
820 // a1 = -2.9501;
821 // a2 = -1.47064;
822 // a3 = 1.29906;
823 // a4 = -0.033105;
824 // a5 = 13.4416;
825 // a6 = -1.5285;
826 // a7 = -0.249;
827 // a8 = 0.19725;
828 // a9 = 59.4525;
829 // a10 = -4.008;
830 // a11 = -0.419;
831 // a12 = 5.895;
832 // a13 = -52.474;
833 // a14 = 0.933;
834 // a15 = 6893.;
835 
836 // Summing all hadronic contributions
837  X0 = 1741.058;
838  a1 = -2.9503;
839  a2 = -1.4708999;
840  a3 = 1.2993;
841  a4 = -0.03308999;
842  a5 = 13.440999;
843  a6 = -1.527;
844  a7 = -0.249;
845  a8 = 0.1972;
846  a9 = 59.44999;
847  a10 = -3.9999;
848  a11 = -0.416;
849  a12 = 5.9;
850  a13 = -52.5;
851  a14 = 0.95;
852  a15 = 6894.;
853 
854  } else if (observable.compare("GammaZ") == 0) {
855  X0 = 2494.24;
856  a1 = -3.725;
857  a2 = -2.019;
858  a3 = 1.773;
859  a4 = -0.04554;
860  a5 = 19.63;
861  a6 = -2.0;
862  a7 = -0.36;
863  a8 = 0.257;
864  a9 = 58.60;
865  a10 = -4.1;
866  a11 = -0.53;
867  a12 = 7.6;
868  a13 = -56.0;
869  a14 = 1.3;
870  a15 = 9256.0;
871  ThError = mycache.getSM().getDelGammaZ();
872  } else if (observable.compare("sigmaHadron") == 0) {
873  X0 = 41488.4;
874  a1 = 3.88;
875  a2 = 0.829;
876  a3 = -0.911;
877  a4 = 0.0076;
878  a5 = 61.10;
879  a6 = 16.0;
880  a7 = -2.0;
881  a8 = -0.59;
882  a9 = -579.4;
883  a10 = 38.0;
884  a11 = -0.26;
885  a12 = 6.5;
886  a13 = 84.0;
887  a14 = 9.5;
888  a15 = -86152.0;
889  ThError = mycache.getSM().getDelSigma0H();
890  } else if (observable.compare("R0_lepton") == 0) {
891  X0 = 20750.9;
892  a1 = -10.00;
893  a2 = -1.83;
894  a3 = 1.878;
895  a4 = -0.0343;
896  a5 = -38.8;
897  a6 = -11.0;
898  a7 = 1.2;
899  a8 = 0.72;
900  a9 = 732.1;
901  a10 = -44.0;
902  a11 = -0.64;
903  a12 = 5.6;
904  a13 = -357.0;
905  a14 = -4.7;
906  a15 = 11771.0;
907  ThError = mycache.getSM().getDelR0l();
908  } else if (observable.compare("R0_electron") == 0) {
909  ThError = mycache.getSM().getDelR0l();
910  return X_extended("Gamma_had")/X_extended("Gamma_e_mu") + ThError;
911 
912  } else if (observable.compare("R0_muon") == 0) {
913  ThError = mycache.getSM().getDelR0l();
914  return X_extended("Gamma_had")/X_extended("Gamma_e_mu") + ThError;
915 
916  } else if (observable.compare("R0_tau") == 0) {
917  ThError = mycache.getSM().getDelR0l();
918  return X_extended("Gamma_had")/X_extended("Gamma_tau") + ThError;
919 
920  } else if (observable.compare("R0_neutrino") == 0) {
921  ThError = 0.0;
922  return X_extended("Gamma_nu")/X_extended("Gamma_had") + ThError;
923 
924  } else if (observable.compare("R0_up") == 0) {
925  ThError = 0.0; // Set to zero for the moment
926  return X_extended("Gamma_u")/X_extended("Gamma_had") + ThError;
927 
928  } else if (observable.compare("R0_strange") == 0) {
929  ThError = 0.0; // Set to zero for the moment
930  return X_extended("Gamma_d_s")/X_extended("Gamma_had") + ThError;
931 
932  } else if (observable.compare("R0_charm") == 0) {
933  X0 = 172.23;
934  a1 = -0.034;
935  a2 = -0.0058;
936  a3 = 0.0054;
937  a4 = -0.00012;
938  a5 = 1.00;
939  a6 = -0.15;
940  a7 = -0.0074;
941  a8 = 0.00091;
942  a9 = 2.3;
943  a10 = 1.3;
944  a11 = -0.0013;
945  a12 = 0.35;
946  a13 = -1.2;
947  a14 = 0.014;
948  a15 = 37.0;
949  ThError = mycache.getSM().getDelR0c();
950  } else if (observable.compare("R0_bottom") == 0) {
951  X0 = 215.80;
952  a1 = 0.036;
953  a2 = 0.0057;
954  a3 = -0.0044;
955  a4 = 0.000062;
956  a5 = -2.98;
957  a6 = 0.20;
958  a7 = 0.020;
959  a8 = -0.00036;
960  a9 = -1.3;
961  a10 = -0.84;
962  a11 = -0.0019;
963  a12 = 0.054;
964  a13 = 0.73;
965  a14 = -0.011;
966  a15 = -18.0;
967  ThError = mycache.getSM().getDelR0b();
968  } else
969  throw std::runtime_error("ApproximateFormulae::X_extended(): " + observable + " is not defined");
970 
971  return ( 0.001
972  * (X0 + a1 * LH + a2 * LH * LH + a3 * DH + a4 * DH * DH + a5 * Dt + a6 * Dt * Dt
973  + a7 * Dt * LH + a8 * Dt * LH * LH + a9 * Das + a10 * Das * Das + a11 * Das * LH
974  + a12 * Das * Dt + a13 * Dal + a14 * Dal * LH + a15 * DZ) + ThError);
975 }

◆ X_full()

double EWSMApproximateFormulae::X_full ( const std::string  observable) const

\(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_\nu\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\).

This function is based on the approximate formulae for partial and total widths of the \(Z\) boson and hadronic \(Z\)-pole cross section presented in arXiv: 1906.08815, which include the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formulae reproduce the full results to be better than 0.0015 MeV, 0.0015 MeV, 0.002 MeV, 0.006 MeV, 0.006 MeV, 0.007 MeV, 0.007 MeV, 0.04 MeV, \( 0.12\times 10^{-3}\), \( 0.1\times 10^{-3}\), \( 0.12\times 10^{-3}\), and 0.15 pb, for \(\Gamma_{e,\mu,\tau,\nu}\), \(\Gamma_{q\not = b}\), \(\Gamma_{b}\), \(\Gamma_Z\), \(R^0_{l}\), \(R^0_{c,b}\) and \(\sigma^0_h\), respectively, if inputs vary within the ranges \(\alpha_s(M_Z^2) = 0.1184\pm 0.0050\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.0590\pm 0.0005\), \(M_Z = 91.1876\pm 0.0084\) GeV, \(155 < m_t < 192\) GeV and \(25 < m_h < 225\) GeV.

Parameters
[in]observablename of the observable to be computed: "Gamma_nu", "Gamma_e_mu", "Gamma_tau", "Gamma_u", "Gamma_c", "Gamma_d_s", "Gamma_b", "GammaZ", "sigmaHadron", "R0_lepton", "R0_charm", "R0_bottom"
Returns
\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\), \(R^0_c\), or \(R^0_b\)

Definition at line 1169 of file EWSMApproximateFormulae.cpp.

1170 {
1171 
1172 // Full 2-loop implementation
1173 
1174  double LH = log(mycache.getSM().getMHl() / 125.7);
1175  double LH2 = LH * LH;
1176 
1177  double DH = pow(125.7 / (mycache.getSM().getMHl()), 4.0) - 1.0;
1178 
1179  double Dt = pow(mycache.getSM().getMtpole() / 173.2, 2.0) - 1.0;
1180 
1181  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
1182 
1183  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
1184 
1185  double DZ = mycache.getSM().getMz() / 91.1876 - 1.0;
1186 
1187  double X0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16;
1188 
1189  double ThError = 0.0; // Theoretical uncertainty
1190 
1191  if (observable.compare("Gamma_e_mu") == 0) {
1192  X0 = 83.983;
1193  a1 = -0.1202;
1194  a2 = -0.06919;
1195  a3 = 0.00383;
1196  a4 = 0.0597;
1197  a5 = 0.8037;
1198  a6 = -0.015;
1199  a7 = -0.0195;
1200  a8 = 0.0032;
1201  a9 = -0.0956;
1202  a10 = -0.0078;
1203  a11 = -0.0095;
1204  a12 = 0.25;
1205  a13 = -1.08;
1206  a14 = 0.056;
1207  a15 = -0.37;
1208  a16 = 286.0;
1209 
1210  } else if (observable.compare("Gamma_tau") == 0) {
1211  X0 = 83.793;
1212  a1 = -0.1200;
1213  a2 = -0.06905;
1214  a3 = 0.00382;
1215  a4 = 0.0596;
1216  a5 = 0.8023;
1217  a6 = -0.015;
1218  a7 = -0.0195;
1219  a8 = 0.0032;
1220  a9 = -0.0954;
1221  a10 = -0.0078;
1222  a11 = -0.0094;
1223  a12 = 0.25;
1224  a13 = -1.08;
1225  a14 = 0.056;
1226  a15 = -0.37;
1227  a16 = 285.0;
1228 
1229  } else if (observable.compare("Gamma_nu") == 0) {
1230  X0 = 167.176;
1231  a1 = -0.1752;
1232  a2 = -0.1249;
1233  a3 = 0.00595;
1234  a4 = 0.1046;
1235  a5 = 1.253;
1236  a6 = -0.110;
1237  a7 = -0.0232;
1238  a8 = 0.0064;
1239  a9 = -0.187;
1240  a10 = -0.014;
1241  a11 = -0.014;
1242  a12 = 0.37;
1243  a13 = -0.085;
1244  a14 = 0.054;
1245  a15 = -0.30;
1246  a16 = 503.0;
1247 
1248  } else if (observable.compare("Gamma_u") == 0) {
1249  X0 = 299.994;
1250  a1 = -0.6152;
1251  a2 = -0.2771;
1252  a3 = 0.0174;
1253  a4 = 0.2341;
1254  a5 = 4.051;
1255  a6 = -0.467;
1256  a7 = -0.0676;
1257  a8 = 0.017;
1258  a9 = 14.26;
1259  a10 = 1.6;
1260  a11 = -0.046;
1261  a12 = 1.82;
1262  a13 = -11.1;
1263  a14 = 0.16;
1264  a15 = -1.0;
1265  a16 = 1253.0;
1266 
1267  } else if (observable.compare("Gamma_c") == 0) {
1268  X0 = 299.918;
1269  a1 = -0.6152;
1270  a2 = -0.2771;
1271  a3 = 0.0174;
1272  a4 = 0.2340;
1273  a5 = 4.051;
1274  a6 = -0.467;
1275  a7 = -0.0676;
1276  a8 = 0.017;
1277  a9 = 14.26;
1278  a10 = 1.6;
1279  a11 = -0.046;
1280  a12 = 1.82;
1281  a13 = -11.1;
1282  a14 = 0.16;
1283  a15 = -1.0;
1284  a16 = 1252.0;
1285 
1286  } else if (observable.compare("Gamma_d_s") == 0) {
1287  X0 = 382.829;
1288  a1 = -0.6685;
1289  a2 = -0.3322;
1290  a3 = 0.0193;
1291  a4 = 0.2792;
1292  a5 = 3.792;
1293  a6 = -0.18;
1294  a7 = -0.0706;
1295  a8 = 0.020;
1296  a9 = 10.20;
1297  a10 = -2.4;
1298  a11 = -0.052;
1299  a12 = 0.71;
1300  a13 = -10.1;
1301  a14 = 0.16;
1302  a15 = -0.92;
1303  a16 = 1469.0;
1304 
1305  } else if (observable.compare("Gamma_b") == 0) {
1306  X0 = 375.890;
1307  a1 = -0.6017;
1308  a2 = -0.3158;
1309  a3 = 0.0190;
1310  a4 = 0.227;
1311  a5 = -2.174;
1312  a6 = 0.042;
1313  a7 = -0.027;
1314  a8 = 0.021;
1315  a9 = 10.53;
1316  a10 = -2.4;
1317  a11 = -0.056;
1318  a12 = 1.2;
1319  a13 = -10.1;
1320  a14 = 0.15;
1321  a15 = -0.95;
1322  a16 = 1458.0;
1323 
1324  } else if (observable.compare("Gamma_had") == 0) {
1325 
1326 // Removing leptonic contributions from the total Z witdh
1327  X0 = 1741.46;
1328  a1 = -3.169;
1329  a2 = -1.53487;
1330  a3 = 0.09267;
1331  a4 = 1.2532;
1332  a5 = 13.5113;
1333  a6 = -1.255;
1334  a7 = -0.3039;
1335  a8 = 0.0912;
1336  a9 = 59.4576;
1337  a10 = -3.9346;
1338  a11 = -0.2496;
1339  a12 = 6.24;
1340  a13 = -52.605;
1341  a14 = 0.77;
1342  a15 = -4.79;
1343  a16 = 6901.0;
1344 
1345  } else if (observable.compare("GammaZ") == 0) {
1346  X0 = 2494.75;
1347  a1 = -4.055;
1348  a2 = -2.117;
1349  a3 = 0.122;
1350  a4 = 1.746;
1351  a5 = 19.68;
1352  a6 = -1.63;
1353  a7 = -0.432;
1354  a8 = 0.12;
1355  a9 = 58.61;
1356  a10 = -4.0;
1357  a11 = -0.32;
1358  a12 = 8.1;
1359  a13 = -56.1;
1360  a14 = 1.1;
1361  a15 = -6.8;
1362  a16 = 9267.0;
1363 
1364  ThError = mycache.getSM().getDelGammaZ();
1365  } else if (observable.compare("sigmaHadron") == 0) {
1366  X0 = 41489.6;
1367  a1 = 0.408;
1368  a2 = -0.320;
1369  a3 = 0.0424;
1370  a4 = 1.32;
1371  a5 = 60.17;
1372  a6 = 16.3;
1373  a7 = -2.31;
1374  a8 = -0.19;
1375  a9 = -579.58;
1376  a10 = 38.0;
1377  a11 = 0.010;
1378  a12 = 7.5;
1379  a13 = 85.2;
1380  a14 = 9.1;
1381  a15 = -68.0;
1382  a16 = -85957.0;
1383 
1384  ThError = mycache.getSM().getDelSigma0H();
1385  } else if (observable.compare("R0_lepton") == 0) {
1386  X0 = 20751.6;
1387  a1 = -8.112;
1388  a2 = -1.174;
1389  a3 = 0.155;
1390  a4 = 0.16;
1391  a5 = -37.59;
1392  a6 = -10.9;
1393  a7 = 1.27;
1394  a8 = 0.29;
1395  a9 = 732.30;
1396  a10 = -44.0;
1397  a11 = -0.61;
1398  a12 = 5.7;
1399  a13 = -358.0;
1400  a14 = -4.7;
1401  a15 = 37;
1402  a16 = 11649.0;
1403 
1404  ThError = mycache.getSM().getDelR0l();
1405  } else if (observable.compare("R0_electron") == 0) {
1406  ThError = mycache.getSM().getDelR0l();
1407  return X_full("Gamma_had")/X_full("Gamma_e_mu") + ThError;
1408 
1409  } else if (observable.compare("R0_muon") == 0) {
1410  ThError = mycache.getSM().getDelR0l();
1411  return X_full("Gamma_had")/X_full("Gamma_e_mu") + ThError;
1412 
1413  } else if (observable.compare("R0_tau") == 0) {
1414  ThError = mycache.getSM().getDelR0l();
1415  return X_full("Gamma_had")/X_full("Gamma_tau") + ThError;
1416 
1417  } else if (observable.compare("R0_neutrino") == 0) {
1418  ThError = 0.0;
1419  return X_full("Gamma_nu")/X_full("Gamma_had") + ThError;
1420 
1421  } else if (observable.compare("R0_up") == 0) {
1422  ThError = 0.0; // Set to zero for the moment
1423  return X_full("Gamma_u")/X_full("Gamma_had") + ThError;
1424 
1425  } else if (observable.compare("R0_strange") == 0) {
1426  ThError = 0.0; // Set to zero for the moment
1427  return X_full("Gamma_d_s")/X_full("Gamma_had") + ThError;
1428 
1429  } else if (observable.compare("R0_charm") == 0) {
1430  X0 = 172.222;
1431  a1 = -0.04049;
1432  a2 = -0.00749;
1433  a3 = 0.000832;
1434  a4 = 0.0108;
1435  a5 = 0.98956;
1436  a6 = -0.151;
1437  a7 = -0.00761;
1438  a8 = 0.00080;
1439  a9 = 2.309;
1440  a10 = 1.25;
1441  a11 = 0.00045;
1442  a12 = 0.369;
1443  a13 = -1.20;
1444  a14 = 0.012;
1445  a15 = -0.062;
1446  a16 = 36.67;
1447 
1448  ThError = mycache.getSM().getDelR0c();
1449  } else if (observable.compare("R0_bottom") == 0) {
1450  X0 = 215.850;
1451  a1 = 0.04904;
1452  a2 = 0.009149;
1453  a3 = -0.000535;
1454  a4 = -0.02676;
1455  a5 = -2.9221;
1456  a6 = 0.200;
1457  a7 = 0.0197;
1458  a8 = -0.0011;
1459  a9 = -1.319;
1460  a10 = -0.84;
1461  a11 = -0.0027;
1462  a12 = 0.044;
1463  a13 = 0.719;
1464  a14 = -0.0077;
1465  a15 = -0.044;
1466  a16 = -17.90;
1467 
1468  ThError = mycache.getSM().getDelR0b();
1469  } else
1470  throw std::runtime_error("ApproximateFormulae::X_full(): " + observable + " is not defined");
1471 
1472  return ( 0.001
1473  * ( X0 + a1 * LH + a2 * LH2 + a3 * LH2 * LH2 + a4 *DH
1474  + a5 * Dt + a6 * Dt*Dt + a7 * Dt*LH + a8 * Dt * LH2
1475  + a9 * Das + a10 * Das * Das + a11 * Das*DH + a12*Das*Dt
1476  + a13 * Dal + a14 * Dal * DH + a15 * Dal * Dt
1477  + a16 * DZ ) + ThError);
1478 }

◆ X_full_2_loop()

double EWSMApproximateFormulae::X_full_2_loop ( const std::string  observable) const

\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(R^0_\ell\), \(R^0_c\), \(R^0_b\), or \(\sigma^0_h\).

This function is based on the approximate formulae for partial and total widths of the \(Z\) boson and hadronic \(Z\)-pole cross section presented in arXiv: 1804.10236, which include the complete two-loop EW corrections as well as leading three-loop corrections. The approximate formulae reproduce the full results to be better than 0.001 MeV, 0.002 MeV, 0.006 MeV, 0.012 MeV, \( 0.1\times 10^{-3}\), \( 0.01\times 10^{-3}\) and 0.1 pb, for \(\Gamma_{e,\mu,\tau,\nu}\), \(\Gamma_{q\not = b}\), \(\Gamma_{b}\), \(\Gamma_Z\), \(R^0_{l}\), \(R^0_{c,b}\) and \(\sigma^0_h\), respectively, if inputs vary within the ranges \(\alpha_s(M_Z^2) = 0.1184\pm 0.0050\), \(\Delta\alpha^{\ell+5q}(M_Z^2) = 0.0590\pm 0.0005\), \(M_Z = 91.1876\pm 0.0042\) GeV, \(169.2 < m_t < 177.2\) GeV and \(120.1 < m_h < 130.1\) GeV. For \(m_h\) beyond [85,165] GeV there are significant differences with some predicions of X_extended, which go well beyond the expected size of the bosonic corrections (>~2x). The function redirects to X_extended in that case.

Parameters
[in]observablename of the observable to be computed: "Gamma_nu", "Gamma_e_mu", "Gamma_tau", "Gamma_u", "Gamma_c", "Gamma_d_s", "Gamma_b", "GammaZ", "sigmaHadron", "R0_lepton", "R0_charm", "R0_bottom"
Returns
\(\Gamma_\nu\), \(\Gamma_{e,\mu}\), \(\Gamma_\tau\), \(\Gamma_u\), \(\Gamma_c\), \(\Gamma_{d,s}\), \(\Gamma_b\), \(\Gamma_Z\), \(\sigma^0_h\), \(R^0_\ell\), \(R^0_c\), or \(R^0_b\)

Definition at line 978 of file EWSMApproximateFormulae.cpp.

979 {
980 
981 // For MH not in [85,165] GeV there are significant differences with some predicions
982 // of X_extended, which go well beyond the expected size of the bosonic corrections (>~2x).
983 // Use EWSMApproximateFormulae::X_extended in that case
984  if (mycache.getSM().getMHl() < 85.0 || mycache.getSM().getMHl() > 165.0) {
985  return X_extended(observable);
986  }
987 
988 // Otherwise proceed with the full 2-loop code
989  double LH = log(mycache.getSM().getMHl() / 125.7);
990  double Dt = pow(mycache.getSM().getMtpole() / 173.2, 2.0) - 1.0;
991  double Das = mycache.getSM().getAlsMz() / 0.1184 - 1.0;
992  double Dal = mycache.getSM().DeltaAlphaL5q() / 0.059 - 1.0;
993  double DZ = mycache.getSM().getMz() / 91.1876 - 1.0;
994 
995  double X0, c1, c2, c3, c4, c5, c6, c7;
996  double ThError = 0.0; // Theoretical uncertainty
997  if (observable.compare("Gamma_nu") == 0) {
998  X0 = 167.176;
999  c1 = -0.071;
1000  c2 = 1.26;
1001  c3 = -0.19;
1002  c4 = -0.02;
1003  c5 = 0.36;
1004  c6 = -0.1;
1005  c7 = 504.0;
1006 
1007  } else if (observable.compare("Gamma_e_mu") == 0) {
1008  X0 = 83.983;
1009  c1 = -0.061;
1010  c2 = 0.810;
1011  c3 = -0.096;
1012  c4 = -0.01;
1013  c5 = 0.25;
1014  c6 = -1.1;
1015  c7 = 286.0;
1016 
1017  } else if (observable.compare("Gamma_tau") == 0) {
1018  X0 = 83.793;
1019  c1 = -0.060;
1020  c2 = 0.810;
1021  c3 = -0.095;
1022  c4 = -0.01;
1023  c5 = 0.25;
1024  c6 = -1.1;
1025  c7 = 285.0;
1026 
1027  } else if (observable.compare("Gamma_u") == 0) {
1028  X0 = 299.993;
1029  c1 = -0.38;
1030  c2 = 4.08;
1031  c3 = 14.27;
1032  c4 = 1.6;
1033  c5 = 1.8;
1034  c6 = -11.1;
1035  c7 = 1253.0;
1036 
1037  } else if (observable.compare("Gamma_c") == 0) {
1038  X0 = 299.916;
1039  c1 = -0.38;
1040  c2 = 4.08;
1041  c3 = 14.27;
1042  c4 = 1.6;
1043  c5 = 1.8;
1044  c6 = -11.1;
1045  c7 = 1253.0;
1046 
1047  } else if (observable.compare("Gamma_d_s") == 0) {
1048  X0 = 382.828;
1049  c1 = -0.39;
1050  c2 = 3.83;
1051  c3 = 10.20;
1052  c4 = -2.4;
1053  c5 = 0.67;
1054  c6 = -10.1;
1055  c7 = 1470.0;
1056 
1057  } else if (observable.compare("Gamma_b") == 0) {
1058  X0 = 375.889;
1059  c1 = -0.36;
1060  c2 = -2.14;
1061  c3 = 10.53;
1062  c4 = -2.4;
1063  c5 = 1.2;
1064  c6 = -10.1;
1065  c7 = 1459.0;
1066 
1067  } else if (observable.compare("Gamma_had") == 0) {
1068 
1069 // Summing all hadronic contributions
1070  X0 = 1741.454;
1071  c1 = -1.9;
1072  c2 = 13.68;
1073  c3 = 59.47;
1074  c4 = -4.0;
1075  c5 = 6.14;
1076  c6 = -52.5;
1077  c7 = 6905.0;
1078 
1079  } else if (observable.compare("GammaZ") == 0) {
1080  X0 = 2494.74;
1081  c1 = -2.3;
1082  c2 = 19.9;
1083  c3 = 58.61;
1084  c4 = -4.0;
1085  c5 = 8.0;
1086  c6 = -56.0;
1087  c7 = 9273.0;
1088 
1089  ThError = mycache.getSM().getDelGammaZ();
1090  } else if (observable.compare("sigmaHadron") == 0) {
1091  X0 = 41489.6;
1092  c1 = 1.6;
1093  c2 = 60.0;
1094  c3 = -579.6;
1095  c4 = 38.0;
1096  c5 = 7.3;
1097  c6 = 85.0;
1098  c7 = -86011.0;
1099 
1100  ThError = mycache.getSM().getDelSigma0H();
1101  } else if (observable.compare("R0_lepton") == 0) {
1102  X0 = 20751.6;
1103  c1 = -7.8;
1104  c2 = -37.0;
1105  c3 = 732.3;
1106  c4 = -44.0;
1107  c5 = 5.5;
1108  c6 = -358.0;
1109  c7 = 11696.0;
1110 
1111  ThError = mycache.getSM().getDelR0l();
1112  } else if (observable.compare("R0_electron") == 0) {
1113  ThError = mycache.getSM().getDelR0l();
1114  return X_full_2_loop("Gamma_had")/X_full_2_loop("Gamma_e_mu") + ThError;
1115 
1116  } else if (observable.compare("R0_muon") == 0) {
1117  ThError = mycache.getSM().getDelR0l();
1118  return X_full_2_loop("Gamma_had")/X_full_2_loop("Gamma_e_mu") + ThError;
1119 
1120  } else if (observable.compare("R0_tau") == 0) {
1121  ThError = mycache.getSM().getDelR0l();
1122  return X_full_2_loop("Gamma_had")/X_full_2_loop("Gamma_tau") + ThError;
1123 
1124  } else if (observable.compare("R0_neutrino") == 0) {
1125  ThError = 0.0;
1126  return X_full_2_loop("Gamma_nu")/X_full_2_loop("Gamma_had") + ThError;
1127 
1128  } else if (observable.compare("R0_up") == 0) {
1129  ThError = 0.0; // Set to zero for the moment
1130  return X_full_2_loop("Gamma_u")/X_full_2_loop("Gamma_had") + ThError;
1131 
1132  } else if (observable.compare("R0_strange") == 0) {
1133  ThError = 0.0; // Set to zero for the moment
1134  return X_full_2_loop("Gamma_d_s")/X_full_2_loop("Gamma_had") + ThError;
1135 
1136  } else if (observable.compare("R0_charm") == 0) {
1137  X0 = 172.22;
1138  c1 = -0.031;
1139  c2 = 1.0;
1140  c3 = 2.3;
1141  c4 = 1.3;
1142  c5 = 0.38;
1143  c6 = -1.2;
1144  c7 = 37.0;
1145 
1146  ThError = mycache.getSM().getDelR0c();
1147  } else if (observable.compare("R0_bottom") == 0) {
1148  X0 = 215.85;
1149  c1 = 0.029;
1150  c2 = -2.92;
1151  c3 = -1.32;
1152  c4 = -0.84;
1153  c5 = 0.032;
1154  c6 = 0.72;
1155  c7 = -18.0;
1156 
1157  ThError = mycache.getSM().getDelR0b();
1158  } else
1159  throw std::runtime_error("ApproximateFormulae::X_full_2_loop(): " + observable + " is not defined");
1160 
1161  return ( 0.001
1162  * (X0 + c1 * LH + c2 * Dt
1163  + c3 * Das + c4 * Das * Das
1164  + c5 * Das * Dt + c6 * Dal + c7 * DZ) + ThError);
1165 }

Member Data Documentation

◆ mycache

const EWSMcache& EWSMApproximateFormulae::mycache
private

A reference to an object of type StandardModel.

Definition at line 429 of file EWSMApproximateFormulae.h.

The documentation for this class was generated from the following files:
QCD::TAU
Definition: QCD.h:316
QCD::NEUTRINO_3
Definition: QCD.h:315
EWSMApproximateFormulae::X_full
double X_full(const std::string observable) const
, , , , , , , , , , , or .
Definition: EWSMApproximateFormulae.cpp:1169
QCD::BOTTOM
Definition: QCD.h:329
Particle::is
bool is(std::string name_i) const
Definition: Particle.cpp:23
EWSMApproximateFormulae::sin2thetaEff_q
double sin2thetaEff_q(const QCD::quark q) const
with the full two-loop EW corrections (bosonic two-loop EW corrections are missing for ).
Definition: EWSMApproximateFormulae.cpp:133
StandardModel::getDelSigma0H
double getDelSigma0H() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:831
StandardModel::getAlsMz
double getAlsMz() const
A get method to access the value of .
Definition: StandardModel.h:730
StandardModel::getDelR0l
double getDelR0l() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:841
QCD::UP
Definition: QCD.h:324
QCD::CHARM
Definition: QCD.h:326
StandardModel::DeltaAlphaL5q
double DeltaAlphaL5q() const
The sum of the leptonic and the five-flavour hadronic corrections to the electromagnetic coupling at...
Definition: StandardModel.cpp:856
QCD::NEUTRINO_2
Definition: QCD.h:313
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
QCD::ELECTRON
Definition: QCD.h:312
StandardModel::getDelMw
double getDelMw() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:778
EWSMApproximateFormulae::sin2thetaEff_b
double sin2thetaEff_b() const
with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:216
EWSMApproximateFormulae::mycache
const EWSMcache & mycache
A reference to an object of type StandardModel.
Definition: EWSMApproximateFormulae.h:429
EWSMApproximateFormulae::X_extended
double X_extended(const std::string observable) const
, , , , , , , , , , , or .
Definition: EWSMApproximateFormulae.cpp:687
EWSMcache::getSM
const StandardModel & getSM() const
Definition: EWSMcache.h:56
QCD::TOP
Definition: QCD.h:328
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
EWSMApproximateFormulae::X_full_2_loop
double X_full_2_loop(const std::string observable) const
, , , , , , , , , , , or .
Definition: EWSMApproximateFormulae.cpp:978
QCD::getMtpole
double getMtpole() const
A get method to access the pole mass of the top quark.
Definition: QCD.h:588
StandardModel::getDelSin2th_l
double getDelSin2th_l() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:789
EWSMApproximateFormulae::sin2thetaEff_l
double sin2thetaEff_l(const QCD::lepton l) const
with the full two-loop EW corrections.
Definition: EWSMApproximateFormulae.cpp:74
QCD::quark
quark
An enum type for quarks.
Definition: QCD.h:323
StandardModel::getDelSin2th_q
double getDelSin2th_q() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:800
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:721
StandardModel::getDelR0b
double getDelR0b() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:861
Mw
An observable class for the -boson mass.
Definition: Mw.h:22
StandardModel::getDelR0c
double getDelR0c() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:851
QCD::STRANGE
Definition: QCD.h:327
Particle::getIndex
int getIndex() const
Definition: Particle.h:160
StandardModel::getMHl
virtual double getMHl() const
A get method to retrieve the Higgs mass .
Definition: StandardModel.h:768
StandardModel::getDelSin2th_b
double getDelSin2th_b() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:811
StandardModel::getDelGammaZ
double getDelGammaZ() const
A get method to retrieve the theoretical uncertainty in , denoted as .
Definition: StandardModel.h:821
QCD::DOWN
Definition: QCD.h:325
QCD::NEUTRINO_1
Definition: QCD.h:311
QCD::MU
Definition: QCD.h:314
QCD::lepton
lepton
An enum type for leptons.
Definition: QCD.h:310