StandardModelMatching Class Reference

A class for the matching in the Standard Model. More...

#include <StandardModelMatching.h>

Inheritance diagram for StandardModelMatching:
[legend]
Collaboration diagram for StandardModelMatching:
[legend]

Detailed Description

A class for the matching in the Standard Model.

Author
HEPfit Collaboration

Definition at line 26 of file StandardModelMatching.h.

Public Member Functions

double A0t (double x) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220 More...
 
double A1t (double x, double mu) const
 loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1 More...
 
double B0b (double x) const
 loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 More...
 
double B0t (double x) const
 loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220 More...
 
double B1t (double x, double mu) const
 loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1 More...
 
double C0b (double x) const
 loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 More...
 
double C0t (double x) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220 More...
 
double C1t (double x, double mu) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1 More...
 
double C7LOeff (double x) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the effective Misiak basis, LO term, Chetyrkin et al hep-ph/9612313 More...
 
double C7NLOeff (double x) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the effective Misiak basis, NLO term, Chetyrkin et al hep-ph/9612313 More...
 
double C8LOeff (double x) const
 loop function which appear in the Wilson coefficient for the chromomagnetic operator in the effective Misiak basis, LO term, Chetyrkin et al hep-ph/9612313 More...
 
double C8NLOeff (double x) const
 loop function which appear in the Wilson coefficient for the chromomagnetic operator in the effective Misiak basis, LO term, Chetyrkin et al hep-ph/9612313 More...
 
virtual std::vector< WilsonCoefficient > & CMbdmm ()
 
virtual std::vector< WilsonCoefficient > & CMBMll ()
 operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic More...
 
virtual std::vector< WilsonCoefficient > & CMbnlep (int a)
 operator basis: More...
 
virtual std::vector< WilsonCoefficient > & CMbnlepCC (int a)
 operator basis: - current current opertors More...
 
virtual std::vector< WilsonCoefficient > & CMbsg ()
 operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic More...
 
virtual std::vector< WilsonCoefficient > & CMbsmm ()
 
virtual std::vector< WilsonCoefficient > & CMbtaunu ()
 
virtual std::vector< WilsonCoefficient > & CMBXdnn ()
 
virtual std::vector< WilsonCoefficient > & CMBXsnn ()
 
virtual std::vector< WilsonCoefficient > & CMd1 ()
 current-current oerators, Misiak basis More...
 
virtual std::vector< WilsonCoefficient > & CMd1Buras ()
 current-current oerators, Buras basis More...
 
virtual std::vector< WilsonCoefficient > & CMdbd2 ()
 \( \Delta B = 2 \), \( B_{d} \) More...
 
virtual std::vector< WilsonCoefficient > & CMdbs2 ()
 \( \Delta B = 2 \), \( B_{s} \) More...
 
virtual std::vector< WilsonCoefficient > & CMdd2 ()
 \( \Delta C = 2 \), More...
 
virtual std::vector< WilsonCoefficient > & CMdk2 ()
 \( \Delta S = 2 \) More...
 
virtual std::vector< WilsonCoefficient > & CMDLi3j (int li_lj)
 
virtual std::vector< WilsonCoefficient > & CMDLij (int li_lj)
 
virtual std::vector< WilsonCoefficient > & CMgminus2mu ()
 
virtual std::vector< WilsonCoefficient > & CMK ()
 operator basis: More...
 
virtual std::vector< WilsonCoefficient > & CMKCC ()
 operator basis: More...
 
virtual std::vector< WilsonCoefficient > & CMkmm ()
 
virtual std::vector< WilsonCoefficient > & CMkpnn ()
 
virtual std::vector< WilsonCoefficient > & CMmueconv ()
 
virtual std::vector< WilsonCoefficient > & CMprimeBMll ()
 operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic More...
 
virtual std::vector< WilsonCoefficient > & CMprimebsg ()
 operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic More...
 
double D0b (double x) const
 loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 More...
 
double D0t (double x) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220 More...
 
double D1t (double x, double mu) const
 loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1 More...
 
double E0b (double x) const
 loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 More...
 
double E0t (double x) const
 loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak basis, Chetyrkin et al hep-ph/9612313 More...
 
double E1t (double x, double mu) const
 loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220 More...
 
double Eet (double x) const
 loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066 More...
 
double F0t (double x) const
 loop function which appear in the Wilson coefficient for the chromomagnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220 More...
 
double F1t (double x, double mu) const
 loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1 More...
 
double G1t (double x, double mu) const
 loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220 More...
 
double mt2omh2 (const double mu, const orders order=FULLNNLO) const
 
double Rest (double x, double mu) const
 approximation of two-loops EW correction for Q_10 operator in the non-effective Misiak basis, Misiak and Urban hep-ph/1311.1348 More...
 
double S0 (double, double) const
 
gslpp::complex S0c () const
 hep-ph/9512380 More...
 
gslpp::complex S0ct () const
 hep-ph/9512380 More...
 
gslpp::complex S0tt () const
 hep-ph/9512380v1 More...
 
double S1 (double x) const
 
 StandardModelMatching (const StandardModel &SM_i)
 
double Tt (double x) const
 loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220 More...
 
void updateSMParameters ()
 Updates to new Standard Model parameter sets. More...
 
double Wt (double x) const
 loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066 More...
 
double X0t (double x) const
 hep-ph/9512380v1 More...
 
double X1t (double x) const
 hep-ph/1009.0947v2 More...
 
double x_c (const double mu, const orders order=FULLNNLO) const
 
double x_t (const double mu, const orders order=FULLNNLO) const
 
double Xewt (double x, double a, double mu) const
 hep-ph/1009.0947v2 More...
 
double Y0 (double x) const
 
double Y1 (double x, double mu) const
 
- Public Member Functions inherited from ModelMatching
virtual ~ModelMatching ()
 

Protected Attributes

std::vector< WilsonCoefficientvmcbdmm
 
std::vector< WilsonCoefficientvmcbdnn
 
std::vector< WilsonCoefficientvmcBMll
 
std::vector< WilsonCoefficientvmcbnlep
 
std::vector< WilsonCoefficientvmcbnlepCC
 
std::vector< WilsonCoefficientvmcbsg
 
std::vector< WilsonCoefficientvmcbsmm
 
std::vector< WilsonCoefficientvmcbsnn
 
std::vector< WilsonCoefficientvmcbtaunu
 
std::vector< WilsonCoefficientvmcd1
 
std::vector< WilsonCoefficientvmcd1Buras
 
std::vector< WilsonCoefficientvmcd2
 
std::vector< WilsonCoefficientvmcdb
 
std::vector< WilsonCoefficientvmcDLi3j
 
std::vector< WilsonCoefficientvmcDLij
 
std::vector< WilsonCoefficientvmcds
 
std::vector< WilsonCoefficientvmcgminus2mu
 
std::vector< WilsonCoefficientvmck
 
std::vector< WilsonCoefficientvmck2
 
std::vector< WilsonCoefficientvmckcc
 
std::vector< WilsonCoefficientvmckmm
 
std::vector< WilsonCoefficientvmckpnn
 
std::vector< WilsonCoefficientvmcmueconv
 
std::vector< WilsonCoefficientvmcprimeBMll
 
std::vector< WilsonCoefficientvmcprimebsg
 

Private Member Functions

double phi1 (double z) const
 
double phi2 (double x, double y) const
 
double S0 (double) const
 
double S0p (double x) const
 
double S11 (double x) const
 
double S18 (double x) const
 
double setWCBdmm (int i, double x, orders order)
 
double setWCBdmmEW (int i, double x, orders_ew order_ew)
 
double setWCBMll (int i, double x, orders order)
 
double setWCbnlep (int i, double x, orders order)
 
double setWCbnlepEW (int i, double x)
 
double setWCbsg (int i, double x, orders order)
 
double setWCBsmm (int i, double x, orders order)
 
double setWCBsmmEW (int i, double x, orders_ew order_ew)
 

Private Attributes

double Ale
 
double BtNDR
 
double CF
 
double CWBdmmArrayLOqcd [8]
 
double CWBdmmArrayNLOew [8]
 
double CWBdmmArrayNLOewt2 [8]
 
double CWBdmmArrayNLOewt4 [8]
 
double CWBdmmArrayNLOqcd [8]
 
double CWBdmmArrayNNLOqcd [8]
 
double CWBMllArrayLO [19]
 
double CWBMllArrayNLO [19]
 
double CWbnlepArrayLOew [10]
 
double CWbnlepArrayLOqcd [10]
 
double CWbnlepArrayNLOew [10]
 
double CWbnlepArrayNLOqcd [10]
 
double CWbsgArrayLO [8]
 
double CWbsgArrayNLO [8]
 
double CWBsmmArrayLOqcd [8]
 
double CWBsmmArrayNLOew [8]
 
double CWBsmmArrayNLOewt2 [8]
 
double CWBsmmArrayNLOewt4 [8]
 
double CWBsmmArrayNLOqcd [8]
 
double CWBsmmArrayNNLOqcd [8]
 
double CWD1ArrayLO [10]
 
double CWD1ArrayNLO [10]
 
double CWprimebsgArrayLO [8]
 
double CWprimebsgArrayNLO [8]
 
double gamma0
 
double GF
 
double J5
 
double L
 
gslpp::complex lam_t
 
WilsonCoefficient mcbdmm
 
WilsonCoefficient mcbdnn
 
WilsonCoefficient mcBMll
 
WilsonCoefficient mcbnlep
 
WilsonCoefficient mcbnlepCC
 
WilsonCoefficient mcbsg
 
WilsonCoefficient mcbsmm
 
WilsonCoefficient mcbsnn
 
WilsonCoefficient mcbtaunu
 
WilsonCoefficient mcd1
 
WilsonCoefficient mcd1Buras
 
WilsonCoefficient mcdbd2
 
WilsonCoefficient mcdbs2
 
WilsonCoefficient mcdd2
 
WilsonCoefficient mcdk2
 
WilsonCoefficient mcDLi3j
 
WilsonCoefficient mcDLij
 
WilsonCoefficient mcgminus2mu
 
WilsonCoefficient mck
 
WilsonCoefficient mckcc
 
WilsonCoefficient mckmm
 
WilsonCoefficient mckpnn
 
WilsonCoefficient mcmueconv
 
WilsonCoefficient mcprimeBMll
 
WilsonCoefficient mcprimebsg
 
double mu_b
 
double Mut
 
double Muw
 
double Mw
 
double Mw_tree
 
double Nc
 
const StandardModelSM
 
double sw
 
double sW2
 
double swa
 
double swb
 
double swc
 
double swd
 
double swe
 
double swf
 
gslpp::matrix< gslpp::complexVckm
 
double xcachea
 
double xcacheb
 
double xcachec
 
double xcached
 
double xcachee
 
double xcachef
 

Constructor & Destructor Documentation

StandardModelMatching::StandardModelMatching ( const StandardModel SM_i)

Definition at line 17 of file StandardModelMatching.cpp.

18 : ModelMatching(), SM(SM_i),
19  mcdbd2(5, NDR, NLO),
20  mcdbs2(5, NDR, NLO),
21  mcdd2(5, NDR, NLO),
22  mcdk2(5, NDR, NLO),
23  mck(10, NDR, NLO),
24  mckcc(10, NDR, NLO),
25  mcbsg(8, NDR, NLO),
26  mcprimebsg(8, NDR, NLO),
27  mcBMll(13, NDR, NLO),
28  mcprimeBMll(13, NDR, NLO),
29  mcbnlep(10, NDR, NLO, NLO_ew),
30  mcbnlepCC(10, NDR, NLO),
31  mcd1(10, NDR, NLO),
32  mcd1Buras(10, NDR, NLO),
33  mckpnn(1, NDR, NLO, NLO_ew),
34  mckmm(1, NDR, NLO),
35  mcbsnn(1, NDR, NLO),
36  mcbdnn(1, NDR, NLO),
37  mcbsmm(8, NDR, NNLO, NLO_ewt4),
38  mcbdmm(8, NDR, NNLO, NLO_ewt4),
39  mcbtaunu(3, NDR, LO),
40  mcDLij(2, NDR, LO),
41  mcDLi3j(20, NDR, LO),
42  mcmueconv(8, NDR, LO),
43  mcgminus2mu(2, NDR, LO),
44  Vckm(3, 3, 0)
45 {
46  swa = 0.;
47  swb = 0.;
48  swc = 0.;
49  xcachea = 0.;
50  xcacheb = 0.;
51  xcachec = 0.;
52 
53 
54  for (int j=0; j<10; j++) {
55  CWD1ArrayLO[j] = 0.;
56  CWD1ArrayNLO[j] = 0.;
57  CWbnlepArrayLOqcd[j] = 0.;
58  CWbnlepArrayNLOqcd[j] = 0.;
59  CWbnlepArrayLOew[j] = 0.;
60  CWbnlepArrayNLOew[j] = 0.;
61  };
62 
63 
64  for(int j=0; j<19; j++){
65  CWBMllArrayLO[j] = 0.;
66  CWBMllArrayNLO[j] = 0.;
67  }
68 
69  for(int j=0; j<8; j++){
70  CWbsgArrayLO[j] = 0.;
71  CWbsgArrayNLO[j] = 0.;
72  CWprimebsgArrayLO[j] = 0.;
73  CWprimebsgArrayNLO[j] = 0.;
74  }
75 
76  for(int j=0; j<8; j++){
77  CWBsmmArrayNNLOqcd[j] = 0.;
78  CWBsmmArrayNLOqcd[j] = 0.;
79  CWBsmmArrayLOqcd[j] = 0.;
80  CWBsmmArrayNLOewt4[j] = 0.;
81  CWBsmmArrayNLOewt2[j] = 0.;
82  CWBsmmArrayNLOew[j] = 0.;
83  }
84 
85  for(int j=0; j<8; j++){
86  CWBdmmArrayNNLOqcd[j] = 0.;
87  CWBdmmArrayNLOqcd[j] = 0.;
88  CWBdmmArrayLOqcd[j] = 0.;
89  CWBdmmArrayNLOewt4[j] = 0.;
90  CWBdmmArrayNLOewt2[j] = 0.;
91  CWBdmmArrayNLOew[j] = 0.;
92  }
93 
94 
95  Nc = SM.getNc();
96  CF = SM.getCF();
97  gamma0 = 6. * (Nc - 1.) / Nc;
98  J5 = SM.Beta1(5) * gamma0 / 2. / SM.Beta0(5) / SM.Beta0(5) - ((Nc - 1.)/(2. * Nc) * (-21. + 57./Nc - 19./3. * Nc + 20./3.)) / 2. / SM.Beta0(5);
99  BtNDR = 5. * (Nc - 1.) / 2. / Nc + 3. * CF;
100 }
double getCF() const
A get method to access the Casimir factor of QCD.
Definition: QCD.h:932
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
double getNc() const
A get method to access the number of colours .
Definition: QCD.h:840
A class for a template of model matching.
Definition: ModelMatching.h:22
WilsonCoefficient mcprimeBMll
Definition: OrderScheme.h:33
const StandardModel & SM
WilsonCoefficient mcprimebsg
gslpp::matrix< gslpp::complex > Vckm
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
WilsonCoefficient mcgminus2mu

Member Function Documentation

double StandardModelMatching::A0t ( double  x) const

loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 215 of file StandardModelMatching.cpp.

216 {
217  double x2 = x * x;
218  double x3 = x2 * x;
219 
220  return ((-3. * x3 + 2. * x2)/(2. * pow(1. - x, 4.)) * log(x) +
221  (22. * x3 - 153. * x2 + 159. * x - 46.)/(36. * pow(1. - x, 3.)));
222 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::A1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 261 of file StandardModelMatching.cpp.

262 {
263  double x2 = x * x;
264  double x3 = x * x * x;
265  double x4 = x * x * x * x;
266  double xm2 = pow(1. - x, 2);
267  double xm3 = xm2 * (1. - x);
268  double xm4 = xm3 * (1. - x);
269  double xm5 = xm4 * (1. - x);
270  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
272 
273  return ((32. * x4 + 244. * x3 - 160. * x2 + 16. * x)/9./xm4 * gsl_sf_dilog(1.- 1./x) +
274  (-774. * x4 - 2826. * x3 + 1994. *x2 - 130. * x + 8.)/81./xm5 * log(x) +
275  (-94. * x4 - 18665. * x3 + 20682. * x2 - 9113. * x + 2006.)/243./xm4 +
276  ((-12. * x4 - 92. * x3 + 56. * x2)/3./(1.-x)/xm4 * log(x) +
277  (-68. * x4 - 202. * x3 - 804. * x2 + 794. * x - 152.)/27./xm4) * 2. * log(mu/mt));
278 }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::B0b ( double  x) const

loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 504 of file StandardModelMatching.cpp.

505 {
506  return ( 0.25 * ( x / (1. - x) + x / (x * x - 2. * x + 1.) * log(x) ) );
507 }
complex log(const complex &z)
double StandardModelMatching::B0t ( double  x) const

loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 224 of file StandardModelMatching.cpp.

225 {
226  return( x / (4.* (1. - x) * (1. - x)) * log(x) + 1. / (4. * (1. - x)) );
227 }
complex log(const complex &z)
double StandardModelMatching::B1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 280 of file StandardModelMatching.cpp.

281 {
282  double x2 = x * x;
283  double xm2 = pow(1. - x, 2);
284  double xm3 = pow(1. - x, 3);
285  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
287 
288  return (-2. * x)/xm2 * gsl_sf_dilog(1.- 1./x) + (-x2 + 17. * x)/(3. * xm3)*log(x) + (13. * x + 3.)/(3. * xm2) +
289  ( (2. * x2 + 2. * x)/xm3*log(x) + (4. * x)/xm2 ) * 2. * log(mu / mt);
290  /*(2. * x)/xm2 * gsl_sf_dilog(1.-x) + (3. * x2 + x)/xm3 * log(x) * log(x) + (-11. * x2 - 5. * x)/(3. * xm3) * log(x) +
291  (-3. * x2 + 19. * x)/(3. * xm2) + 16. * x * (2. * (x - 1.) - (1. + x) * log(x))/(4. * xm3) * log(mu / Mw);*/
292 }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::C0b ( double  x) const

loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 509 of file StandardModelMatching.cpp.

510 {
511  return ( x / 8. * ( (x - 6.) / (x - 1.) + (3. * x + 2.) / ( x * x - 2. * x + 1.) * log(x) ) );
512 }
complex log(const complex &z)
double StandardModelMatching::C0t ( double  x) const

loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 229 of file StandardModelMatching.cpp.

230 {
231  return( (3. * x * x + 2. * x) / (8. * (1. - x) * (1. - x)) * log(x) + (-x * x + 6. * x) / (8. * (1. - x)) );
232 }
complex log(const complex &z)
double StandardModelMatching::C1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 294 of file StandardModelMatching.cpp.

295 {
296  double x2 = x * x;
297  double x3 = x * x2;
298  double xm2 = pow(1. - x, 2);
299  double xm3 = pow(1. - x, 3);
300  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
302 
303  return (-x3 - 4. * x)/xm2 * gsl_sf_dilog(1.- 1./x) + (3. * x3 + 14. * x2 + 23 * x)/(3. * xm3)*log(x) +
304  (4. * x3 + 7. * x2 + 29. * x)/(3. * xm2) + ( (8. * x2 + 2. * x)/xm3*log(x) + (x3 + x2 + 8. * x)/xm2) * 2. * log(mu / mt);
305  /*(x3 + 4. * x)/xm2 * gsl_sf_dilog(1.-x) + (x4 - x3 + 20. * x2)/(2. * xm3) * log(x) * log(x) +
306  (-3. * x4 - 3. * x3 - 35. * x2 + x)/(3. * xm3) * log(x) + (4. * x3 + 7. * x2 + 29. * x)/(3. * xm2) +
307  16. * x * (-8. + 7. * x + x3 - 2. * (1. + 4. * x) * log(x))/(8. * xm3) * log(mu / Mw);*/
308 }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::C7LOeff ( double  x) const

loop function which appear in the Wilson coefficient for the magnetic operator in the effective Misiak basis, LO term, Chetyrkin et al hep-ph/9612313

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 447 of file StandardModelMatching.cpp.

448 {
449  double x2 = x * x;
450  double x3 = x2 * x;
451 
452  return( (3. * x3 - 2. * x2) / (4. * pow(x - 1., 4.)) * log(x) + (-8. * x3 - 5. * x2 +
453  7. * x) / (24. * pow(x-1.,3.)));
454 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::C7NLOeff ( double  x) const

loop function which appear in the Wilson coefficient for the magnetic operator in the effective Misiak basis, NLO term, Chetyrkin et al hep-ph/9612313

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 461 of file StandardModelMatching.cpp.

462 {
463  double x2 = x * x;
464  double x3 = x2 * x;
465  double x4 = x3 * x;
466  double xm4 = pow(x-1.,4.);
467  double xm5 = xm4 * (x - 1);
468  double logx = log(x);
469 
470  double Li2 = gsl_sf_dilog(1.-1./x);
471  return( Li2 * ( -16. * x4 - 122. * x3 + 80. * x2 - 8. * x) / (9. * xm4) +
472  (6. * x4 + 46. * x3 -28. * x2) / (3. * xm5) * logx * logx +
473  (-102. * x4 * x - 588. * x4 - 2262. * x3 + 3244. * x2 - 1364. * x + 208.) / (81. * xm5) * logx +
474  (1646. * x4 + 12205. * x3 - 10740. * x2 + 2509. * x - 436.) / (486. * xm4));
475 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::C8LOeff ( double  x) const

loop function which appear in the Wilson coefficient for the chromomagnetic operator in the effective Misiak basis, LO term, Chetyrkin et al hep-ph/9612313

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 456 of file StandardModelMatching.cpp.

457 {
458  return( -3. * x * x / (4. * pow( x - 1., 4.)) * log(x) + (-x * x * x + 5. * x * x + 2. * x) / (8. * pow(x - 1., 3)) );
459 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::C8NLOeff ( double  x) const

loop function which appear in the Wilson coefficient for the chromomagnetic operator in the effective Misiak basis, LO term, Chetyrkin et al hep-ph/9612313

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 477 of file StandardModelMatching.cpp.

478 {
479  double x2 = x * x;
480  double x3 = x2 * x;
481  double x4 = x3 * x;
482  double xm4 = pow(x-1.,4.);
483  double xm5 = xm4 * (x - 1);
484  double logx = log(x);
485 
486  double Li2 = gsl_sf_dilog(1.-1./x);
487  return(Li2 * ( -4. * x4 + 40. * x3 + 41. * x2 + x) / (6. * xm4) +
488  (-17. * x3 - 31. * x2) / (2. * xm5) * logx * logx +
489  (-210. * x * x4 + 1086. * x4 + 4893. * x3 + 2857. * x2 - 1994. * x + 280.)/(216. * xm5) * logx +
490  (737. * x4 - 14102. * x3 - 28209. * x2 + 610. * x - 508.) / (1296. * xm4));
491 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
std::vector< WilsonCoefficient > & StandardModelMatching::CMbdmm ( )
virtual
Returns
Wilson coefficient for \( B_{d} \rightarrow \mu \mu \)

Definition at line 1482 of file StandardModelMatching.cpp.

1482  {
1483 
1484  // The couplings are not used here, but in the Bdmumu class.
1485 
1486  double xt = x_t(Muw);
1487 
1488  vmcbdmm.clear();
1489 
1490 
1491 
1492  switch (mcbdmm.getScheme()) {
1493  case NDR:
1494  //case HV:
1495  //case LRI:
1496  break;
1497  default:
1498  std::stringstream out;
1499  out << mcbdmm.getScheme();
1500  throw std::runtime_error("StandardModel::CMbdmm(): scheme " + out.str() + "not implemented");
1501  }
1502 
1503  mcbdmm.setMu(Muw);
1504 
1505  switch (mcbdmm.getOrder()) {
1506  case NNLO:
1507 
1508  for (int j=0; j<8; j++){
1509 
1510  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) *
1511  setWCBdmm(j, xt, NNLO), NNLO);
1512  }
1513  case NLO:
1514 
1515  for (int j=0; j<8; j++){
1516 
1517  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) *
1518  setWCBdmm(j, xt, NLO), NLO);
1519  }
1520  case LO:
1521 
1522  for (int j=0; j<8; j++){
1523 
1524  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) * setWCBdmm(j, xt, LO), LO);
1525  }
1526  break;
1527  default:
1528  std::stringstream out;
1529  out << mcbdmm.getOrder();
1530  throw std::runtime_error("StandardModelMatching::CMbdmm(): order " + out.str() + "not implemented");
1531  }
1532 
1533  switch (mcbdmm.getOrder_ew()) {
1534  case NLO_ewt4:
1535  ;
1536  for (int j=0; j<8; j++){
1537 
1538  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) * setWCBdmmEW(j, xt, NLO_ewt4), NLO_ewt4);
1539 
1540  }
1541  case NLO_ewt3: /*absent at high energy */
1542  for (int j=0; j<8; j++){
1543 
1544  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) * 0., NLO_ewt3);
1545  }
1546  case NLO_ewt2:
1547 
1548  for (int j=0; j<8; j++){
1549 
1550  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) * setWCBdmmEW(j, xt, NLO_ewt2), NLO_ewt2);
1551  }
1552  case NLO_ewt1: /*absent at high energy */
1553  for (int j=0; j<8; j++){
1554 
1555  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) * 0., NLO_ewt1);
1556  }
1557  case NLO_ew:
1558  for (int j=0; j<8; j++){
1559 
1560  mcbdmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,0)) * setWCBdmmEW(j, xt, NLO_ew), NLO_ew);
1561 
1562  }
1563  case LO_ew: /*absent at high energy */
1564  for (int j=0; j<8; j++){
1565 
1566  mcbdmm.setCoeff(j,(Vckm(2,2).conjugate() * Vckm(2,0)) * 0., LO_ew);
1567  }
1568  break;
1569  default:
1570  std::stringstream out;
1571  out << mcbdmm.getOrder_ew();
1572  throw std::runtime_error("StandardModelMatching::CMbdmm(): order_ew " + out.str() + "not implemented");
1573  }
1574  vmcbdmm.push_back(mcbdmm);
1575  return(vmcbdmm);
1576 
1577 }
virtual void setMu(double mu)
double setWCBdmmEW(int i, double x, orders_ew order_ew)
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
orders_ew getOrder_ew() const
Definition: OrderScheme.h:33
std::vector< WilsonCoefficient > vmcbdmm
gslpp::matrix< gslpp::complex > Vckm
double setWCBdmm(int i, double x, orders order)
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMBMll ( )
virtual

operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic

Returns
Wilson coefficients, Misiak basis, for \( B \rightarrow K^* l^{+} l{-} \)

Implements ModelMatching.

Reimplemented in FlavourWilsonCoefficientMatching.

Definition at line 1228 of file StandardModelMatching.cpp.

1229  {
1230  double xt = x_t(Muw); //* ORDER FULLNNLO*//
1231 
1232  vmcBMll.clear();
1233 
1234  switch (mcBMll.getScheme()) {
1235  case NDR:
1236  //case HV:
1237  //case LRI:
1238  break;
1239  default:
1240  std::stringstream out;
1241  out << mcBMll.getScheme();
1242  throw std::runtime_error("StandardModel::CMBKstrall(): scheme " + out.str() + "not implemented");
1243  }
1244 
1245  mcBMll.setMu(Muw);
1246 
1247  switch (mcBMll.getOrder()) {
1248  case NNLO:
1249  case NLO:
1250  for (int j=0; j<13; j++){
1251  mcBMll.setCoeff(j, SM.Als(Muw, FULLNNLO) / 4. / M_PI * setWCBMll(j, xt, NLO) , NLO);
1252  }
1253  case LO:
1254  for (int j=0; j<13; j++){
1255  mcBMll.setCoeff(j, setWCBMll(j, xt, LO), LO);
1256  }
1257  break;
1258  default:
1259  std::stringstream out;
1260  out << mcBMll.getOrder();
1261  throw std::runtime_error("StandardModelMatching::CMBKstrall(): order " + out.str() + "not implemented");
1262  }
1263 
1264  vmcBMll.push_back(mcBMll);
1265  return(vmcBMll);
1266 }
virtual void setMu(double mu)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
double setWCBMll(int i, double x, orders order)
const StandardModel & SM
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > vmcBMll
std::vector< WilsonCoefficient > & StandardModelMatching::CMbnlep ( int  a)
virtual

operator basis:

current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic

Parameters
[in]aa=0 deltaS=0 deltaC=0; a=1 deltaS=1 deltaC=0;
Returns
Wilson coefficients Buras base for non-leptonic B decays

Implements ModelMatching.

Definition at line 1618 of file StandardModelMatching.cpp.

1619 {
1620  gslpp::complex lambda;
1621 
1622  switch (a) {
1623  case 0: lambda = SM.computelamt_d();
1624  break;
1625  case 1: lambda = SM.computelamt_s();
1626  break;
1627  default:
1628  std::stringstream out;
1629  out << a;
1630  throw std::runtime_error("case" + out.str() + "not implemented; implemented i=0,1,2,3");
1631  }
1632 
1633  double xt = x_t(Muw);
1634  double co = ( GF / sqrt(2));
1635 
1636  vmcbnlep.clear();
1637 
1638  switch (mcbnlep.getScheme()) {
1639  case NDR:
1640  //case HV:
1641  //case LRI:
1642  break;
1643  default:
1644  std::stringstream out;
1645  out << mcbnlep.getScheme();
1646  throw std::runtime_error("StandardModel::CMbsg(): scheme " + out.str() + "not implemented");
1647  }
1648 
1649  mcbnlep.setMu(Muw);
1650 
1651  switch (mcbnlep.getOrder()) {
1652  case NNLO:
1653  case NLO:
1654  for (int j=0; j<10; j++){
1655  mcbnlep.setCoeff(j,co * lambda * SM.Als(Muw, FULLNLO) / 4. / M_PI * //* CHECK ORDER *//
1656  setWCbnlep(j, xt, NLO), NLO);
1657  mcbnlep.setCoeff(j, co * lambda * Ale / 4. / M_PI *
1658  setWCbnlepEW(j, xt), NLO_ew);
1659  }
1660  case LO:
1661  for (int j=0; j<10; j++){
1662  mcbnlep.setCoeff(j, co * lambda * setWCbnlep(j, xt, LO), LO);
1663  mcbnlep.setCoeff(j, 0., LO_ew);
1664  }
1665  break;
1666  default:
1667  std::stringstream out;
1668  out << mcbnlep.getOrder();
1669  throw std::runtime_error("StandardModelMatching::CMbsg(): order " + out.str() + "not implemented");
1670  }
1671 
1672  vmcbnlep.push_back(mcbnlep);
1673  return(vmcbnlep);
1674 }
virtual void setMu(double mu)
std::vector< WilsonCoefficient > vmcbnlep
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
gslpp::complex computelamt_d() const
The product of the CKM elements .
Definition: OrderScheme.h:33
const StandardModel & SM
double setWCbnlep(int i, double x, orders order)
double setWCbnlepEW(int i, double x)
gslpp::complex computelamt_s() const
The product of the CKM elements .
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
complex sqrt(const complex &z)
std::vector< WilsonCoefficient > & StandardModelMatching::CMbnlepCC ( int  a)
virtual

operator basis: - current current opertors

Parameters
[in]aa=0 deltaS=0 deltaC=0; a=1 1,0 ; a=2 0,1 ; a=3 1,1
Returns
Wilson coefficients, Buras basis, for non-leptonic B decays

Implements ModelMatching.

Definition at line 1681 of file StandardModelMatching.cpp.

1682 {
1683  gslpp::complex lambda1 = 0.;
1684  //gslpp::complex lambda2 = 0.;
1685  //gslpp::matrix<gslpp::complex> ckm = SM.getVCKM();
1686 
1687  switch (a) {
1688  case 0: lambda1 = SM.computelamu_d();
1689  break;
1690  case 1: lambda1 = SM.computelamu_s();
1691  break;
1692  case 2: lambda1 = Vckm(0,2).conjugate()*Vckm(1,0);
1693  break;
1694  case 3: lambda1 = Vckm(1,2).conjugate()*Vckm(0,0);
1695  break;
1696  case 4: lambda1 = Vckm(0,2).conjugate()*Vckm(1,1);
1697  break;
1698  case 5: lambda1 = Vckm(1,2).conjugate()*Vckm(2,1);
1699  break;
1700  default:
1701  std::stringstream out;
1702  out << a;
1703  throw std::runtime_error("case" + out.str() + " not existing; implemented i=0,1,2,3");
1704  }
1705 
1706  double xt = x_t(Muw);
1707  double co = ( GF / sqrt(2));
1708 
1709  vmcbnlepCC.clear();
1710 
1711  switch (mcbnlepCC.getScheme()) {
1712  case NDR:
1713  //case HV:
1714  //case LRI:
1715  break;
1716  default:
1717  std::stringstream out;
1718  out << mcbnlepCC.getScheme();
1719  throw std::runtime_error("StandardModel::CMbsg(): scheme " + out.str() + "not implemented");
1720  }
1721 
1722  mcbnlepCC.setMu(Muw);
1723 
1724  switch (mcbnlepCC.getOrder()) {
1725  case NNLO:
1726  case NLO:
1727  for (int j=0; j<2; j++){
1728  mcbnlepCC.setCoeff(j, co * lambda1 * setWCbnlep(j, xt, NLO), NLO);
1729  }
1730  for (int j=2; j<10; j++){
1731  mcbnlepCC.setCoeff(j, 0. , NLO);
1732  }
1733  case LO:
1734  for (int j=0; j<2; j++){
1735  mcbnlepCC.setCoeff(j, co * lambda1 * setWCbnlep(j, xt, LO), LO); }
1736  for (int j=2; j<10; j++){
1737  mcbnlepCC.setCoeff(j, 0. , LO); }
1738  break;
1739  default:
1740  std::stringstream out;
1741  out << mcbnlepCC.getOrder();
1742  throw std::runtime_error("StandardModelMatching::CMbsg(): order " + out.str() + "not implemented");
1743  }
1744 
1745  vmcbnlepCC.push_back(mcbnlepCC);
1746  return(vmcbnlepCC);
1747 }
virtual void setMu(double mu)
An observable class for the quartic Higgs potential coupling .
std::vector< WilsonCoefficient > vmcbnlepCC
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
double setWCbnlep(int i, double x, orders order)
gslpp::complex computelamu_d() const
The product of the CKM elements .
gslpp::matrix< gslpp::complex > Vckm
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
gslpp::complex computelamu_s() const
The product of the CKM elements .
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
complex sqrt(const complex &z)
std::vector< WilsonCoefficient > & StandardModelMatching::CMbsg ( )
virtual

operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic

Returns
Wilson coefficients, Misiak basis, for \( B \rightarrow X_{s} \gamma, l^{+} l{-} \)

Implements ModelMatching.

Reimplemented in FlavourWilsonCoefficientMatching.

Definition at line 1079 of file StandardModelMatching.cpp.

1080 {
1081  double xt = x_t(Muw);
1082  gslpp::complex co = 1.; // (- 4. * GF / sqrt(2)) * SM.computelamt_s(); THIS SHOULD ALREADY BE IMPLEMENTED IN THE OBSERVABLE
1083 
1084  vmcbsg.clear();
1085 
1086  switch (mcbsg.getScheme()) {
1087  case NDR:
1088  //case HV:
1089  //case LRI:
1090  break;
1091  default:
1092  std::stringstream out;
1093  out << mcbsg.getScheme();
1094  throw std::runtime_error("StandardModel::CMbsg(): scheme " + out.str() + "not implemented");
1095  }
1096 
1097  mcbsg.setMu(Muw);
1098 
1099  switch (mcbsg.getOrder()) {
1100  case NNLO:
1101  case NLO:
1102  for (int j=0; j<8; j++){
1103  mcbsg.setCoeff(j, co * SM.Alstilde5(Muw) * setWCbsg(j, xt, NLO) , NLO);//* CHECK ORDER *//
1104  }
1105  case LO:
1106  for (int j=0; j<8; j++){
1107  mcbsg.setCoeff(j, co * setWCbsg(j, xt, LO), LO);
1108  }
1109  break;
1110  default:
1111  std::stringstream out;
1112  out << mcbsg.getOrder();
1113  throw std::runtime_error("StandardModelMatching::CMbsg(): order " + out.str() + "not implemented");
1114  }
1115 
1116  vmcbsg.push_back(mcbsg);
1117  return(vmcbsg);
1118 }
virtual void setMu(double mu)
std::vector< WilsonCoefficient > vmcbsg
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
double setWCbsg(int i, double x, orders order)
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
std::vector< WilsonCoefficient > & StandardModelMatching::CMbsmm ( )
virtual
Returns
Wilson coefficient for \( B_{s} \rightarrow \mu \mu \)

Definition at line 1377 of file StandardModelMatching.cpp.

1377  {
1378 
1379  // The couplings are not used here, but in the Bsmumu class.
1380 
1381  double xt = x_t(Muw);
1382 
1383  vmcbsmm.clear();
1384 
1385 
1386 
1387  switch (mcbsmm.getScheme()) {
1388  case NDR:
1389  //case HV:
1390  //case LRI:
1391  break;
1392  default:
1393  std::stringstream out;
1394  out << mcbsmm.getScheme();
1395  throw std::runtime_error("StandardModel::CMbsmm(): scheme " + out.str() + "not implemented");
1396  }
1397 
1398  mcbsmm.setMu(Muw);
1399 
1400  switch (mcbsmm.getOrder()) {
1401  case NNLO:
1402 
1403  for (int j=0; j<8; j++){
1404 
1405  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) *
1406  setWCBsmm(j, xt, NNLO), NNLO);
1407 
1408  }
1409  case NLO:
1410 
1411  for (int j=0; j<8; j++){
1412 
1413  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) *
1414  setWCBsmm(j, xt, NLO), NLO);
1415  }
1416  case LO:
1417 
1418  for (int j=0; j<8; j++){
1419 
1420  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) * setWCBsmm(j, xt, LO), LO);
1421  }
1422  break;
1423  default:
1424  std::stringstream out;
1425  out << mcbsmm.getOrder();
1426  throw std::runtime_error("StandardModelMatching::CMbsmm(): order " + out.str() + "not implemented");
1427  }
1428 
1429  switch (mcbsmm.getOrder_ew()) {
1430  case NLO_ewt4:
1431  ;
1432  for (int j=0; j<8; j++){
1433 
1434  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) * setWCBsmmEW(j, xt, NLO_ewt4), NLO_ewt4);
1435 
1436  }
1437  case NLO_ewt3: /*absent at high energy */
1438  for (int j=0; j<8; j++){
1439 
1440  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) * 0., NLO_ewt3);
1441  }
1442  case NLO_ewt2:
1443 
1444  for (int j=0; j<8; j++){
1445 
1446  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) * setWCBsmmEW(j, xt, NLO_ewt2), NLO_ewt2);
1447  }
1448  case NLO_ewt1: /*absent at high energy */
1449  for (int j=0; j<8; j++){
1450 
1451  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) * 0., NLO_ewt1);
1452  }
1453  case NLO_ew:
1454  for (int j=0; j<8; j++){
1455 
1456  mcbsmm.setCoeff(j, (Vckm(2,2).conjugate() * Vckm(2,1)) * setWCBsmmEW(j, xt, NLO_ew), NLO_ew);
1457 
1458  }
1459  case LO_ew: /*absent at high energy */
1460  for (int j=0; j<8; j++){
1461 
1462  mcbsmm.setCoeff(j,(Vckm(2,2).conjugate() * Vckm(2,1)) * 0., LO_ew);
1463  }
1464  break;
1465  default:
1466  std::stringstream out;
1467  out << mcbsmm.getOrder_ew();
1468  throw std::runtime_error("StandardModelMatching::CMbsmm(): order_ew " + out.str() + "not implemented");
1469  }
1470  vmcbsmm.push_back(mcbsmm);
1471  return(vmcbsmm);
1472 
1473 }
virtual void setMu(double mu)
double setWCBsmm(int i, double x, orders order)
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
orders_ew getOrder_ew() const
Definition: OrderScheme.h:33
gslpp::matrix< gslpp::complex > Vckm
std::vector< WilsonCoefficient > vmcbsmm
double setWCBsmmEW(int i, double x, orders_ew order_ew)
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMbtaunu ( )
virtual
Returns
Wilson coefficient for \( B \rightarrow \tau \nu \)

Reimplemented in THDMMatching.

Definition at line 1584 of file StandardModelMatching.cpp.

1584  {
1585 
1586  vmcbtaunu.clear();
1587 
1588  mcbtaunu.setMu(Muw);
1589 
1590  switch (mcbtaunu.getOrder()) {
1591  case NNLO:
1592  case NLO:
1593  case LO:
1594  mcbtaunu.setCoeff(0, 4.*GF * Vckm(0,2) / sqrt(2.) , LO);
1595  break;
1596  default:
1597  std::stringstream out;
1598  out << mcbsmm.getOrder();
1599  throw std::runtime_error("StandardModelMatching::CMbsmm(): order " + out.str() + "not implemented");
1600  }
1601 
1602  vmcbtaunu.push_back(mcbtaunu);
1603  return(vmcbtaunu);
1604 
1605 }
virtual void setMu(double mu)
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
gslpp::matrix< gslpp::complex > Vckm
std::vector< WilsonCoefficient > vmcbtaunu
orders getOrder() const
complex sqrt(const complex &z)
std::vector< WilsonCoefficient > & StandardModelMatching::CMBXdnn ( )
virtual
Returns
Wilson coefficients for \( B_{d} \rightarrow X_{d} \nu \nu \)

Definition at line 1846 of file StandardModelMatching.cpp.

1846  {
1847 
1848  double xt = x_t(Muw);
1849 
1850  vmcbdnn.clear();
1851 
1852  mcbdnn.setMu(Mut);
1853 
1854  switch (mcbdnn.getOrder()) {
1855  case NNLO:
1856  case NLO:
1857  mcbsnn.setCoeff(0, (Vckm(2,2).abs() / Vckm(1,2).abs()) *
1858  SM.Als(Muw, FULLNLO)/4./M_PI*X1t(xt), NLO);//* CHECK ORDER *//
1859  case LO:
1860  mcbsnn.setCoeff(0, (Vckm(2,2).abs() / Vckm(1,2).abs()) *
1861  X0t(xt), LO);
1862  break;
1863  default:
1864  std::stringstream out;
1865  out << mcbdnn.getOrder();
1866  throw std::runtime_error("StandardModelMatching::CXdnn(): order " + out.str() + "not implemented");
1867  }
1868 
1869  vmcbdnn.push_back(mcbdnn);
1870  return(vmcbdnn);
1871 
1872 }
virtual void setMu(double mu)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double X0t(double x) const
hep-ph/9512380v1
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
std::vector< WilsonCoefficient > vmcbdnn
Definition: OrderScheme.h:33
const StandardModel & SM
gslpp::matrix< gslpp::complex > Vckm
double X1t(double x) const
hep-ph/1009.0947v2
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMBXsnn ( )
virtual
Returns
Wilson coefficients for \( B_{s} \rightarrow X_{s} \nu \nu \)

Definition at line 1818 of file StandardModelMatching.cpp.

1818  {
1819 
1820  double xt = x_t(Muw);
1821 
1822  vmcbsnn.clear();
1823 
1824  mcbsnn.setMu(Mut);
1825 
1826  switch (mcbsnn.getOrder()) {
1827  case NNLO:
1828  case NLO:
1829  mcbsnn.setCoeff(0, (Vckm(2,1).abs() / Vckm(1,2).abs())*
1830  SM.Als(Muw, FULLNLO)/4./M_PI*X1t(xt), NLO);//* CHECK ORDER *//
1831  case LO:
1832  mcbsnn.setCoeff(0, (Vckm(2,1).abs() / Vckm(1,2).abs())*
1833  X0t(xt), LO);
1834  break;
1835  default:
1836  std::stringstream out;
1837  out << mcbsnn.getOrder();
1838  throw std::runtime_error("StandardModelMatching::CMXsnn(): order " + out.str() + "not implemented");
1839  }
1840 
1841  vmcbsnn.push_back(mcbsnn);
1842  return(vmcbsnn);
1843 
1844 }
virtual void setMu(double mu)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double X0t(double x) const
hep-ph/9512380v1
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
std::vector< WilsonCoefficient > vmcbsnn
Definition: OrderScheme.h:33
const StandardModel & SM
gslpp::matrix< gslpp::complex > Vckm
double X1t(double x) const
hep-ph/1009.0947v2
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMd1 ( )
virtual

current-current oerators, Misiak basis

Returns
Wilson coefficients for \( D^{0} \rightarrow \pi \pi , K K \)

Implements ModelMatching.

Reimplemented in SUSYMassInsertionMatching.

Definition at line 898 of file StandardModelMatching.cpp.

899 {
900  vmcd1.clear();
901 
902  switch (mcd1.getScheme()) {
903  case NDR:
904  //case HV:
905  //case LRI:
906  break;
907  default:
908  std::stringstream out;
909  out << mcd1.getScheme();
910  throw std::runtime_error("StandardModel::CMd1(): scheme " + out.str() + "not implemented");
911  }
912 
913  mcd1.setMu(Muw);
914 
915  switch (mcd1.getOrder()) {
916  case NNLO:
917  case NLO:
918  mcd1.setCoeff(0, SM.Als(Muw, FULLNLO) / 4. / M_PI * 15. , NLO); //* CHECK ORDER *//
919  for (int j=1; j<10; j++){
920  mcd1.setCoeff(j, 0., NLO);
921  }
922  case LO:
923  mcd1.setCoeff(0, 0. , LO);
924  mcd1.setCoeff(1, 1. , LO);
925  for (int j=2; j<10; j++){
926  mcd1.setCoeff(j, 0., LO);
927  }
928  break;
929  default:
930  std::stringstream out;
931  out << mcd1.getOrder();
932  throw std::runtime_error("StandardModelMatching::CMd1(): order " + out.str() + "not implemented");
933  }
934 
935  vmcd1.push_back(mcd1);
936 
937  return(vmcd1);
938 
939 }
virtual void setMu(double mu)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
std::vector< WilsonCoefficient > vmcd1
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMd1Buras ( )
virtual

current-current oerators, Buras basis

Returns
Wilson coefficients for \( D^{0} \rightarrow \pi \pi , K K \)

Implements ModelMatching.

Definition at line 854 of file StandardModelMatching.cpp.

855 {
856  vmcd1Buras.clear();
857 
858  switch (mcd1Buras.getScheme()) {
859  case NDR:
860  //case HV:
861  //case LRI:
862  break;
863  default:
864  std::stringstream out;
865  out << mcd1Buras.getScheme();
866  throw std::runtime_error("StandardModel::CMd1Buras(): scheme " + out.str() + "not implemented");
867  }
868 
870 
871  switch (mcd1Buras.getOrder()) {
872  case NNLO:
873  case NLO:
874  mcd1Buras.setCoeff(0, SM.Als(Muw, FULLNLO) / 4. / M_PI * 11./2. , NLO); //* CHECK ORDER *//
875  mcd1Buras.setCoeff(1, SM.Als(Muw, FULLNLO) / 4. / M_PI * (-11./6.) , NLO);
876  for (int j=2; j<10; j++){
877  mcd1Buras.setCoeff(j, 0., NLO);
878  }
879  case LO:
880  mcd1Buras.setCoeff(0, 0., LO);
881  mcd1Buras.setCoeff(1, 1., LO);
882  for (int j=2; j<10; j++){
883  mcd1Buras.setCoeff(j, 0., LO);
884  }
885  break;
886  default:
887  std::stringstream out;
888  out << mcd1Buras.getOrder();
889  throw std::runtime_error("StandardModelMatching::CMd1Buras(): order " + out.str() + "not implemented");
890  }
891 
892  vmcd1Buras.push_back(mcd1Buras);
893 
894  return(vmcd1Buras);
895 
896 }
virtual void setMu(double mu)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
std::vector< WilsonCoefficient > vmcd1Buras
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMdbd2 ( )
virtual

\( \Delta B = 2 \), \( B_{d} \)

Returns
return the vector of SM Wilson coefficients

Implements ModelMatching.

Reimplemented in SUSYMassInsertionMatching.

Definition at line 734 of file StandardModelMatching.cpp.

735 {
736  double gammam = 6. * CF;
737  double Bt;
738 
739 
740  double xt = x_t(Mut);
741  gslpp::complex co = GF / 4. / M_PI * Mw * SM.computelamt_d();
742 
743  vmcdb.clear();
744 
745  switch (mcdbd2.getScheme()) {
746  case NDR:
747  Bt = BtNDR;
748  break;
749  case HV:
750  case LRI:
751  default:
752  std::stringstream out;
753  out << mcdbd2.getScheme();
754  throw std::runtime_error("StandardModel::CMdb2(): scheme " + out.str() + "not implemented");
755  }
756 
757  mcdbd2.setMu(Mut);
758 
759  switch (mcdbd2.getOrder()) {
760  case NNLO:
761  case NLO:
762  mcdbd2.setCoeff(0, co * co * 4. * (SM.Als(Mut, FULLNLO) / 4. / M_PI * (S1(xt) + //* CHECK ORDER *//
763  (Bt + gamma0 * log(Mut / Mw)) * S0(xt, xt) + 2. * gammam * S0p(xt) * log(Mut / Mw))), NLO);
764 #if SUSYFIT_DEBUG & 1
765  std::cout << "Mw = " << Mw << " xt(muw=" << Muw << ")= " << xt << "matching of DB=2: S0(xt) = " << S0(xt) <<
766  ", S1(xt) = " << S1(xt) +
767  (Bt + gamma0 * log(Muw / Mw)) * S0(xt, xt) + 2. * gammam * S0p(xt) * log(Muw / Mw)
768  << ", lambdat_d^2 = " << SM.getlamt_d()*SM.getlamt_d() << std::endl;
769 #endif
770  case LO:
771  mcdbd2.setCoeff(0, co * co * 4. * (S0(xt, xt)), LO);
772  break;
773  default:
774  std::stringstream out;
775  out << mcdbd2.getOrder();
776  throw std::runtime_error("StandardModelMatching::CMdbd2(): order " + out.str() + "not implemented");
777  }
778 
779 
780  vmcdb.push_back(mcdbd2);
781  return(vmcdb);
782 }
virtual void setMu(double mu)
double S1(double x) const
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double S0p(double x) const
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
gslpp::complex computelamt_d() const
The product of the CKM elements .
std::vector< WilsonCoefficient > vmcdb
Definition: OrderScheme.h:33
const StandardModel & SM
Definition: OrderScheme.h:22
An observable class for the -boson mass.
Definition: Mw.h:22
double S0(double, double) const
complex log(const complex &z)
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
std::vector< WilsonCoefficient > & StandardModelMatching::CMdbs2 ( )
virtual

\( \Delta B = 2 \), \( B_{s} \)

Returns
return the vector of SM Wilson coefficients

Implements ModelMatching.

Reimplemented in SUSYMassInsertionMatching, and THDMMatching.

Definition at line 784 of file StandardModelMatching.cpp.

785 {
786  double gammam = 6. * CF;
787  double Bt;
788  double xt = x_t(Mut);
789  gslpp::complex co = GF / 4. / M_PI * Mw * SM.computelamt_s();
790 
791  vmcds.clear();
792 
793  switch (mcdbs2.getScheme()) {
794  case NDR:
795  Bt = BtNDR;
796  break;
797  case HV:
798  case LRI:
799  default:
800  std::stringstream out;
801  out << mcdbs2.getScheme();
802  throw std::runtime_error("StandardModel::CMdbs2(): scheme " + out.str() + "not implemented");
803  }
804 
805  mcdbs2.setMu(Mut);
806 
807  switch (mcdbs2.getOrder()) {
808  case NNLO:
809  case NLO:
810  mcdbs2.setCoeff(0, co * co * 4. * (SM.Als(Mut, FULLNLO) / 4. / M_PI * (S1(xt) + //* CHECK ORDER *//
811  (Bt + gamma0 * log(Mut / Mw)) * S0(xt, xt) + 2. * gammam * S0p(xt) * log(Mut / Mw))), NLO);
812  case LO:
813  mcdbs2.setCoeff(0, co * co * 4. * (S0(xt, xt)), LO);
814  break;
815  default:
816  std::stringstream out;
817  out << mcdbs2.getOrder();
818  throw std::runtime_error("StandardModelMatching::CMdbs2(): order " + out.str() + "not implemented");
819  }
820 
821  vmcds.push_back(mcdbs2);
822  return(vmcds);
823 }
virtual void setMu(double mu)
double S1(double x) const
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double S0p(double x) const
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
gslpp::complex computelamt_s() const
The product of the CKM elements .
Definition: OrderScheme.h:22
std::vector< WilsonCoefficient > vmcds
An observable class for the -boson mass.
Definition: Mw.h:22
double S0(double, double) const
complex log(const complex &z)
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
std::vector< WilsonCoefficient > & StandardModelMatching::CMdd2 ( )
virtual

\( \Delta C = 2 \),

Returns
return the vector of SM Wilson coefficients

Implements ModelMatching.

Reimplemented in SUSYMassInsertionMatching.

Definition at line 941 of file StandardModelMatching.cpp.

942 {
943  vmcd2.clear();
944 
945  switch (mcdd2.getScheme()) {
946  case NDR:
947  case HV:
948  case LRI:
949  break;
950  default:
951  std::stringstream out;
952  out << mcdd2.getScheme();
953  throw std::runtime_error("StandardModel::CMdd2(): scheme " + out.str() + "not implemented");
954  }
955 
956  mcdd2.setMu(Muw);
957 
958  switch (mcdd2.getOrder()) {
959  case NNLO:
960  case NLO:
961  for(int i=0; i<5; i++)
962  mcdd2.setCoeff(i, 0., NLO);
963  case LO:
964  for(int j=0; j<5; j++)
965  mcdd2.setCoeff(j, 0., LO);
966  break;
967  default:
968  std::stringstream out;
969  out << mcdd2.getOrder();
970  throw std::runtime_error("StandardModelMatching::CMdd2(): order " + out.str() + "not implemented");
971  }
972 
973  vmcd2.push_back(mcdd2);
974  return(vmcd2);
975 }
std::vector< WilsonCoefficient > vmcd2
virtual void setMu(double mu)
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
Definition: OrderScheme.h:22
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMdk2 ( )
virtual

\( \Delta S = 2 \)

Returns
return the vector of SM Wilson coefficients

Reimplemented in SUSYMassInsertionMatching.

Definition at line 831 of file StandardModelMatching.cpp.

832 {
833  vmck2.clear();
834 
835  mcdk2.setMu(Mut);
836 
837  switch (mcdk2.getOrder()) {
838  case NNLO:
839  case NLO:
840  mcdk2.setCoeff(0, 0., NLO);
841  case LO:
842  mcdk2.setCoeff(0, 0., LO);
843  break;
844  default:
845  std::stringstream out;
846  out << mcdk2.getOrder();
847  throw std::runtime_error("StandardModelMatching::CMdk2(): order " + out.str() + "not implemented");
848  }
849 
850  vmck2.push_back(mcdk2);
851  return(vmck2);
852 }
virtual void setMu(double mu)
std::vector< WilsonCoefficient > vmck2
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMDLi3j ( int  li_lj)
virtual
Returns
Wilson coefficients for \( \ell_i \to \ell_j\ell_j\ell_j\)

Reimplemented in SUSYMatching.

Definition at line 2290 of file StandardModelMatching.cpp.

2290  {
2291 
2292  vmcDLi3j.clear();
2293 
2294  mcDLi3j.setMu(Muw);
2295 
2296  switch (mcDLi3j.getOrder()) {
2297  case LO:
2298  mcDLi3j.setCoeff(0, 0., LO);
2299  mcDLi3j.setCoeff(1, 0., LO);
2300  mcDLi3j.setCoeff(2, 0., LO);
2301  mcDLi3j.setCoeff(3, 0., LO);
2302  mcDLi3j.setCoeff(4, 0., LO);
2303  mcDLi3j.setCoeff(5, 0., LO);
2304  mcDLi3j.setCoeff(6, 0., LO);
2305  mcDLi3j.setCoeff(7, 0., LO);
2306  mcDLi3j.setCoeff(8, 0., LO);
2307  mcDLi3j.setCoeff(9, 0., LO);
2308  mcDLi3j.setCoeff(10, 0., LO);
2309  mcDLi3j.setCoeff(11, 0., LO);
2310  mcDLi3j.setCoeff(12, 0., LO);
2311  mcDLi3j.setCoeff(13, 0., LO);
2312  mcDLi3j.setCoeff(14, 0., LO);
2313  mcDLi3j.setCoeff(15, 0., LO);
2314  mcDLi3j.setCoeff(16, 0., LO);
2315  mcDLi3j.setCoeff(17, 0., LO);
2316  mcDLi3j.setCoeff(18, 0., LO);
2317  mcDLi3j.setCoeff(19, 0., LO);
2318  break;
2319  case NNLO:
2320  case NLO:
2321  default:
2322  std::stringstream out;
2323  out << mcDLi3j.getOrder();
2324  throw std::runtime_error("StandardModelMatching::CMDLi3j(): order " + out.str() + " not implemented.\nFor lepton flavour violating observables only Leading Order (LO) necessary.");
2325  }
2326 
2327  vmcDLi3j.push_back(mcDLi3j);
2328  return(vmcDLi3j);
2329 
2330 }
virtual void setMu(double mu)
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
orders getOrder() const
std::vector< WilsonCoefficient > vmcDLi3j
std::vector< WilsonCoefficient > & StandardModelMatching::CMDLij ( int  li_lj)
virtual
Returns
Wilson coefficients for \( \ell_i \to \ell_j\)

Reimplemented in SUSYMatching.

Definition at line 2266 of file StandardModelMatching.cpp.

2266  {
2267 
2268  vmcDLij.clear();
2269 
2270  mcDLij.setMu(Muw);
2271 
2272  switch (mcDLij.getOrder()) {
2273  case LO:
2274  mcDLij.setCoeff(0, 0., LO);
2275  mcDLij.setCoeff(1, 0., LO);
2276  break;
2277  case NNLO:
2278  case NLO:
2279  default:
2280  std::stringstream out;
2281  out << mcDLij.getOrder();
2282  throw std::runtime_error("StandardModelMatching::CMDLij(): order " + out.str() + " not implemented.\nFor lepton flavour violating observables only Leading Order (LO) necessary.");
2283  }
2284 
2285  vmcDLij.push_back(mcDLij);
2286  return(vmcDLij);
2287 
2288 }
virtual void setMu(double mu)
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
std::vector< WilsonCoefficient > vmcDLij
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMgminus2mu ( )
virtual
Returns
Wilson coefficients for \( (g-2)_\mu \)

Reimplemented in SUSYMatching.

Definition at line 2362 of file StandardModelMatching.cpp.

2362  {
2363 
2364  vmcgminus2mu.clear();
2365 
2367 
2368  switch (mcgminus2mu.getOrder()) {
2369  case LO:
2370  mcgminus2mu.setCoeff(0, 0., LO);
2371  mcgminus2mu.setCoeff(1, 0., LO);
2372  break;
2373  case NNLO:
2374  case NLO:
2375  default:
2376  std::stringstream out;
2377  out << mcgminus2mu.getOrder();
2378  throw std::runtime_error("StandardModelMatching::CMmueconv(): order " + out.str() + " not implemented.\nFor lepton flavour violating observables only Leading Order (LO) necessary.");
2379  }
2380 
2381  vmcgminus2mu.push_back(mcgminus2mu);
2382  return(vmcgminus2mu);
2383 
2384 }
virtual void setMu(double mu)
std::vector< WilsonCoefficient > vmcgminus2mu
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
orders getOrder() const
WilsonCoefficient mcgminus2mu
std::vector< WilsonCoefficient > & StandardModelMatching::CMK ( )
virtual

operator basis:

current-current; qcd penguins; hep/ph 9512380

Returns
Wilson coefficients Buras base for \( K \rightarrow \pi \pi \) decays

Definition at line 977 of file StandardModelMatching.cpp.

977  {
978 
979  double xt = x_t(Muw);
980 
981  vmck.clear();
982 
983  switch (mck.getScheme()) {
984  case NDR:
985  //case HV:
986  //case LRI:
987  break;
988  default:
989  std::stringstream out;
990  out << mck.getScheme();
991  throw "StandardModel::CMK(): scheme " + out.str() + "not implemented";
992  }
993 
994  mck.setMu(Muw);
995 
996  switch (mck.getOrder()) {
997  case NNLO:
998  case NLO:
999  for (int j=0; j<10; j++){
1000  mck.setCoeff(j, lam_t * SM.Als(Muw, FULLNLO) / 4. / M_PI * //* CHECK ORDER *//
1001  setWCbnlep(j, xt, NLO), NLO);
1002  mck.setCoeff(j, lam_t * Ale / 4. / M_PI *
1003  setWCbnlepEW(j, xt), NLO_ew);
1004  }
1005  case LO:
1006  for (int j=0; j<10; j++){
1007  mck.setCoeff(j, lam_t * setWCbnlep(j, xt, LO), LO);
1008  mck.setCoeff(j, 0., LO_ew);
1009  }
1010  break;
1011  default:
1012  std::stringstream out;
1013  out << mck.getOrder();
1014  throw "StandardModelMatching::CMK(): order " + out.str() + "not implemented";
1015  }
1016 
1017  vmck.push_back(mck);
1018  return(vmck);
1019 }
virtual void setMu(double mu)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
double setWCbnlep(int i, double x, orders order)
double setWCbnlepEW(int i, double x)
std::vector< WilsonCoefficient > vmck
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMKCC ( )
virtual

operator basis:

current-current (open up - open charm) hep/ph 9512380

Returns
Wilson coefficients Buras base for \( B \rightarrow \pi \pi \) decays

Definition at line 1025 of file StandardModelMatching.cpp.

1025  {
1026 
1027  double xt = x_t(Muw);
1028 
1029  vmckcc.clear();
1030 
1031  switch (mckcc.getScheme()) {
1032  case NDR:
1033  //case HV:
1034  //case LRI:
1035  break;
1036  default:
1037  std::stringstream out;
1038  out << mckcc.getScheme();
1039  throw "StandardModel::CMKCC(): scheme " + out.str() + "not implemented";
1040  }
1041 
1042  mckcc.setMu(Muw);
1043 
1044  switch (mckcc.getOrder()) {
1045  case NNLO:
1046  case NLO:
1047  for (int j=0; j<2; j++){
1048  mckcc.setCoeff(j, lam_t * setWCbnlep(j, xt, NLO), NLO);
1049  }
1050  for (int j=2; j<10; j++){
1051  mckcc.setCoeff(j, 0. , NLO);
1052  }
1053  case LO:
1054  for (int j=0; j<2; j++){
1055  mckcc.setCoeff(j, lam_t * setWCbnlep(j, xt, LO), LO);
1056  }
1057  for (int j=2; j<10; j++){
1058  mckcc.setCoeff(j, 0. , LO);
1059  }
1060  break;
1061  default:
1062  std::stringstream out;
1063  out << mckcc.getOrder();
1064  throw "StandardModelMatching::CMKCC(): order " + out.str() + "not implemented";
1065  }
1066 
1067  vmckcc.push_back(mckcc);
1068  return(vmckcc);
1069 }
virtual void setMu(double mu)
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
double setWCbnlep(int i, double x, orders order)
orders getOrder() const
std::vector< WilsonCoefficient > vmckcc
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMkmm ( )
virtual
Returns
Wilson coefficient for \( K^{+} \rightarrow \mu \mu \), short distance top contribution

Definition at line 1790 of file StandardModelMatching.cpp.

1790  {
1791 
1792  //PROBLEMI: mu e sin(theta_weak) e la scala di als
1793 
1794  double xt = x_t(Muw);
1795 
1796  vmckmm.clear();
1797 
1798  mckmm.setMu(Mut);
1799 
1800  switch (mckmm.getOrder()) {
1801  case NNLO:
1802  case NLO:
1803  mckmm.setCoeff(0, SM.Als(Muw, FULLNLO)/4./M_PI*lam_t.real()*Y1(xt, Muw)/SM.getLambda(), NLO);//* CHECK ORDER *//
1804  case LO:
1805  mckmm.setCoeff(0, lam_t.real()*Y0(xt)/SM.getLambda(), LO);
1806  break;
1807  default:
1808  std::stringstream out;
1809  out << mckmm.getOrder();
1810  throw std::runtime_error("StandardModelMatching::CMkmm(): order " + out.str() + "not implemented");
1811  }
1812 
1813  vmckmm.push_back(mckmm);
1814  return(vmckmm);
1815 
1816 }
virtual void setMu(double mu)
const double & real() const
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double getLambda() const
A get method to retrieve the CKM element .
double Y0(double x) const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
const StandardModel & SM
std::vector< WilsonCoefficient > vmckmm
orders getOrder() const
double Y1(double x, double mu) const
double x_t(const double mu, const orders order=FULLNNLO) const
std::vector< WilsonCoefficient > & StandardModelMatching::CMkpnn ( )
virtual
Returns
Wilson coefficients for \( K_{L} \rightarrow \pi \nu \nu \)

Definition at line 1749 of file StandardModelMatching.cpp.

1749  {
1750 
1751  //scales assigned to xt, a and Xewt to be checked!
1752 
1753  double xt = x_t(SM.getMut());
1754  double a = 1./mt2omh2(Muw);
1756 
1757  vmckpnn.clear();
1758 
1759  mckpnn.setMu(Mut);
1760 
1761  switch (mckpnn.getOrder()) {
1762  case NNLO:
1763  case NLO:
1764  mckpnn.setCoeff(0, SM.Als(SM.getMut(), FULLNLO)/4./M_PI*lam_t.imag()*X1t(xt)/lambda5, NLO);//* CHECK ORDER *//
1765  case LO:
1766  mckpnn.setCoeff(0, lam_t.imag()*X0t(xt)/lambda5, LO);
1767  break;
1768  default:
1769  std::stringstream out;
1770  out << mckpnn.getOrder();
1771  throw std::runtime_error("StandardModelMatching::CMkpnn(): order " + out.str() + "not implemented");
1772  }
1773 
1774  switch (mckpnn.getOrder_ew()) {
1775  case NLO_ew:
1776  mckpnn.setCoeff(0, Ale/4./M_PI*lam_t.imag()*Xewt(xt, a, Muw)/lambda5, NLO_ew);
1777  case LO_ew:
1778  break;
1779  default:
1780  std::stringstream out;
1781  out << mckpnn.getOrder();
1782  throw std::runtime_error("StandardModelMatching::CMkpnn(): order " + out.str() + "not implemented");
1783  }
1784 
1785  vmckpnn.push_back(mckpnn);
1786  return(vmckpnn);
1787 
1788 }
virtual void setMu(double mu)
double mt2omh2(const double mu, const orders order=FULLNNLO) const
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double getLambda() const
A get method to retrieve the CKM element .
double X0t(double x) const
hep-ph/9512380v1
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
std::vector< WilsonCoefficient > vmckpnn
orders_ew getOrder_ew() const
An observable class for the quartic Higgs potential coupling .
Definition: OrderScheme.h:33
double Xewt(double x, double a, double mu) const
hep-ph/1009.0947v2
const StandardModel & SM
const double & imag() const
double X1t(double x) const
hep-ph/1009.0947v2
orders getOrder() const
double x_t(const double mu, const orders order=FULLNNLO) const
double getMut() const
A get method to access the threshold between six- and five-flavour theory in GeV. ...
Definition: QCD.h:896
std::vector< WilsonCoefficient > & StandardModelMatching::CMmueconv ( )
virtual
Returns
Wilson coefficients for \( \mu \to e\) conversion in nuclei

Reimplemented in SUSYMatching.

Definition at line 2332 of file StandardModelMatching.cpp.

2332  {
2333 
2334  vmcmueconv.clear();
2335 
2336  mcmueconv.setMu(Muw);
2337 
2338  switch (mcmueconv.getOrder()) {
2339  case LO:
2340  mcmueconv.setCoeff(0, 0., LO);
2341  mcmueconv.setCoeff(1, 0., LO);
2342  mcmueconv.setCoeff(2, 0., LO);
2343  mcmueconv.setCoeff(3, 0., LO);
2344  mcmueconv.setCoeff(4, 0., LO);
2345  mcmueconv.setCoeff(5, 0., LO);
2346  mcmueconv.setCoeff(6, 0., LO);
2347  mcmueconv.setCoeff(7, 0., LO);
2348  break;
2349  case NNLO:
2350  case NLO:
2351  default:
2352  std::stringstream out;
2353  out << mcmueconv.getOrder();
2354  throw std::runtime_error("StandardModelMatching::CMmueconv(): order " + out.str() + " not implemented.\nFor lepton flavour violating observables only Leading Order (LO) necessary.");
2355  }
2356 
2357  vmcmueconv.push_back(mcmueconv);
2358  return(vmcmueconv);
2359 
2360 }
virtual void setMu(double mu)
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
std::vector< WilsonCoefficient > vmcmueconv
Definition: OrderScheme.h:33
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMprimeBMll ( )
virtual

operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic

Returns
Wilson coefficients, Misiak basis, for \( B \rightarrow K^* l^{+} l{-} \)

Implements ModelMatching.

Reimplemented in FlavourWilsonCoefficientMatching.

Definition at line 1343 of file StandardModelMatching.cpp.

1344  {
1345  vmcprimeBMll.clear();
1347  switch (mcprimeBMll.getOrder()) {
1348  case NNLO:
1349  case NLO:
1350  for (int j=0; j<13; j++){
1351  mcprimeBMll.setCoeff(j, 0., NLO);
1352  }
1353  case LO:
1354  for (int j=0; j<13; j++){
1355  mcprimeBMll.setCoeff(j, 0., LO);
1356  }
1357  break;
1358  default:
1359  std::stringstream out;
1360  out << mcprimeBMll.getOrder();
1361  throw std::runtime_error("StandardModelMatching::CMBKstrall(): order " + out.str() + "not implemented");
1362  }
1363  vmcprimeBMll.push_back(mcprimeBMll);
1364  return(vmcprimeBMll);
1365  }
virtual void setMu(double mu)
std::vector< WilsonCoefficient > vmcprimeBMll
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
WilsonCoefficient mcprimeBMll
Definition: OrderScheme.h:33
orders getOrder() const
std::vector< WilsonCoefficient > & StandardModelMatching::CMprimebsg ( )
virtual

operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic

Returns
Wilson coefficients, Misiak basis, for \( B \rightarrow X_{s} \gamma, l^{+} l{-} \)

Implements ModelMatching.

Reimplemented in FlavourWilsonCoefficientMatching.

Definition at line 1121 of file StandardModelMatching.cpp.

1122 {
1123  vmcprimebsg.clear();
1124 
1125  switch (mcprimebsg.getScheme()) {
1126  case NDR:
1127  //case HV:
1128  //case LRI:
1129  break;
1130  default:
1131  std::stringstream out;
1132  out << mcprimebsg.getScheme();
1133  throw std::runtime_error("StandardModel::CMprimebsg(): scheme " + out.str() + "not implemented");
1134  }
1135 
1136  mcprimebsg.setMu(Muw);
1137 
1138  switch (mcprimebsg.getOrder()) {
1139  case NNLO:
1140  case NLO:
1141  for (int j=0; j<8; j++){
1142  mcprimebsg.setCoeff(j, 0., NLO);//* CHECK ORDER *//
1143  }
1144  case LO:
1145  for (int j=0; j<8; j++){
1146  mcprimebsg.setCoeff(j, 0., LO);
1147  }
1148  break;
1149  default:
1150  std::stringstream out;
1151  out << mcprimebsg.getOrder();
1152  throw std::runtime_error("StandardModelMatching::CMprimebsg(): order " + out.str() + "not implemented");
1153  }
1154 
1155  vmcprimebsg.push_back(mcprimebsg);
1156  return(vmcprimebsg);
1157 }
virtual void setMu(double mu)
schemes getScheme() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
std::vector< WilsonCoefficient > vmcprimebsg
WilsonCoefficient mcprimebsg
orders getOrder() const
double StandardModelMatching::D0b ( double  x) const

loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 514 of file StandardModelMatching.cpp.

515 {
516  double x2 = x * x;
517  return ( -4. / 9. * log(x) + (-19. * x2 * x + 25. * x2) / (36. * (x2 * x - 3. * x2 + 3. * x - 1.))
518  + (x2 * (5. * x2 - 2. * x - 6.) ) / (18. * pow(x - 1.,4.)) * log(x) );
519 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::D0t ( double  x) const

loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 234 of file StandardModelMatching.cpp.

235 {
236  double x2 = x * x;
237  double x3 = x2 * x;
238  double x4 = x3 * x;
239 
240  return( (-3. * x4 + 30. * x3 - 54. * x2 + 32.* x - 8.) / (18.* pow(1. - x, 4)) * log(x)
241  + (-47. * x3 + 237. * x2 - 312. * x + 104.) / (108. * pow(1.- x, 3.)) );
242 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::D1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 310 of file StandardModelMatching.cpp.

311 {
312  double x2 = x * x;
313  double x3 = x * x2;
314  double x4 = x * x3;
315  double xm4 = pow(1. - x, 4);
316  double xm5 = pow(1. - x, 5);
317  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
319 
320  return (380. * x4 - 1352. * x3 + 1656. * x2 - 784. * x + 256.)/(81. * xm4) * gsl_sf_dilog(1.- 1./x) +
321  (304. * x4 + 1716. * x3 - 4644. * x2 + 2768. * x - 720.)/(81. * xm5)*log(x) +
322  (-6175. * x4 + 41608. * x3 - 66723. * x2 + 33106. * x - 7000.)/(729. * xm4) +
323  ( (648. * x4 - 720. * x3 - 232. * x2 - 160. * x + 32.)/(81. * xm5)*log(x) +
324  (-352. * x4 + 4912. * x3 - 8280. * x2 + 3304. * x - 880.)/(243. * xm4) ) * 2. * log(mu / mt);
325 }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::E0b ( double  x) const

loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 521 of file StandardModelMatching.cpp.

522 {
523  double x2 = x * x;
524 
525  return ( -2./3. * log(x) + (18. * x - 11. * x2 - x2 * x) / (12.* (- x2 * x +3. * x2 -3. * x +1.)) +
526  (x2 * (15. - 16. * x +4. * x2))/(6.*pow(1.-x,4.)) *log(x) );
527 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::E0t ( double  x) const

loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak basis, Chetyrkin et al hep-ph/9612313

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 244 of file StandardModelMatching.cpp.

245 {
246 //***// CHECK THIS FUNCTION double x2 = x * x;
247 
248  return (-9. * x * x + 16. * x - 4.) / (6. * pow((1.- x),4) ) * log(x) + (-7. * x * x * x - 21. * x * x + 42. * x + 4.)/(36 * pow((1. - x), 3));
249  //return (x * (18. - 11. * x - x * x) / (12. * pow(1. - x, 3.) + x * x * (15. - 16. * x + 4. * x * x) /(6. * pow(1. - x, 4.)) * log(x) - 2./3. * log(x)));
250 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::E1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 344 of file StandardModelMatching.cpp.

346 {
347 double x2 = x * x;
348 double x3 = x * x2;
349 double x4 = x * x3;
350 double xm4 = pow(1. - x, 4);
351 double xm5 = pow(1. - x, 5);
352 double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
354 
355 
356 return (515. * x4 - 614. * x3 - 81. * x2 - 190. * x + 40.)/(54. * xm4) * gsl_sf_dilog(1.- 1./x) +
357 (-1030. * x4 + 435. * x3 + 1373. * x2 + 1950. * x - 424.)/(108. * xm5) * log(x) +
358 (-29467. * x4 + 45604. * x3 - 30237. * x2 + 66532. * x - 10960.)/(1944. * xm4) +
359 ( (-1125. * x3 + 1685. * x2 + 380. * x - 76.)/(54. * xm5)*log(x) +
360 (133. * x4 - 2758. * x3 - 2061. * x2 + 11522. * x - 1652.)/(324. * xm4) ) * 2. * log(mu / mt);
361  }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::Eet ( double  x) const

loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 400 of file StandardModelMatching.cpp.

401 {
402  double x2 = x * x;
403  double xm2 = pow(1. - x, 2);
404  double xm3 = xm2 * (1. - x);
405  double xm4 = xm3 * (1. - x);
406 
407 return ((x * (18. - 11. * x - x2))/(12. * xm3) +
408  (log(x) * (x2 * (15. - 16. * x + 4. * x2))/(6. * xm4)) - 2. * log(x) /3.);
409 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::F0t ( double  x) const

loop function which appear in the Wilson coefficient for the chromomagnetic operator in the non-effective Misiak basis, Bobeth et al hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass

Definition at line 252 of file StandardModelMatching.cpp.

253 {
254  double x2 = x * x;
255  double xm3 = (1. - x)*(1. - x)*(1. - x);
256 
257  return ((3. * x2) / (2. * xm3 * (1. - x)) * log(x) + ( 5. * x2 * x - 9. * x2 + 30. * x - 8.)/
258  (12. * xm3));
259 }
complex log(const complex &z)
double StandardModelMatching::F1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effective Misiak basis, Misiak and Urban hep-ph/9901278v1

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 327 of file StandardModelMatching.cpp.

328 {
329  double x2 = x * x;
330  double x3 = x * x2;
331  double x4 = x * x3;
332  double xm4 = pow(1. - x, 4);
333  double xm5 = pow(1. - x, 5);
334  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
336 
337  return ((4. * x4 - 40. * x3 - 41. * x2 - x)/3./xm4 * gsl_sf_dilog(1.- 1./x) +
338  (-144. * x4 + 3177. * x3 + 3661. * x2 + 250. * x - 32.)/108./xm5 * log(x)
339  + (-247. * x4 + 11890. * x3 + 31779. * x2 - 2966. * x + 1016.)/648./xm4
340  + ((17. * x3 + 31. * x2)/xm5 * log(x) + (- 35. * x4 + 170. * x3 + 447. * x2
341  + 338. * x - 56.)/18./xm4)* 2. * log(mu/mt));
342 }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::G1t ( double  x,
double  mu 
) const

loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 363 of file StandardModelMatching.cpp.

365 {
366 double x2 = x * x;
367 double x3 = x * x2;
368 double x4 = x * x3;
369 double xm3 = pow(1. - x, 3);
370 double xm4 = pow(1. - x, 4);
371 
372 double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
374 
375 return (10. * x4 - 100. * x3 + 30. * x2 + 160. * x - 40.)/(27. * xm4) * gsl_sf_dilog(1.- 1./x) +
376 (30. * x3 - 42. * x2 - 332. * x + 68.)/(81. * xm4)*log(x) +
377 (-6. * x3 - 293. * x2 + 161. * x + 42.)/(81. * xm3) +
378 ( (90. * x2 - 160. * x + 40.)/(27. * xm4)*log(x) +
379 (35. * x3 + 105. * x2 - 210. * x - 20.)/(81. * xm3) ) * 2. * log(mu / mt);
380  }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
complex log(const complex &z)
double StandardModelMatching::mt2omh2 ( const double  mu,
const orders  order = FULLNNLO 
) const

Definition at line 140 of file StandardModelMatching.cpp.

141 {
142  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
143  SM.getQuarks(QCD::TOP).getMass(), order);
144  return (mt / SM.getMHl())*(mt / SM.getMHl());
145 }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
double getMHl() const
A get method to retrieve the Higgs mass .
double StandardModelMatching::phi1 ( double  z) const
private
Parameters
z
Returns
two loop EW loop functions for K-> P nu nu, hep-ph/1009.0947v2

Definition at line 693 of file StandardModelMatching.cpp.

693  {
694  if (z >= 0.) {
695  if (z < 1){
696  return(4. * sqrt(z / (1. - z)) * gsl_sf_clausen(2. * asin(sqrt(z))));
697  }
698  else{
699  return((1. / sqrt(1. - 1. / z)) * (2. * log(0.5 * sqrt(1. - 1. / z)) * log(0.5 * sqrt(1. -1. / z))- 4. * gsl_sf_dilog(0.5 * (1. - sqrt(z / (1. - z)))) - log(4. * z) * log(4. * z)
700  + M_PI * M_PI / 3.));
701  }
702  }
703  else{
704  std::stringstream out;
705  out << z;
706  throw std::runtime_error("StandardModelMatching::phi1(double z)" + out.str() + " <0");
707  }
708  return(0.);
709 }
complex log(const complex &z)
complex sqrt(const complex &z)
double StandardModelMatching::phi2 ( double  x,
double  y 
) const
private
Parameters
x
y
Returns
two loop EW loop functions for K-> P nu nu, hep-ph/1009.0947v2

Definition at line 711 of file StandardModelMatching.cpp.

711  {
712  double l = sqrt((1. - x - y) * (1. - x - y) - 4. * x * y);
713 
714  if ((l * l) >= 0. || (sqrt(x) + sqrt(y)) <= 1.){
715  return( 1. / l * (M_PI * M_PI/3. + 2. * log(0.5 * (1. + x - y - l)) * log(0.5 * (1. - x + y - l)) - log(x) * log(y) - 2. * gsl_sf_dilog(0.5 * (1. + x - y - l)) - 2. * gsl_sf_dilog(0.5 * (1. -x + y - l))));
716  }
717  else if((l * l) < 0. || (sqrt(x) + sqrt(y)) > 1.){
718  return(2./( -l * l) * (gsl_sf_clausen(2. * acos((-1. + x + y)/(2. * sqrt(x * y))))
719  +gsl_sf_clausen(2. * acos((1. + x - y) / (2. * sqrt(x))))
720  +gsl_sf_clausen(2. * acos((1. - x + y) / (2. * sqrt(y))))));
721  }
722  else{
723  std::stringstream out;
724  out << x;
725  throw std::runtime_error("StandardModelMatching::phi2(double x, double y) wrong" + out.str());
726  }
727  return(0.);
728 }
complex log(const complex &z)
complex sqrt(const complex &z)
double StandardModelMatching::Rest ( double  x,
double  mu 
) const

approximation of two-loops EW correction for Q_10 operator in the non-effective Misiak basis, Misiak and Urban hep-ph/1311.1348

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 411 of file StandardModelMatching.cpp.

413 {
414  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(), SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
415 
416 return (-37.01364013973161 + 7.870950908767437 * mt -
417  0.0015295355176062242 * mt * mt + 2.41071411865951 * Mw -
418  0.20348320015672194 * mt * Mw - 0.02858827491583899 * Mw * Mw +
419  0.001422822903303167 * mt * Mw * Mw + (4.257050684362808 + 0.17719711396626878 * mt -
420  0.8190947921716011 * Mw - 0.002315407459561656 * mt * Mw + 0.008797408866807221 * Mw * Mw) * log(
421  mu) + (0.49627858125619595 - pow(5.784745743815408,-8) *mt +
422  0.031869225004473686 * Mw - 0.00041193393986696286 * Mw * Mw) * log(
423  mu) * log(mu));
424  }
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
complex pow(const complex &z1, const complex &z2)
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
An observable class for the -boson mass.
Definition: Mw.h:22
complex log(const complex &z)
double StandardModelMatching::S0 ( double  x,
double  y 
) const

Definition at line 152 of file StandardModelMatching.cpp.

153 { // Buras 2000 Appendix
154  if (fabs(1. - y / x) < LEPS){
155  return ((x * (-4. + 15. * x - 12. * x * x + x * x * x +
156  6. * x * x * log(x))) / (4. * pow(-1. + x, 3.)));
157  }
158  else
159  return (x * y * ((1./4. + 3./2. / (1. - x) - 3./4. / pow(1. - x, 2.)) *
160  log(x) / (x - y) +
161  (1./4. + 3./2. / (1. - y) - 3./4. / pow(1. - y, 2.)) *
162  log(y) / (y - x) -
163  3./4. / (1. - x) / (1. - y)));
164 }
complex pow(const complex &z1, const complex &z2)
#define LEPS
complex log(const complex &z)
double StandardModelMatching::S0 ( double  x) const
private

Definition at line 147 of file StandardModelMatching.cpp.

148 {
149  return S0(x, x);
150 }
double S0(double, double) const
gslpp::complex StandardModelMatching::S0c ( ) const

hep-ph/9512380

Returns
the loop function for the charm-charm contribution to the Delta S = 2 effective hamiltonian multiplied by the CKM element

Definition at line 2229 of file StandardModelMatching.cpp.

2230 {
2231  double xc = x_c(SM.getMuc());
2232  gslpp::complex co = GF / 2. / M_PI * Mw_tree * SM.computelamc().conjugate(); /* Mw_tree...?? */
2233 
2234  return(co * co * S0(xc, xc));
2235 }
complex conjugate() const
gslpp::complex computelamc() const
The product of the CKM elements .
double x_c(const double mu, const orders order=FULLNNLO) const
const StandardModel & SM
double getMuc() const
A get method to access the threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:914
double S0(double, double) const
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
gslpp::complex StandardModelMatching::S0ct ( ) const

hep-ph/9512380

Returns
the loop function for the charm-top contribution to the Delta S = 2 effective hamiltonian multiplied by the CKM element

Definition at line 2237 of file StandardModelMatching.cpp.

2238 {
2240  xc *= xc;
2241  double xt = SM.Mrun4(SM.getMuw(),SM.getQuarks(QCD::TOP).getMass_scale(),SM.getQuarks(QCD::TOP).getMass())/Mw;
2242  xt *= xt;
2243  double co = GF / 2. / M_PI * Mw;
2244 #if SUSYFIT_DEBUG & 2
2245  std::cout << "S0(" << xc << "," << xt << ") = " << S0(xc,xt) << std::endl;
2246 #endif
2247 
2248  return( co * co * 2. * SM.computelamc().conjugate() * lam_t.conjugate() * S0(xc, xt) );
2249 }
complex conjugate() const
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
gslpp::complex computelamc() const
The product of the CKM elements .
double getMuw() const
A get method to retrieve the matching scale around the weak scale.
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
An observable class for the -boson mass.
Definition: Mw.h:22
double getMuc() const
A get method to access the threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:914
double S0(double, double) const
double StandardModelMatching::S0p ( double  x) const
private

Definition at line 166 of file StandardModelMatching.cpp.

167 {
168  double x2 = x * x;
169  return (x * (4. - 22. * x + 15. * x2 + 2. * x2 * x + x2 * x2 - 18. * x2 * log(x)) / 4. / pow(x - 1., 4.));
170 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
gslpp::complex StandardModelMatching::S0tt ( ) const

hep-ph/9512380v1

Returns
the loop function for the top-top contribution to the Delta S = 2 effective hamiltonian

Definition at line 2251 of file StandardModelMatching.cpp.

2252 {
2253  double xt = x_t(Mut);
2254  gslpp::complex co = GF / 2. / M_PI * Mw * lam_t.conjugate();
2255 #if SUSYFIT_DEBUG & 2
2256  std::cout << "S0(" << xt << ") = " << S0(xt,xt) << std::endl;
2257 #endif
2258 
2259  return ( co * co * S0(xt, xt) );
2260 }
complex conjugate() const
An observable class for the -boson mass.
Definition: Mw.h:22
double S0(double, double) const
double x_t(const double mu, const orders order=FULLNNLO) const
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
double StandardModelMatching::S1 ( double  x) const
Parameters
[in]xthe square of the ratio between top mass and W mass
Returns

Definition at line 202 of file StandardModelMatching.cpp.

203 {
204  return (CF * S11(x) + (Nc - 1.) / 2. / Nc * S18(x));
205 }
double S18(double x) const
double S11(double x) const
double StandardModelMatching::S11 ( double  x) const
private

Definition at line 172 of file StandardModelMatching.cpp.

173 {
174  double x2 = x * x;
175  double x3 = x2 * x;
176  double x4 = x3 * x;
177  double xm3 = (x - 1.) * (x - 1.) * (x - 1.);
178  double xm4 = xm3 * (x - 1);
179 
180  return (x * (4. - 39. * x + 168. * x2 + 11. * x3) / 4. / xm3
181  + 3. * x3 * gsl_sf_dilog(1. - x) * (5. + x) / xm3
182  + 3. * x * log(x)*(-4. + 24. * x - 36. * x2 - 7. * x3 - x4) / 2.
183  / xm4 + 3. * x3 * pow(log(x), 2.) * (13. + 4. * x + x2) / 2.
184  / xm4);
185 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::S18 ( double  x) const
private

Definition at line 187 of file StandardModelMatching.cpp.

188 {
189  double x2 = x * x;
190  double x3 = x2 * x;
191  double x4 = x3 * x;
192  double xm2 = (x - 1.) * (x - 1.);
193  double xm3 = xm2 * (x - 1.);
194  return ((-64. + 68. * x + 17. * x2 - 11. * x3) / 4. / xm2
195  + pow(M_PI, 2.) * 8./3. / x + 2. * gsl_sf_dilog(1. - x) * (8. - 24. * x
196  + 20. * x2 - x3 + 7. * x4 - x4 * x) / (x * xm3)
197  + log(x)*(-32. + 68. * x - 32. * x2 + 28. * x3 - 3. * x4)
198  / (2. * xm3) + x2 * pow(log(x), 2.) * (4. - 7. * x + 7. * x2
199  - 2. * x3) / (2. * xm2 * xm2));
200 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::setWCBdmm ( int  i,
double  x,
orders  order 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order
Returns
return the value of the wilson coefficients for \( B_{d} \rightarrow l^{+} l{-} \)

Definition at line 2017 of file StandardModelMatching.cpp.

2018 {
2019 
2020  sw = sqrt( (M_PI * Ale ) / ( sqrt(2.) * GF * Mw * Mw) );
2021 
2022  if ( swb == sw && xcacheb == x){
2023  switch (order){
2024  case NNLO:
2025  return (CWBdmmArrayNNLOqcd[i]);
2026  break;
2027  case NLO:
2028  return (CWBdmmArrayNLOqcd[i]);
2029  break;
2030  case LO:
2031  return (CWBdmmArrayLOqcd[i]);
2032  break;
2033  default:
2034  std::stringstream out;
2035  out << order;
2036  throw std::runtime_error("order" + out.str() + "not implemeted");
2037  }
2038  }
2039 
2040  swb = sw; xcacheb = x;
2041 
2042  switch (order){
2043  case NNLO:
2044  CWBdmmArrayNNLOqcd[0] = sw * sw * (-Tt(x) + 7987./72. + 17. * M_PI * M_PI/3. + 475. * L/6. + 17. * L * L);
2045  CWBdmmArrayNNLOqcd[1] = sw * sw * (127./18. + 4. * M_PI * M_PI /3. + 46. * L/3. + 4. * L * L);
2046  CWBdmmArrayNNLOqcd[2] = sw * sw * (G1t(x, Muw) - 680./243. - 20. * M_PI * M_PI /81. - 68. * L/81. - 20. * L* L/27.);
2047  CWBdmmArrayNNLOqcd[3] = sw * sw * (E1t(x, Muw) + 950./243. + 10.* M_PI * M_PI /81. + 124. * L/27. + 10. * L * L/27.);
2048  CWBdmmArrayNNLOqcd[4] = sw * sw * (-G1t(x, Muw)/10. + 2. * E0t(x)/15. + 68./243. + 2. * M_PI * M_PI /81. + 14.* L/81. + 2. * L * L/27.);
2049  CWBdmmArrayNNLOqcd[5] = sw * sw * (-3. * G1t(x, Muw)/16. + E0t(x)/4. + 85./162. + 5. * M_PI * M_PI/108. + 35. * L/108. + 5. * L * L/36.);
2050 
2051  case NLO:
2052  CWBdmmArrayNLOqcd[0] = sw * sw * (15. + 6. * L);
2053  CWBdmmArrayNLOqcd[3] = sw * sw * (Eet(x) - 2./3. + 2. * L/3.);
2054 
2055  case LO:
2056  CWBdmmArrayLOqcd[1] = sw * sw * 1.;
2057 
2058  break;
2059  default:
2060  std::stringstream out;
2061  out << order;
2062  throw std::runtime_error("order" + out.str() + "not implemeted");
2063  }
2064  switch (order){
2065  case NNLO:
2066  return (CWBdmmArrayNNLOqcd[i]);
2067 
2068  break;
2069  case NLO:
2070  return (CWBdmmArrayNLOqcd[i]);
2071 
2072  break;
2073  case LO:
2074  return (CWBdmmArrayLOqcd[i]);
2075 
2076  break;
2077  default:
2078  std::stringstream out;
2079  out << order;
2080  throw std::runtime_error("order" + out.str() + "not implemeted");
2081  }
2082 }
double Eet(double x) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066
double Tt(double x) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220
double G1t(double x, double mu) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220
Definition: OrderScheme.h:33
double E1t(double x, double mu) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220
An observable class for the -boson mass.
Definition: Mw.h:22
double E0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak ba...
complex sqrt(const complex &z)
double StandardModelMatching::setWCBdmmEW ( int  i,
double  x,
orders_ew  order_ew 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order_ew
Returns
return the electroweak value of the wilson coefficients for \( B_{d} \rightarrow l^{+} l{-} \)

Definition at line 2084 of file StandardModelMatching.cpp.

2085 {
2086  sw = sqrt( (M_PI * Ale ) / ( sqrt(2.) * GF * Mw * Mw) ) ;
2087 
2088  double mt = SM.Mrun(Muw, SM.getQuarks(QCD::TOP).getMass_scale(),
2090 
2091  if ( swc == sw && xcachec == x){
2092  switch (order_ew){
2093  case NLO_ewt4:
2094  return (CWBdmmArrayNLOewt4[i]);
2095  break;
2096  case NLO_ewt2:
2097  return (CWBdmmArrayNLOewt2[i]);
2098  break;
2099  case NLO_ew:
2100  return (CWBdmmArrayNLOew[i]);
2101  break;
2102  default:
2103  std::stringstream out;
2104  out << order_ew;
2105  throw std::runtime_error("order_ew" + out.str() + "not implemeted");
2106  }
2107 
2108  }
2109 
2110 
2111  swc = sw; xcachec = x;
2112 
2113  switch (order_ew){
2114  case NLO_ewt4:
2115  CWBdmmArrayNLOewt4[7] = sw * sw * (1./(sw * sw)) * Rest(x, Muw) ;
2116 
2117  case NLO_ewt2:
2118  CWBdmmArrayNLOewt2[6] = sw * sw * ((1. - 4. * sw * sw) * C1t(x, Muw) / (sw * sw) - B1t(x, Muw)/(sw * sw)
2119  - D1t(x, Muw) + 1./ (sw * sw) + 524./729. - 128. * M_PI * M_PI / 243.
2120  - 16. * L / 3. - 128. * L * L /81. ) ;
2121  CWBdmmArrayNLOewt2[7] = sw * sw * ((1./(sw * sw)) * (B1t(x, Muw) - C1t(x, Muw)) - 1./(sw * sw)) ;
2122 
2123  case NLO_ew:
2124  CWBdmmArrayNLOew[6] = sw * sw * (Y0(x)/(sw * sw) + Wt(x) + 4./9. - 4. * 2 * log(Muw/mt)/9.);
2125  CWBdmmArrayNLOew[7] = sw * sw * (-Y0(x)/(sw * sw));
2126 
2127  break;
2128  default:
2129  std::stringstream out;
2130  out << order_ew;
2131  throw std::runtime_error("order_ew" + out.str() + "not implemeted");
2132  }
2133 
2134  switch (order_ew){
2135  case NLO_ewt4:
2136  return (CWBdmmArrayNLOewt4[i]);
2137  break;
2138  case NLO_ewt1:
2139  return (CWBdmmArrayNLOewt2[i]);
2140  break;
2141  case NLO_ew:
2142  return (CWBdmmArrayNLOew[i]);
2143  break;
2144  default:
2145  std::stringstream out;
2146  out << order_ew;
2147  throw std::runtime_error("order_ew" + out.str() + "not implemeted");
2148  }
2149 }
double B1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
double D1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
double C1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double Wt(double x) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066
double Y0(double x) const
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
An observable class for the -boson mass.
Definition: Mw.h:22
complex log(const complex &z)
double Rest(double x, double mu) const
approximation of two-loops EW correction for Q_10 operator in the non-effective Misiak basis...
complex sqrt(const complex &z)
double StandardModelMatching::setWCBMll ( int  i,
double  x,
orders  order 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order
Returns
return the value of the wilson coefficients for \( B \rightarrow k^* l^{+} l{-} \)

Definition at line 1274 of file StandardModelMatching.cpp.

1275 {
1276  sw = sqrt( sW2 ) ;
1277 
1278  if ( swa == sw && xcachea == x){
1279  switch (order){
1280  case NNLO:
1281  case NLO:
1282  return ( CWBMllArrayNLO[i] );
1283  break;
1284  case LO:
1285  return ( CWBMllArrayLO[i] );
1286  break;
1287  default:
1288  std::stringstream out;
1289  out << order;
1290  throw std::runtime_error("order" + out.str() + "not implemeted");
1291  }
1292  }
1293 
1294  swa = sw; xcachea = x;
1295 
1296  switch (order){
1297  case NNLO:
1298  case NLO:
1299  CWBMllArrayNLO[0] = 15. + 6*L;
1300  CWBMllArrayNLO[3] = E0t(x) - (7./9.) + (2./3.* L);
1301  CWBMllArrayNLO[6] = -0.5*A1t(x,Muw) + 713./243. + 4./81.*L - 4./9.*CWBMllArrayNLO[3];
1302  CWBMllArrayNLO[7] = -0.5*F1t(x,Muw) + 91./324. - 4./27.*L - 1./6.*CWBMllArrayNLO[3];
1303  CWBMllArrayNLO[8] = (1-4.*sW2) / (sW2) *C1t(x,Muw) - 1./(sW2) * B1t(x,Muw) - D1t(x,Muw) + 1./sW2 + 524./729. -
1304  128.*M_PI*M_PI/243. - 16.*L/3. -128.*L*L/81.;
1305  CWBMllArrayNLO[9] = (B1t(x,Muw) - C1t(x,Muw)) / sW2 - 1./sW2;
1306  case LO:
1307  CWBMllArrayLO[1] = 1.;
1308  CWBMllArrayLO[6] = -0.5*A0t(x) - 23./36.;
1309  CWBMllArrayLO[7] = -0.5*F0t(x) - 1./3.;
1310  CWBMllArrayLO[8] = (1-4.*sW2) / (sW2) *C0t(x) - 1./(sW2) * B0t(x) - D0t(x) + 38./27. + 1./(4.*sW2) - (4./9.)*L + 8./9. * log(SM.getMuw()/mu_b);
1311  CWBMllArrayLO[9] = 1./(sW2) * (B0t(x) - C0t(x)) -1./(4.*sW2);
1312  break;
1313  default:
1314  std::stringstream out;
1315  out << order;
1316  throw std::runtime_error("order" + out.str() + "not implemeted");
1317  }
1318 
1319  switch (order){
1320  case NNLO:
1321  case NLO:
1322  return ( CWBMllArrayNLO[i] );
1323  break;
1324  case LO:
1325  return ( CWBMllArrayLO[i] );
1326  break;
1327  default:
1328  std::stringstream out;
1329  out << order;
1330  throw std::runtime_error("order" + out.str() + "not implemeted");
1331  }
1332 }
double B1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
double D1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double C1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double B0t(double x) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
double A0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double getMuw() const
A get method to retrieve the matching scale around the weak scale.
Definition: OrderScheme.h:33
const StandardModel & SM
double C0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double F1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
double D0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
complex log(const complex &z)
double F0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the non-effec...
double E0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak ba...
double A1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
complex sqrt(const complex &z)
double StandardModelMatching::setWCbnlep ( int  i,
double  x,
orders  order 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order
Returns
return the value of the QCD contribution to the Wilson coefficients for non-leptonic B decays

Definition at line 2155 of file StandardModelMatching.cpp.

2156 {
2157  sw = sqrt( (M_PI * Ale ) / ( sqrt(2) * GF * Mw * Mw) );
2158 
2159  if ( swb == sw && xcacheb == x){
2160  switch (order){
2161  case NNLO:
2162  case NLO:
2163  return (CWbnlepArrayNLOqcd[i]);
2164  break;
2165  case LO:
2166  return (CWbnlepArrayLOqcd[i]);
2167  break;
2168  default:
2169  std::stringstream out;
2170  out << order;
2171  throw std::runtime_error("order" + out.str() + "not implemeted");
2172  }
2173  }
2174 
2175  swb = sw; xcacheb = x;
2176 
2177  switch (order){
2178  case NNLO:
2179  case NLO:
2180  CWbnlepArrayNLOqcd[0] = 11./2.;
2181  CWbnlepArrayNLOqcd[1] = -11./6.;
2182  CWbnlepArrayNLOqcd[2] = -1./6. * (E0b(x) - 2./3.);
2183  CWbnlepArrayNLOqcd[3] = 0.5 * (E0b(x) - 2./3.);
2184  CWbnlepArrayNLOqcd[4] = -1./6. * (E0b(x) - 2./3.);
2185  CWbnlepArrayNLOqcd[5] = 0.5 * (E0b(x) - 2./3.);
2186  case LO:
2187  CWbnlepArrayLOqcd[1] = 1.;
2188  break;
2189  default:
2190  std::stringstream out;
2191  out << order;
2192  throw std::runtime_error("order" + out.str() + "not implemeted");
2193  }
2194 
2195  switch (order){
2196  case NNLO:
2197  case NLO:
2198  return (CWbnlepArrayNLOqcd[i]);
2199  break;
2200  case LO:
2201  return (CWbnlepArrayLOqcd[i]);
2202  break;
2203  default:
2204  std::stringstream out;
2205  out << order;
2206  throw std::runtime_error("order" + out.str() + "not implemeted");
2207  }
2208 }
double E0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
Definition: OrderScheme.h:33
An observable class for the -boson mass.
Definition: Mw.h:22
complex sqrt(const complex &z)
double StandardModelMatching::setWCbnlepEW ( int  i,
double  x 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
Returns
return the value of the electroweak contribution to the Wilson coefficients for non-leptonic B decays

Definition at line 2210 of file StandardModelMatching.cpp.

2211 {
2212  sw = sqrt( (M_PI * Ale ) / ( sqrt(2) * GF * Mw * Mw) ) ;
2213 
2214  if ( swb == sw && xcacheb == x){
2215  return (CWbnlepArrayNLOew[i]);
2216  }
2217 
2218  swc = sw; xcachec = x;
2219 
2220  CWbnlepArrayNLOew[1] = -35./18.;
2221  CWbnlepArrayNLOew[2] = 2. / (3. * sw * sw) * ( 2. * B0b(x) + C0b(x) );
2222  CWbnlepArrayNLOew[6] = 2./3. * (4. * C0b(x) + D0b(x) - 4./9.);
2223  CWbnlepArrayNLOew[8] = 2./3. * (4. * C0b(x) + D0b(x) - 4./9. + (1. / (sw * sw)) *
2224  (10. * B0b(x) - 4. * C0b(x)) );
2225 
2226  return (CWbnlepArrayNLOew[i]);
2227 }
double B0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
double C0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
An observable class for the -boson mass.
Definition: Mw.h:22
double D0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
complex sqrt(const complex &z)
double StandardModelMatching::setWCbsg ( int  i,
double  x,
orders  order 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order
Returns
return the value of the wilson coefficients for \( B \rightarrow X_{s} \gamma, l^{+} l{-} \)

Definition at line 1163 of file StandardModelMatching.cpp.

1164 {
1165  sw = sqrt( sW2 );//sqrt( (M_PI * Ale )/( sqrt(2) * GF * Mw * Mw) ) ;
1166 
1167  if ( swf == sw && xcachef == x){
1168  switch (order){
1169  case NNLO:
1170  case NLO:
1171  return ( CWbsgArrayNLO[i] );
1172  break;
1173  case LO:
1174  return ( CWbsgArrayLO[i] );
1175  break;
1176  default:
1177  std::stringstream out;
1178  out << order;
1179  throw std::runtime_error("order" + out.str() + "not implemeted");
1180  }
1181  }
1182 
1183  swf = sw; xcachef = x;
1184 
1185  switch (order){
1186  case NNLO:
1187  case NLO:
1188  CWbsgArrayNLO[0] = 15. + 6*L;
1189  CWbsgArrayNLO[3] = E0t(x) - (7./9.) + (2./3.* L);
1190  CWbsgArrayNLO[6] = -0.5*A1t(x,Muw) + 713./243. + 4./81.*L - 4./9.*CWbsgArrayNLO[3];
1191  CWbsgArrayNLO[7] = -0.5*F1t(x,Muw) + 91./324. - 4./27.*L - 1./6.*CWbsgArrayNLO[3];
1192  case LO:
1193  CWbsgArrayLO[1] = 1.;
1194  CWbsgArrayLO[6] = -0.5*A0t(x) - 23./36.;
1195  CWbsgArrayLO[7] = -0.5*F0t(x) - 1./3.;
1196  break;
1197  default:
1198  std::stringstream out;
1199  out << order;
1200  throw std::runtime_error("order" + out.str() + "not implemeted");
1201  }
1202 
1203  switch (order){
1204  case NNLO:
1205  case NLO:
1206  return ( CWbsgArrayNLO[i] );
1207  break;
1208  case LO:
1209  return ( CWbsgArrayLO[i] );
1210  break;
1211  default:
1212  std::stringstream out;
1213  out << order;
1214  throw std::runtime_error("order" + out.str() + "not implemeted");
1215  }
1216 }
double A0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
Definition: OrderScheme.h:33
double F1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
double F0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the non-effec...
double E0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak ba...
double A1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
complex sqrt(const complex &z)
double StandardModelMatching::setWCBsmm ( int  i,
double  x,
orders  order 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order
Returns
return the value of the wilson coefficients for \( B_{s} \rightarrow l^{+} l{-} \)

Definition at line 1877 of file StandardModelMatching.cpp.

1878 {
1879 
1880  sw = sqrt( (M_PI * Ale ) / ( sqrt(2.) * GF * Mw * Mw) );
1881 
1882  if ( swd == sw && xcached == x){
1883  switch (order){
1884  case NNLO:
1885  return (CWBsmmArrayNNLOqcd[i]);
1886  break;
1887  case NLO:
1888  return (CWBsmmArrayNLOqcd[i]);
1889  break;
1890  case LO:
1891  return (CWBsmmArrayLOqcd[i]);
1892  break;
1893  default:
1894  std::stringstream out;
1895  out << order;
1896  throw std::runtime_error("order" + out.str() + "not implemeted");
1897  }
1898  }
1899 
1900  swd = sw; xcached = x;
1901 
1902  switch (order){
1903  case NNLO:
1904  CWBsmmArrayNNLOqcd[0] = sw * sw * (-Tt(x) + 7987./72. + 17. * M_PI * M_PI/3. + 475. * L/6. + 17. * L * L);
1905  CWBsmmArrayNNLOqcd[1] = sw * sw * (127./18. + 4. * M_PI * M_PI /3. + 46. * L/3. + 4. * L * L);
1906  CWBsmmArrayNNLOqcd[2] = sw * sw * (G1t(x, Muw) - 680./243. - 20. * M_PI * M_PI /81. - 68. * L/81. - 20. * L* L/27.);
1907  CWBsmmArrayNNLOqcd[3] = sw * sw * (E1t(x, Muw) + 950./243. + 10.* M_PI * M_PI /81. + 124. * L/27. + 10. * L * L/27.);
1908  CWBsmmArrayNNLOqcd[4] = sw * sw * (-G1t(x, Muw)/10. + 2. * E0t(x)/15. + 68./243. + 2. * M_PI * M_PI /81. + 14.* L/81. + 2. * L * L/27.);
1909  CWBsmmArrayNNLOqcd[5] = sw * sw * (-3. * G1t(x, Muw)/16. + E0t(x)/4. + 85./162. + 5. * M_PI * M_PI/108. + 35. * L/108. + 5. * L * L/36.);
1910 
1911  case NLO:
1912  CWBsmmArrayNLOqcd[0] = sw * sw * (15. + 6. * L);
1913  CWBsmmArrayNLOqcd[3] = sw * sw * (Eet(x) - 2./3. + 2. * L/3.);
1914 
1915  case LO:
1916  CWBsmmArrayLOqcd[1] = sw * sw * 1.;
1917 
1918  break;
1919  default:
1920  std::stringstream out;
1921  out << order;
1922  throw std::runtime_error("order" + out.str() + "not implemeted");
1923  }
1924  switch (order){
1925  case NNLO:
1926  return (CWBsmmArrayNNLOqcd[i]);
1927 
1928  break;
1929  case NLO:
1930  return (CWBsmmArrayNLOqcd[i]);
1931 
1932  break;
1933  case LO:
1934  return (CWBsmmArrayLOqcd[i]);
1935 
1936  break;
1937  default:
1938  std::stringstream out;
1939  out << order;
1940  throw std::runtime_error("order" + out.str() + "not implemeted");
1941  }
1942 }
double Eet(double x) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066
double Tt(double x) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220
double G1t(double x, double mu) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220
Definition: OrderScheme.h:33
double E1t(double x, double mu) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220
An observable class for the -boson mass.
Definition: Mw.h:22
double E0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak ba...
complex sqrt(const complex &z)
double StandardModelMatching::setWCBsmmEW ( int  i,
double  x,
orders_ew  order_ew 
)
private
Parameters
iint, flag for the caching
xthe square ratio between top mass and W mass
order_ew
Returns
return the electroweak value of the wilson coefficients for \( B_{s} \rightarrow l^{+} l{-} \)

Definition at line 1944 of file StandardModelMatching.cpp.

1945 {
1946  sw = sqrt( (M_PI * Ale ) / ( sqrt(2.) * GF * Mw * Mw) ) ;
1947 
1948  double mt = SM.Mrun(Muw, SM.getQuarks(QCD::TOP).getMass_scale(),
1950 
1951  if ( swe == sw && xcachee == x){
1952  switch (order_ew){
1953  case NLO_ewt4:
1954  return (CWBsmmArrayNLOewt4[i]);
1955  break;
1956  case NLO_ewt2:
1957  return (CWBsmmArrayNLOewt2[i]);
1958  break;
1959  case NLO_ew:
1960  return (CWBsmmArrayNLOew[i]);
1961  break;
1962  default:
1963  std::stringstream out;
1964  out << order_ew;
1965  throw std::runtime_error("order_ew" + out.str() + "not implemeted");
1966  }
1967 
1968  }
1969 
1970 
1971  swe = sw; xcachee = x;
1972 
1973  switch (order_ew){
1974  case NLO_ewt4:
1975  CWBsmmArrayNLOewt4[7] = sw * sw * (1./(sw * sw)) * Rest(x, Muw) ;
1976 
1977  case NLO_ewt2:
1978  CWBsmmArrayNLOewt2[6] = sw * sw * ((1. - 4. * sw * sw) * C1t(x, Muw) / (sw * sw) - B1t(x, Muw)/(sw * sw)
1979  - D1t(x, Muw) + 1./ (sw * sw) + 524./729. - 128. * M_PI * M_PI / 243.
1980  - 16. * L / 3. - 128. * L * L /81. ) ;
1981  CWBsmmArrayNLOewt2[7] = sw * sw * ((1./(sw * sw)) * (B1t(x, Muw) - C1t(x, Muw)) - 1./(sw * sw)) ;
1982 
1983  case NLO_ew:
1984  CWBsmmArrayNLOew[6] = sw * sw * (Y0(x)/(sw * sw) + Wt(x) + 4./9. - 4. * 2 * log(Muw/mt)/9.);
1985  CWBsmmArrayNLOew[7] = sw * sw * (-Y0(x)/(sw * sw));
1986 
1987  break;
1988  default:
1989  std::stringstream out;
1990  out << order_ew;
1991  throw std::runtime_error("order_ew" + out.str() + "not implemeted");
1992  }
1993 
1994  switch (order_ew){
1995  case NLO_ewt4:
1996  return (CWBsmmArrayNLOewt4[i]);
1997  break;
1998  case NLO_ewt1:
1999  return (CWBsmmArrayNLOewt2[i]);
2000  break;
2001  case NLO_ew:
2002  return (CWBsmmArrayNLOew[i]);
2003  break;
2004  default:
2005  std::stringstream out;
2006  out << order_ew;
2007  throw std::runtime_error("order_ew" + out.str() + "not implemeted");
2008  }
2009 }
double B1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
double D1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
double C1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
double Wt(double x) const
loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066
double Y0(double x) const
Definition: QCD.h:735
const StandardModel & SM
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
An observable class for the -boson mass.
Definition: Mw.h:22
complex log(const complex &z)
double Rest(double x, double mu) const
approximation of two-loops EW correction for Q_10 operator in the non-effective Misiak basis...
complex sqrt(const complex &z)
double StandardModelMatching::Tt ( double  x) const

loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/9910220

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 382 of file StandardModelMatching.cpp.

383 {
384 return ((-(16. * x +8.) * sqrt(4. * x - 1) * gsl_sf_clausen(2. * asin(1./2./sqrt(x)))) +((16. * x + 20./3.) * log(x)) + (32. * x) + (112./9)) ;
385 }
complex log(const complex &z)
complex sqrt(const complex &z)
void StandardModelMatching::updateSMParameters ( )

Updates to new Standard Model parameter sets.

Definition at line 102 of file StandardModelMatching.cpp.

103 {
104  Mut = SM.getMut();
105  Muw = SM.getMuw();
106  Ale = SM.getAle();
107  GF = SM.getGF();
108  Mw_tree = SM.Mw_tree();
109  /* NP models should be added here after writing codes for Mw. */
110  if (SM.ModelName()=="StandardModel") {
111  Mw = SM.Mw(); /* on-shell Mw */
112  sW2 = SM.sW2(); /* on-shell sW2 */
113  } else {
114  Mw = Mw_tree;
115  sW2 = 1.0 - Mw*Mw/SM.getMz()/SM.getMz();
116  }
117  Vckm = SM.getVCKM();
118  lam_t = SM.computelamt();
119  L=2*log(Muw/Mw);
120  mu_b = SM.getMub();
121 }
virtual double sW2(const double Mw_i) const
The square of the sine of the weak mixing angle in the on-shell scheme, denoted as ...
double getMub() const
A get method to access the threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:905
virtual double Mw_tree() const
The tree-level mass of the boson, .
gslpp::matrix< gslpp::complex > getVCKM() const
A get method to retrieve the CKM matrix.
double getMuw() const
A get method to retrieve the matching scale around the weak scale.
virtual double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
double getGF() const
A get method to retrieve the Fermi constant .
const StandardModel & SM
double getAle() const
A get method to retrieve the fine-structure constant .
gslpp::matrix< gslpp::complex > Vckm
An observable class for the -boson mass.
Definition: Mw.h:22
complex log(const complex &z)
std::string ModelName() const
A method to fetch the name of the model.
Definition: Model.h:56
gslpp::complex computelamt() const
The product of the CKM elements .
double getMut() const
A get method to access the threshold between six- and five-flavour theory in GeV. ...
Definition: QCD.h:896
double getMz() const
A get method to access the mass of the boson .
double StandardModelMatching::Wt ( double  x) const

loop function which appear in the Wilson coefficient in the non-effective Misiak basis, Misiak and Urban hep-ph/0512066

Parameters
[in]xthe square of the ratio between top mass and W mass
[in]muthe matching scale of the Wilson coefficients

Definition at line 387 of file StandardModelMatching.cpp.

388 {
389  double x2 = x * x;
390  double x3 = x * x * x;
391  double x4 = x * x * x * x;
392  double xm2 = pow(1. - x, 2);
393  double xm3 = xm2 * (1. - x);
394  double xm4 = xm3 * (1. - x);
395 
396 return ((-32. * x4 + 38. * x3 + 15. * x2 - 18. * x)/18./xm4 * log(x) -
397  (-18. * x4 + 163. * x3 - 259. *x2 + 108. * x)/36./xm3 );
398 }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)
double StandardModelMatching::X0t ( double  x) const

hep-ph/9512380v1

Parameters
[in]xthe square of the ratio between top mass and W mass
Returns
0th order loop function for the top contribution to K -> pi nu nu decays

Definition at line 533 of file StandardModelMatching.cpp.

533  {
534  return((x/8.)*((x+2.)/(x-1.)+(3.*x -6)/(x-1.)/(x-1.)*log(x)));
535 }
complex log(const complex &z)
double StandardModelMatching::X1t ( double  x) const

hep-ph/1009.0947v2

Parameters
[in]xthe square of the ratio between top mass and W mass
Returns
first order in QCD loop function for the top contribution to K -> pi nu nu decays

Definition at line 537 of file StandardModelMatching.cpp.

537  {
538 
539  double x2 = x * x;
540  double x3 = x2 * x;
541  double x4 = x3 * x;
542  double xm3 = pow(1.-x,3.);
543  double logx = log(x);
544 
545  return (-(29. * x - x2 -4. * x3) / (3. * (1. - x) * (1. - x))
546  - logx * (x + 9. * x2 - x3 - x4) / xm3
547  + logx * logx * (8. * x + 4. * x2 + x3 - x4) / (2. * xm3)
548  - gsl_sf_dilog(1.-x) * (4. * x - x3) / ((1. - x) * (1. - x))
549  - 8. * x * log(Mut*Mut/Muw/Muw) * (8. - 9. * x + x3 + 6. * logx)/8./xm3 );
550  }
complex pow(const complex &z1, const complex &z2)
complex log(const complex &z)