(Generated on Fri Feb 19 2016 13:25:08 by doxygen 1.8.9.1)
StandardModelMatching.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 HEPfit Collaboration
3  * All rights reserved.
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "StandardModelMatching.h"
9 #include "StandardModel.h"
10 #include "QCD.h"
11 #include <gsl/gsl_sf_dilog.h>
12 #include <gsl/gsl_sf_zeta.h>
13 #include <gsl/gsl_sf_clausen.h>
14 #include <stdexcept>
15 
16 
17 StandardModelMatching::StandardModelMatching(const StandardModel & SM_i)
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 }
101 
102 void StandardModelMatching::updateSMParameters()
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 }
122 
123 double StandardModelMatching::x_c(const double mu, const orders order) const
124 {
125  double mc = SM.Mrun(mu, SM.getQuarks(QCD::CHARM).getMass_scale(),
126  SM.getQuarks(QCD::CHARM).getMass(), order);
127  return mc*mc/Mw/Mw;
128 }
129 
130 double StandardModelMatching::x_t(const double mu, const orders order) const
131 {
132  double mt = SM.Mrun(mu, SM.getQuarks(QCD::TOP).getMass_scale(),
133  SM.getQuarks(QCD::TOP).getMass(), order);
134 #if SUSYFIT_DEBUG & 1
135  std::cout << "mt(" << mu << "," << order << ")=" << mt << std::endl;
136 #endif
137  return mt*mt/Mw/Mw;
138 }
139 
140 double StandardModelMatching::mt2omh2(const double mu, const orders order) const
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 }
146 
147 double StandardModelMatching::S0(double x) const
148 {
149  return S0(x, x);
150 }
151 
152 double StandardModelMatching::S0(double x, double y) const
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 }
165 
166 double StandardModelMatching::S0p( double x) const
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 }
171 
172 double StandardModelMatching::S11(double x) const
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 }
186 
187 double StandardModelMatching::S18(double x) const
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 }
201 
202 double StandardModelMatching::S1(double x) const
203 {
204  return (CF * S11(x) + (Nc - 1.) / 2. / Nc * S18(x));
205 }
206 
207 /*******************************************************************************
208  * loop functions misiak base for b -> s gamma *
209  * operator basis: - current current *
210  * - qcd penguins *
211  * - magnetic and chromomagnetic penguins *
212  * - semileptonic *
213  * ****************************************************************************/
214 
215 double StandardModelMatching::A0t(double x) const
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 }
223 
224 double StandardModelMatching::B0t(double x) const
225 {
226  return( x / (4.* (1. - x) * (1. - x)) * log(x) + 1. / (4. * (1. - x)) );
227 }
228 
229 double StandardModelMatching::C0t(double x) const
230 {
231  return( (3. * x * x + 2. * x) / (8. * (1. - x) * (1. - x)) * log(x) + (-x * x + 6. * x) / (8. * (1. - x)) );
232 }
233 
234 double StandardModelMatching::D0t(double x) const
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 }
243 
244 double StandardModelMatching::E0t(double x) const
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 }
251 
252 double StandardModelMatching::F0t(double x) const
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 }
260 
261 double StandardModelMatching::A1t(double x, double mu) const
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(),
271  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
279 
280 double StandardModelMatching::B1t(double x, double mu) const
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(),
286  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
293 
294 double StandardModelMatching::C1t(double x, double mu) const
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(),
301  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
309 
310 double StandardModelMatching::D1t(double x, double mu) const
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(),
318  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
326 
327 double StandardModelMatching::F1t(double x, double mu) const
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(),
335  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
343 
344 double StandardModelMatching::E1t(double x, double mu) const
345 
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(),
353  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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  }
362 
363 double StandardModelMatching::G1t(double x, double mu) const
364 
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(),
373  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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  }
381 
382 double StandardModelMatching::Tt(double x) const
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 }
386 
387 double StandardModelMatching::Wt(double x) const
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 }
399 
400 double StandardModelMatching::Eet(double x) const
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 }
410 
411 double StandardModelMatching::Rest(double x, double mu) const
412 
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  }
425 
426 double StandardModelMatching::Y0(double x) const
427 {
428  return( x/8. * ((4 - 5 * x + x * x + 3 * x * log(x))/pow(x - 1., 2.)) );
429 }
430 
431 double StandardModelMatching::Y1(double x, double mu) const
432 {
433  double x2 = x * x;
434  double x3 = x2 * x;
435  double x4 = x3 * x;
436  double logx = log(x);
437  double xm = 1. - x;
438  double xm2 = xm * xm;
439  double xm3 = xm2 * xm;
440 
441  return ((10. * x + 10. * x2 + 4. * x3)/(3 * xm2) - (2. * x - 8. * x2 - x3 - x4)/xm3 * logx
442  + (2. * x - 14. * x2 + x3 - x4)/(2. * xm3) * pow(logx, 2.)
443  + (2. * x + x3)/xm2 * gsl_sf_dilog(1. - x)
444  + 16. * x * (-4. + 3. * x + x3 - 6. * x * logx)/(8. * -xm3) * log(mu / Mw));
445 }
446 
447 double StandardModelMatching::C7LOeff(double x) const
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 }
455 
456 double StandardModelMatching::C8LOeff(double x) const
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 }
460 
461 double StandardModelMatching::C7NLOeff(double x) const
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 }
476 
477 double StandardModelMatching::C8NLOeff(double x) const
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 }
492 
493 
494 /******************************************************************************/
495 
496 
497 /*******************************************************************************
498  * loop functions Buras base for nonlep. b decays *
499  * operator basis: - current current *
500  * - qcd penguins *
501  * - ew penguins *
502  * ****************************************************************************/
503 
504 double StandardModelMatching::B0b(double x) const
505 {
506  return ( 0.25 * ( x / (1. - x) + x / (x * x - 2. * x + 1.) * log(x) ) );
507 }
508 
509 double StandardModelMatching::C0b(double x) const
510 {
511  return ( x / 8. * ( (x - 6.) / (x - 1.) + (3. * x + 2.) / ( x * x - 2. * x + 1.) * log(x) ) );
512 }
513 
514 double StandardModelMatching::D0b(double x) const
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 }
520 
521 double StandardModelMatching::E0b(double x) const
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 }
528 
529 /******************************************************************************/
530 /* loop functions for rare K and B decays, K-> pi nu nu & B-> Xs nu nu */
531 /******************************************************************************/
532 
533 double StandardModelMatching::X0t(double x) const{
534  return((x/8.)*((x+2.)/(x-1.)+(3.*x -6)/(x-1.)/(x-1.)*log(x)));
535 }
536 
537 double StandardModelMatching::X1t(double x) const{
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  }
551 
552 double StandardModelMatching::Xewt(double x, double a, double mu) const{
553  double b = 0.;
554  // WARNING: check consistency of EW scheme choice (see Gorbahn's NNLO papers)
555  double swsq = (M_PI * Ale )/( sqrt(2) * GF * Mw * Mw);
556 
557  double A[17], C[17];
558 
559  double x2 = x * x;
560  double x3 = x2 * x;
561  double x4 = x3 * x;
562  double x5 = x4 * x;
563  double x6 = x5 * x;
564  double x7 = x6 * x;
565  double x8 = x7 * x;
566  double M_PI2 = M_PI * M_PI;
567  double a2 = a * a;
568  double a3 = a2 * a;
569  double a4 = a3 * a;
570  double a5 = a4 * a;
571  double a6 = a5 * a;
572  double xm2 = (x - 1.) * (x - 1.);
573  double xm3 = xm2 * (x - 1.);
574  double axm = a * x - 1.;
575  double logx = log(x);
576  double loga = log(a);
577 
578  A[0] = (16. - 48. * a) * M_PI2 + (288. * a - (32. - 88. * a) * M_PI2 ) * x
579  + (2003. * a + 4. * (4. - 6. * a - a2 ) * M_PI2 )* x2
580  + (9. * a * (93. + 28. * a) - 4. * a * (3. - 2. * a + 8. * a2) * M_PI2 ) * x3
581  + (3. * a * (172. - 49. * a - 32. * a2) + 4. * a * (20. - a + 16. * a2 ) * M_PI2 ) * x4
582  - (3. * a * (168. + 11. * a - 24. * a2 ) + 4. * a * (45. + 8. *a2) * M_PI2) * x5
583  + 96. * a * M_PI2 * x6;
584 
585  A[1] = -768. * x - (525. - 867. * a) * x2 + (303. + 318. * a) * x3 - 195. * a * x4;
586 
587  A[2] = -8.*(95. - 67. * a + 11. * a2 ) * x2 + 2. * (662. - 78. * a - 177. * a2 + 40. * a3 ) * x3
588  - (608. + 476. * a - 595. * a2 + 114. * a3 ) * x4
589  + (44. + 188. * a - 321. * a2 + 103. * a3 - 8. * a4 ) * x5
590  - a*(28. - 72. * a + 33. * a2 - 4. * a3 ) * x6;
591 
592  A[3] = +48. - 10.*(57. + 4. * a) * x+ 51.*(29. + 10. * a) * x2 -
593  (841. + 1265. * a) * x3 + (308. + 347. * a) * x4
594  - (28. - 40. * a) * x5 + 12. * a * x6 ;
595 
596  A[4] = + 768. + (816. - 768. * a) * x+ (1240. - 1232. * a) * x2
597  - 4.*(415. + 2. * a) * x3 + (311. + 722. * a) * x4
598  + (145. - 267. * a) * x5 - (36. + 51. * a) * x6 + 20. * a * x7 ;
599 
600  A[5] = + 328. * x- (536. + 900. * a) * x2 + (208. + 1584. * a + 670. * a2 ) * x3
601  - a * (668. + 1161. * a + 225. * a2 ) * x4
602  + a2 * (479. + 362. * a + 28. * a2 ) * x5
603  - a3 *(143. + 42. * a) * x6 + 16. * a4 * x7;
604 
605  A[6] = + 32. - 4.*(44. - 9. * a) * x + (384. - 322. * a - 400. * a2 ) * x2
606  - (400. - 869. * a - 1126. * a2 - 696. * a3 ) * x3
607  + 2.*(80. - 488. * a - 517. * a2 - 631. * a3 - 264. * a4 ) * x4
608  + (48. + 394. * a + 269. * a2 + 190. * a3 + 882. * a4 + 196. * a5 ) * x5
609  - (64. - 58. * a - 89. * a2 - 95. * a3 + 34. * a4 + 296. * a5 + 32. * a6 ) * x6
610  + (16. - 59. * a - 79. * a2 + 256. * a3 - 239. * a4
611  + 57. * a5 + 48. * a6 ) * x7
612  + (1. - a) * (1. - a) * (1. - a) * a2 * (29. + 16. * a) * x8 ;
613 
614  A[7] = + 28. * a2 * x2 - 32. * a3 * x3;
615 
616  A[8] = - 288. + 36.*(1. + 8. * a) * x + 6.*(647. + 87. * a) * x2 + 5.*(55. - 927. * a - 132. * a2 ) * x3
617  - (1233. + 98. * a - 879. * a2 - 192. * a3 ) * x4
618  + (360. + 1371. * a - 315. * a2 - 264. * a3 ) * x5
619  - 24. * a * (17. - 4. * a2) * x6;
620 
621  A[9] = + 32. + 4.*(-44. + 29. * a) * x- 12.*(-32. + 77. * a + 31. * a2 ) * x2
622  + 2.*(-200. + 837. * a + 767. * a2 + 182. * a3 ) * x3
623  - 2.*(-80. + 625. * a + 905. * a2 + 520. * a3 + 82. * a4 ) * x4
624  + (48. + 1079. * a + 590. * a2 + 1002. * a3 + 462. * a4 + 32. * a5 ) * x5
625  + (-64. - 1160. * a - 501. * a2 - 364. * a3 - 486. * a4 - 72. * a5 ) * x6
626  + (16. + 729. * a + 1038. * a2 + 38. * a3 + 238. * a4 + 52. * a5 ) * x7
627  - a*(192. + 743. * a + 50. * a3 + 12. * a4 ) * x8 + 192. * a2 * x8 * x;
628 
629  A[10] = + 16. * x + 324. * x2 - 36. * x4;
630 
631  A[11] = + 216. * x - 672. * x2 + 152. * x3;
632 
633  A[12] = - 16. * x + (16. - 42. * a) * x2 + (16. + 21. * a + 60. * a2 ) * x3
634  - (16 - 21. * a + 45. * a2 + 32. * a3 ) * x4 - a2 * (7. - 24. * a) * x5;
635 
636  A[13] = - 32. + (144. - 68. * a) * x + (-240. + 334. * a + 332. * a2 ) * x2
637  + (160. - 551. * a - 660. * a2 - 364. * a3 ) * x3
638  + a * (329. + 451. * a + 650. * a2 + 164. * a3 ) * x4
639  + (-48. - a - 59. * a2 - 523. * a3 - 316. * a4 - 32. * a5 ) * x5
640  + (16. - 43. * a -93. * a2 + 255. * a3 + 287. * a4 + 32. * a5 ) * x6
641  - a2 * (-29. + 42. * a + 103. * a2 + 8. * a3 ) * x7;
642 
643  A[14] = - 144.*(1. - a)*(1. - a) * x2 + 144. * (1. - a) * (1. - a) * x3 - 36. * (1. - a) * (1. - a) * x4;
644 
645  A[15] = - 32. + 96. * a + (48. - 32. * a) * x - 176. * a * x2 - (16. - 74. * a) * x3 + 212. * a * x4;
646 
647  A[16] = - 32. + (64. - 100. * a) * x- 8.*(4. - 34. * a -29. * a2 ) * x2
648  - 4. * a * (34. + 170. * a + 33. * a2 ) * x3
649  + 8. * a2 * (47. + 51. * a + 4. * a2) * x4 - 16. * a3 * (15. + 4. * a) * x5
650  + 32. * a4 * x6;
651 
652  C[0] = 1. / (3.* a * xm2 * x);
653 
654  C[1] = phi1(0.25) / (xm3 * axm);
655 
656  C[2] = phi1(0.25 * a) / (2. * xm3 * axm);
657 
658  C[3] = phi1(1. / 4. / x) / (2. * xm3 * axm);
659 
660  C[4] = phi1(0.25 * x) / (2. * xm3 * axm);
661 
662  C[5] = phi1(a * x * 0.25) / (xm3 * axm);
663 
664  C[6] = phi2(1. / a / x, 1. / a) / (2. * a2 * x2 * xm3 * axm);
665 
666  C[7] = loga * log(a) / axm;
667 
668  C[8] = logx / (xm3 * axm * 3.);
669 
670  C[9] = logx * logx / ((x-1.) * xm3 * axm * 2. * a * x);
671 
672  C[10] = 2. * log(mu/Mw) / xm2;
673 
674  C[11] = logx * 2. * log(mu/Mw) / xm3;
675 
676  C[12] = loga / (xm2 * axm);
677 
678  C[13] = logx * loga / (2. * a * xm3 * x * axm);
679 
680  C[14] = gsl_sf_dilog(1. - a) / xm2;
681 
682  C[15] = gsl_sf_dilog(1. - x) / a / x;
683 
684  C[16] = gsl_sf_dilog(1. - a * x) / (a * x * xm2);
685 
686  for (int i=0; i<10; i++){
687  b += C[i]*A[i];
688  }
689 
690  return (b/128./swsq);
691 }
692 
693 double StandardModelMatching::phi1(double z) const{
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 }
710 
711 double StandardModelMatching::phi2(double x, double y) const{
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 }
729 
730 /*******************************************************************************
731  * Wilson coefficients Buras base for Delta B = 2 observables *
732  * ****************************************************************************/
733 
734  std::vector<WilsonCoefficient>& StandardModelMatching::CMdbd2()
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 }
783 
784  std::vector<WilsonCoefficient>& StandardModelMatching::CMdbs2()
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 }
824 
825 /*******************************************************************************
826  * Wilson coefficients Buras base for Delta S = 2 observables *
827  * Comment: they look empty because they are computed in Flavour/EvolDF2.cpp *
828  * due to historical reasons. *
829  * ****************************************************************************/
830 
831  std::vector<WilsonCoefficient>& StandardModelMatching::CMdk2()
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 }
853 
854  std::vector<WilsonCoefficient>& StandardModelMatching::CMd1Buras()
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 
869  mcd1Buras.setMu(Muw);
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 }
897 
898  std::vector<WilsonCoefficient>& StandardModelMatching::CMd1()
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 }
940 
941  std::vector<WilsonCoefficient>& StandardModelMatching::CMdd2()
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 }
976 
977  std::vector<WilsonCoefficient>& StandardModelMatching::CMK(){
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 }
1020 
1021 /*******************************************************************************
1022  * Wilson coefficients Buras base for K -> pi pi decays *
1023  * operator basis: - current current *
1024  * ****************************************************************************/
1025  std::vector<WilsonCoefficient>& StandardModelMatching::CMKCC(){
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 }
1070 
1071 
1072 /*******************************************************************************
1073  * Wilson coefficients misiak base for b -> s gamma *
1074  * operator basis: - current current *
1075  * - qcd penguins *
1076  * - magnetic and chromomagnetic penguins *
1077  * - semileptonic *
1078  * ****************************************************************************/
1079 std::vector<WilsonCoefficient>& StandardModelMatching::CMbsg()
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 }
1119 
1120 
1121 std::vector<WilsonCoefficient>& StandardModelMatching::CMprimebsg()
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 }
1158 
1159 /*******************************************************************************
1160  * Wilson coefficients calcoulus, misiak base for b -> s gamma *
1161  * ****************************************************************************/
1162 
1163 double StandardModelMatching::setWCbsg(int i, double x, orders order)
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 }
1217 
1218 
1219 
1220 
1221 /*******************************************************************************
1222  * Wilson coefficients misiak base for B -> K^*ll *
1223  * operator basis: - current current *
1224  * - qcd penguins *
1225  * - magnetic and chromomagnetic penguins *
1226  * - semileptonic *
1227  * ****************************************************************************/
1228  std::vector<WilsonCoefficient>& StandardModelMatching::CMBMll()
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 }
1267 
1268 
1269 
1270  /*******************************************************************************
1271  * Wilson coefficients calcoulus, misiak base for B -> K^*ll *
1272  * *****************************************************************************/
1273 
1274 double StandardModelMatching::setWCBMll(int i, double x, orders order)
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 }
1333 
1334 
1335 
1336 /*******************************************************************************
1337  * Wilson coefficients misiak primed base for B -> K^*ll *
1338  * operator basis: - current current *
1339  * - qcd penguins *
1340  * - magnetic and chromomagnetic penguins *
1341  * - semileptonic *
1342  * ****************************************************************************/
1343  std::vector<WilsonCoefficient>& StandardModelMatching::CMprimeBMll()
1344  {
1345  vmcprimeBMll.clear();
1346  mcprimeBMll.setMu(Muw);
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  }
1366 
1367 
1368  /******************************************************************************/
1369 
1370 /*******************************************************************************
1371  * Wilson coefficients Misiak base for bs -> mu mu. decays *
1372  * operator basis: - current current *
1373  * - qcd penguins *
1374  * - semileptonic *
1375  * ****************************************************************************/
1376 
1377  std::vector<WilsonCoefficient>& StandardModelMatching::CMbsmm() {
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 }
1474 
1475 /*******************************************************************************
1476  * Wilson coefficients Misiak base for bd -> mu mu. decays *
1477  * operator basis: - current current *
1478  * - qcd penguins *
1479  * - semileptonic *
1480  * ****************************************************************************/
1481 
1482  std::vector<WilsonCoefficient>& StandardModelMatching::CMbdmm() {
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 }
1578 
1579 
1580 /*******************************************************************************
1581  * Wilson coefficients calcoulus, misiak base for B -> tau nu *
1582  * ****************************************************************************/
1583 
1584  std::vector<WilsonCoefficient>& StandardModelMatching::CMbtaunu() {
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 }
1606 
1607 
1608 /******************************************************************************/
1609 
1610 /*******************************************************************************
1611  * Wilson coefficients Buras base for b -> nonlep. decays *
1612  * operator basis: - current current *
1613  * - qcd penguins *
1614  * - magnetic and chromomagnetic penguins *
1615  * - semileptonic *
1616  * i=0 deltaS=0 deltaC=0; i=1 1,0 ; *
1617  * ****************************************************************************/
1618  std::vector<WilsonCoefficient>& StandardModelMatching::CMbnlep(const int a)
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 }
1675 
1676 /*******************************************************************************
1677  * Wilson coefficients Buras base for b -> nonlep. decays *
1678  * operator basis: - current current opertors *
1679  * i=0 deltaS=0 deltaC=0; i=1 1,0 ; i=2 0,1 ; i=3 1,1 *
1680  * ****************************************************************************/
1681  std::vector<WilsonCoefficient>& StandardModelMatching::CMbnlepCC(const int a)
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 }
1748 
1749  std::vector<WilsonCoefficient>& StandardModelMatching::CMkpnn() {
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);
1755  double lambda5 = SM.getLambda()*SM.getLambda()*SM.getLambda()*SM.getLambda()*SM.getLambda();
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 }
1789 
1790  std::vector<WilsonCoefficient>& StandardModelMatching::CMkmm() {
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 }
1817 
1818  std::vector<WilsonCoefficient>& StandardModelMatching::CMBXsnn() {
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 }
1845 
1846  std::vector<WilsonCoefficient>& StandardModelMatching::CMBXdnn() {
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 }
1873 
1874 /*******************************************************************************
1875  * Wilson coefficients calculus, MISIAK base for Bs to mu mu decay *
1876  * ****************************************************************************/
1877 double StandardModelMatching::setWCBsmm(int i, double x, orders order)
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 }
1943 
1944 double StandardModelMatching::setWCBsmmEW(int i, double x, orders_ew order_ew)
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(),
1949  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
2010 
2011 
2012 
2013 
2014 /*******************************************************************************
2015  * Wilson coefficients calculus, MISIAK base for Bd to mu mu decay *
2016  * ****************************************************************************/
2017 double StandardModelMatching::setWCBdmm(int i, double x, orders order)
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 }
2083 
2084 double StandardModelMatching::setWCBdmmEW(int i, double x, orders_ew order_ew)
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(),
2089  SM.getQuarks(QCD::TOP).getMass(), FULLNNLO);
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 }
2150 
2151 
2152 /*******************************************************************************
2153  * Wilson coefficients calculus, Buras base for nonlep. b decays *
2154  * ****************************************************************************/
2155 double StandardModelMatching::setWCbnlep(int i, double x, orders order)
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 }
2209 
2210 double StandardModelMatching::setWCbnlepEW(int i, double x)
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 }
2228 
2229 gslpp::complex StandardModelMatching::S0c() const
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 }
2236 
2237 gslpp::complex StandardModelMatching::S0ct() const
2238 {
2239  double xc = SM.Mrun4(SM.getMuc(),SM.getQuarks(QCD::CHARM).getMass_scale(),SM.getQuarks(QCD::CHARM).getMass())/Mw;
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 }
2250 
2251 gslpp::complex StandardModelMatching::S0tt() const
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 }
2261 
2262 /*******************************************************************************
2263  * Wilson coefficients for Lepton Flavour Violation *
2264  * ****************************************************************************/
2265 
2266 std::vector<WilsonCoefficient>& StandardModelMatching::CMDLij(int li_lj) {
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 }
2289 
2290 std::vector<WilsonCoefficient>& StandardModelMatching::CMDLi3j(int li_lj) {
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 }
2331 
2332 std::vector<WilsonCoefficient>& StandardModelMatching::CMmueconv() {
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 }
2361 
2362 std::vector<WilsonCoefficient>& StandardModelMatching::CMgminus2mu() {
2363 
2364  vmcgminus2mu.clear();
2365 
2366  mcgminus2mu.setMu(Muw);
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 }
StandardModelMatching::C7LOeff
double C7LOeff(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the effective Misia...
Definition: StandardModelMatching.cpp:447
StandardModelMatching::B1t
double B1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
Definition: StandardModelMatching.cpp:280
StandardModelMatching::vmcd2
std::vector< WilsonCoefficient > vmcd2
Definition: StandardModelMatching.h:501
StandardModelMatching::CMbsmm
virtual std::vector< WilsonCoefficient > & CMbsmm()
Definition: StandardModelMatching.cpp:1377
QCD::getCF
double getCF() const
A get method to access the Casimir factor of QCD.
Definition: QCD.h:932
StandardModelMatching::Eet
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
Definition: StandardModelMatching.cpp:400
WilsonTemplate::setMu
virtual void setMu(double mu)
Definition: WilsonTemplate.h:97
LRI
Definition: OrderScheme.h:23
StandardModelMatching::CMDLi3j
virtual std::vector< WilsonCoefficient > & CMDLi3j(int li_lj)
Definition: StandardModelMatching.cpp:2290
lambda1
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:252
StandardModel::sW2
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 ...
Definition: StandardModel.cpp:750
StandardModelMatching::D1t
double D1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
Definition: StandardModelMatching.cpp:310
NLO_ew
Definition: OrderScheme.h:49
StandardModelMatching::vmck2
std::vector< WilsonCoefficient > vmck2
Definition: StandardModelMatching.h:501
StandardModelMatching::setWCBdmmEW
double setWCBdmmEW(int i, double x, orders_ew order_ew)
Definition: StandardModelMatching.cpp:2084
NLO_ewt2
Definition: OrderScheme.h:51
QCD::getMub
double getMub() const
A get method to access the threshold between five- and four-flavour theory in GeV.
Definition: QCD.h:905
StandardModel::Mw_tree
virtual double Mw_tree() const
The tree-level mass of the boson, .
Definition: StandardModel.cpp:677
StandardModel.h
QCD::Beta1
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
StandardModelMatching::C7NLOeff
double C7NLOeff(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the effective Misia...
Definition: StandardModelMatching.cpp:461
gslpp::complex::conjugate
complex conjugate() const
Definition: gslpp_complex.cpp:288
LO_ew
Definition: OrderScheme.h:48
StandardModelMatching::E0b
double E0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
Definition: StandardModelMatching.cpp:521
StandardModelMatching::S0ct
gslpp::complex S0ct() const
hep-ph/9512380
Definition: StandardModelMatching.cpp:2237
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
StandardModelMatching::vmcbnlep
std::vector< WilsonCoefficient > vmcbnlep
Definition: StandardModelMatching.h:502
StandardModelMatching::Tt
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
Definition: StandardModelMatching.cpp:382
StandardModelMatching::CMbtaunu
virtual std::vector< WilsonCoefficient > & CMbtaunu()
Definition: StandardModelMatching.cpp:1584
Particle::getMass_scale
double getMass_scale() const
A get method to access the scale at which the particle mass is defined.
Definition: Particle.h:133
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
StandardModelMatching::S1
double S1(double x) const
Definition: StandardModelMatching.cpp:202
StandardModelMatching::C1t
double C1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
Definition: StandardModelMatching.cpp:294
StandardModelMatching::mt2omh2
double mt2omh2(const double mu, const orders order=FULLNNLO) const
Definition: StandardModelMatching.cpp:140
StandardModelMatching::S18
double S18(double x) const
Definition: StandardModelMatching.cpp:187
StandardModelMatching::setWCBsmm
double setWCBsmm(int i, double x, orders order)
Definition: StandardModelMatching.cpp:1877
StandardModelMatching::Wt
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
Definition: StandardModelMatching.cpp:387
gslpp::complex::real
const double & real() const
Definition: gslpp_complex.cpp:53
StandardModel::computelamc
gslpp::complex computelamc() const
The product of the CKM elements .
Definition: StandardModel.cpp:514
QCD::Als
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
StandardModelMatching::B0t
double B0t(double x) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
Definition: StandardModelMatching.cpp:224
StandardModel::getLambda
double getLambda() const
A get method to retrieve the CKM element .
Definition: StandardModel.h:790
QCD::getNc
double getNc() const
A get method to access the number of colours .
Definition: QCD.h:840
StandardModelMatching::CMmueconv
virtual std::vector< WilsonCoefficient > & CMmueconv()
Definition: StandardModelMatching.cpp:2332
StandardModelMatching::CMKCC
virtual std::vector< WilsonCoefficient > & CMKCC()
operator basis:
Definition: StandardModelMatching.cpp:1025
NLO_ewt4
Definition: OrderScheme.h:53
StandardModelMatching::vmcgminus2mu
std::vector< WilsonCoefficient > vmcgminus2mu
Definition: StandardModelMatching.h:504
StandardModelMatching::CMdbd2
virtual std::vector< WilsonCoefficient > & CMdbd2()
,
Definition: StandardModelMatching.cpp:734
StandardModelMatching::B0b
double B0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
Definition: StandardModelMatching.cpp:504
StandardModelMatching::vmcprimeBMll
std::vector< WilsonCoefficient > vmcprimeBMll
Definition: StandardModelMatching.h:502
StandardModelMatching::vmcbsg
std::vector< WilsonCoefficient > vmcbsg
Definition: StandardModelMatching.h:502
StandardModelMatching::G1t
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: StandardModelMatching.cpp:363
StandardModelMatching::vmcbnlepCC
std::vector< WilsonCoefficient > vmcbnlepCC
Definition: StandardModelMatching.h:502
StandardModelMatching::S0p
double S0p(double x) const
Definition: StandardModelMatching.cpp:166
WilsonTemplate::getScheme
schemes getScheme() const
Definition: WilsonTemplate.h:103
NLO
Definition: OrderScheme.h:34
StandardModelMatching::Y0
double Y0(double x) const
Definition: StandardModelMatching.cpp:426
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:443
StandardModelMatching::X0t
double X0t(double x) const
hep-ph/9512380v1
Definition: StandardModelMatching.cpp:533
LEPS
#define LEPS
Definition: StandardModelMatching.h:14
WilsonCoefficient::setCoeff
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: WilsonCoefficient.h:40
StandardModelMatching::vmckpnn
std::vector< WilsonCoefficient > vmckpnn
Definition: StandardModelMatching.h:503
StandardModel::getVCKM
gslpp::matrix< gslpp::complex > getVCKM() const
A get method to retrieve the CKM matrix.
Definition: StandardModel.h:772
FULLNNLO
Definition: OrderScheme.h:37
ModelMatching
A class for a template of model matching.
Definition: ModelMatching.h:22
StandardModelMatching::C0b
double C0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
Definition: StandardModelMatching.cpp:509
StandardModelMatching::A0t
double A0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
Definition: StandardModelMatching.cpp:215
StandardModel::getMuw
double getMuw() const
A get method to retrieve the matching scale around the weak scale.
Definition: StandardModel.h:876
QCD::TOP
Definition: QCD.h:735
StandardModelMatching::CMBXsnn
virtual std::vector< WilsonCoefficient > & CMBXsnn()
Definition: StandardModelMatching.cpp:1818
StandardModelMatching::vmcbsnn
std::vector< WilsonCoefficient > vmcbsnn
Definition: StandardModelMatching.h:503
StandardModelMatching::CMprimebsg
virtual std::vector< WilsonCoefficient > & CMprimebsg()
operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic ...
Definition: StandardModelMatching.cpp:1121
StandardModel::Mw
virtual double Mw() const
The SM prediction for the -boson mass in the on-shell scheme, .
Definition: StandardModel.cpp:696
WilsonTemplate::getOrder_ew
orders_ew getOrder_ew() const
Definition: WilsonTemplate.h:75
orders_ew
orders_ew
An enum type for orders in electroweak.
Definition: OrderScheme.h:45
StandardModelMatching::vmcbdnn
std::vector< WilsonCoefficient > vmcbdnn
Definition: StandardModelMatching.h:503
NNLO
Definition: OrderScheme.h:35
StandardModelMatching::CMd1
virtual std::vector< WilsonCoefficient > & CMd1()
current-current oerators, Misiak basis
Definition: StandardModelMatching.cpp:898
StandardModelMatching::mcprimeBMll
WilsonCoefficient mcprimeBMll
Definition: StandardModelMatching.h:514
lambda5
An observable class for the quartic Higgs potential coupling .
Definition: THDMquantities.h:344
StandardModelMatching::CMkmm
virtual std::vector< WilsonCoefficient > & CMkmm()
Definition: StandardModelMatching.cpp:1790
StandardModelMatching::S0tt
gslpp::complex S0tt() const
hep-ph/9512380v1
Definition: StandardModelMatching.cpp:2251
StandardModel::computelamt_d
gslpp::complex computelamt_d() const
The product of the CKM elements .
Definition: StandardModel.cpp:524
StandardModelMatching::vmcmueconv
std::vector< WilsonCoefficient > vmcmueconv
Definition: StandardModelMatching.h:504
StandardModelMatching::phi2
double phi2(double x, double y) const
Definition: StandardModelMatching.cpp:711
StandardModelMatching::updateSMParameters
void updateSMParameters()
Updates to new Standard Model parameter sets.
Definition: StandardModelMatching.cpp:102
StandardModelMatching.h
StandardModel::getGF
double getGF() const
A get method to retrieve the Fermi constant .
Definition: StandardModel.h:703
StandardModelMatching::x_c
double x_c(const double mu, const orders order=FULLNNLO) const
Definition: StandardModelMatching.cpp:123
StandardModelMatching::CMBMll
virtual std::vector< WilsonCoefficient > & CMBMll()
operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic ...
Definition: StandardModelMatching.cpp:1228
QCD.h
StandardModelMatching::vmcdb
std::vector< WilsonCoefficient > vmcdb
Definition: StandardModelMatching.h:501
NLO_ewt3
Definition: OrderScheme.h:52
LO
Definition: OrderScheme.h:33
StandardModelMatching::setWCBMll
double setWCBMll(int i, double x, orders order)
Definition: StandardModelMatching.cpp:1274
StandardModelMatching::Xewt
double Xewt(double x, double a, double mu) const
hep-ph/1009.0947v2
Definition: StandardModelMatching.cpp:552
StandardModelMatching::CMkpnn
virtual std::vector< WilsonCoefficient > & CMkpnn()
Definition: StandardModelMatching.cpp:1749
NLO_ewt1
Definition: OrderScheme.h:50
StandardModelMatching::SM
const StandardModel & SM
Definition: StandardModelMatching.h:508
StandardModelMatching::vmcbdmm
std::vector< WilsonCoefficient > vmcbdmm
Definition: StandardModelMatching.h:503
StandardModelMatching::setWCbnlep
double setWCbnlep(int i, double x, orders order)
Definition: StandardModelMatching.cpp:2155
StandardModelMatching::setWCbnlepEW
double setWCbnlepEW(int i, double x)
Definition: StandardModelMatching.cpp:2210
StandardModel::computelamu_d
gslpp::complex computelamu_d() const
The product of the CKM elements .
Definition: StandardModel.cpp:534
StandardModelMatching::vmcprimebsg
std::vector< WilsonCoefficient > vmcprimebsg
Definition: StandardModelMatching.h:502
StandardModelMatching::C8NLOeff
double C8NLOeff(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the effective...
Definition: StandardModelMatching.cpp:477
StandardModelMatching::vmck
std::vector< WilsonCoefficient > vmck
Definition: StandardModelMatching.h:501
StandardModelMatching::mcprimebsg
WilsonCoefficient mcprimebsg
Definition: StandardModelMatching.h:514
StandardModelMatching::phi1
double phi1(double z) const
Definition: StandardModelMatching.cpp:693
FULLNLO
Definition: OrderScheme.h:36
StandardModelMatching::CMbnlep
virtual std::vector< WilsonCoefficient > & CMbnlep(int a)
operator basis:
Definition: StandardModelMatching.cpp:1618
StandardModelMatching::C0t
double C0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
Definition: StandardModelMatching.cpp:229
StandardModelMatching::S0c
gslpp::complex S0c() const
hep-ph/9512380
Definition: StandardModelMatching.cpp:2229
QCD::getQuarks
Particle getQuarks(const quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:869
StandardModelMatching::setWCbsg
double setWCbsg(int i, double x, orders order)
Definition: StandardModelMatching.cpp:1163
StandardModelMatching::CMbsg
virtual std::vector< WilsonCoefficient > & CMbsg()
operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic ...
Definition: StandardModelMatching.cpp:1079
StandardModel::computelamt_s
gslpp::complex computelamt_s() const
The product of the CKM elements .
Definition: StandardModel.cpp:539
StandardModelMatching::CMgminus2mu
virtual std::vector< WilsonCoefficient > & CMgminus2mu()
Definition: StandardModelMatching.cpp:2362
StandardModelMatching::F1t
double F1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
Definition: StandardModelMatching.cpp:327
StandardModel::getAle
double getAle() const
A get method to retrieve the fine-structure constant .
Definition: StandardModel.h:712
StandardModelMatching::CMdbs2
virtual std::vector< WilsonCoefficient > & CMdbs2()
,
Definition: StandardModelMatching.cpp:784
HV
Definition: OrderScheme.h:22
StandardModelMatching::E1t
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
Definition: StandardModelMatching.cpp:344
StandardModelMatching::Vckm
gslpp::matrix< gslpp::complex > Vckm
Definition: StandardModelMatching.h:532
StandardModelMatching::vmcbsmm
std::vector< WilsonCoefficient > vmcbsmm
Definition: StandardModelMatching.h:503
Particle::getMass
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
StandardModelMatching::CMbnlepCC
virtual std::vector< WilsonCoefficient > & CMbnlepCC(int a)
operator basis: - current current opertors
Definition: StandardModelMatching.cpp:1681
StandardModelMatching::vmcds
std::vector< WilsonCoefficient > vmcds
Definition: StandardModelMatching.h:501
Mw
An observable class for the -boson mass.
Definition: Mw.h:22
StandardModelMatching::StandardModelMatching
StandardModelMatching(const StandardModel &SM_i)
Definition: StandardModelMatching.cpp:17
StandardModelMatching::CMbdmm
virtual std::vector< WilsonCoefficient > & CMbdmm()
Definition: StandardModelMatching.cpp:1482
StandardModelMatching::D0t
double D0t(double x) const
loop function which appear in the Wilson coefficient for the magnetic operator in the non-effective M...
Definition: StandardModelMatching.cpp:234
StandardModelMatching::vmckmm
std::vector< WilsonCoefficient > vmckmm
Definition: StandardModelMatching.h:503
QCD::getMuc
double getMuc() const
A get method to access the threshold between four- and three-flavour theory in GeV.
Definition: QCD.h:914
StandardModelMatching::setWCBdmm
double setWCBdmm(int i, double x, orders order)
Definition: StandardModelMatching.cpp:2017
StandardModelMatching::vmcd1
std::vector< WilsonCoefficient > vmcd1
Definition: StandardModelMatching.h:502
gslpp::complex::imag
const double & imag() const
Definition: gslpp_complex.cpp:59
StandardModelMatching::C8LOeff
double C8LOeff(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the effective...
Definition: StandardModelMatching.cpp:456
StandardModelMatching::vmcDLij
std::vector< WilsonCoefficient > vmcDLij
Definition: StandardModelMatching.h:504
StandardModelMatching::CMdk2
virtual std::vector< WilsonCoefficient > & CMdk2()
Definition: StandardModelMatching.cpp:831
StandardModelMatching::vmcbtaunu
std::vector< WilsonCoefficient > vmcbtaunu
Definition: StandardModelMatching.h:503
StandardModelMatching::S0
double S0(double, double) const
Definition: StandardModelMatching.cpp:152
StandardModelMatching::X1t
double X1t(double x) const
hep-ph/1009.0947v2
Definition: StandardModelMatching.cpp:537
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
StandardModelMatching::vmcd1Buras
std::vector< WilsonCoefficient > vmcd1Buras
Definition: StandardModelMatching.h:502
StandardModelMatching::setWCBsmmEW
double setWCBsmmEW(int i, double x, orders_ew order_ew)
Definition: StandardModelMatching.cpp:1944
StandardModelMatching::CMBXdnn
virtual std::vector< WilsonCoefficient > & CMBXdnn()
Definition: StandardModelMatching.cpp:1846
WilsonTemplate::getOrder
orders getOrder() const
Definition: WilsonTemplate.h:70
StandardModelMatching::Rest
double Rest(double x, double mu) const
approximation of two-loops EW correction for Q_10 operator in the non-effective Misiak basis...
Definition: StandardModelMatching.cpp:411
StandardModelMatching::vmcDLi3j
std::vector< WilsonCoefficient > vmcDLi3j
Definition: StandardModelMatching.h:504
StandardModelMatching::vmckcc
std::vector< WilsonCoefficient > vmckcc
Definition: StandardModelMatching.h:501
StandardModelMatching::Y1
double Y1(double x, double mu) const
Definition: StandardModelMatching.cpp:431
StandardModelMatching::F0t
double F0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the non-effec...
Definition: StandardModelMatching.cpp:252
StandardModelMatching::x_t
double x_t(const double mu, const orders order=FULLNNLO) const
Definition: StandardModelMatching.cpp:130
StandardModelMatching::S11
double S11(double x) const
Definition: StandardModelMatching.cpp:172
StandardModel::computelamu_s
gslpp::complex computelamu_s() const
The product of the CKM elements .
Definition: StandardModel.cpp:549
StandardModelMatching::E0t
double E0t(double x) const
loop function which appear in the Wilson coefficient for the chromomagnetic operator in the Misiak ba...
Definition: StandardModelMatching.cpp:244
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
Model::ModelName
std::string ModelName() const
A method to fetch the name of the model.
Definition: Model.h:56
StandardModel::getMHl
double getMHl() const
A get method to retrieve the Higgs mass .
Definition: StandardModel.h:732
StandardModelMatching::A1t
double A1t(double x, double mu) const
loop function which appear in the Wilson coefficient for the semileptonic operator in the non-effecti...
Definition: StandardModelMatching.cpp:261
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
StandardModelMatching::CMdd2
virtual std::vector< WilsonCoefficient > & CMdd2()
,
Definition: StandardModelMatching.cpp:941
StandardModelMatching::vmcBMll
std::vector< WilsonCoefficient > vmcBMll
Definition: StandardModelMatching.h:502
StandardModelMatching::CMd1Buras
virtual std::vector< WilsonCoefficient > & CMd1Buras()
current-current oerators, Buras basis
Definition: StandardModelMatching.cpp:854
StandardModelMatching::CMK
virtual std::vector< WilsonCoefficient > & CMK()
operator basis:
Definition: StandardModelMatching.cpp:977
StandardModelMatching::D0b
double D0b(double x) const
loop functions for non-leptonic B decays, Buiras Basis Buras et al, hep-ph/9512380v1 ...
Definition: StandardModelMatching.cpp:514
StandardModel::computelamt
gslpp::complex computelamt() const
The product of the CKM elements .
Definition: StandardModel.cpp:509
QCD::getMut
double getMut() const
A get method to access the threshold between six- and five-flavour theory in GeV. ...
Definition: QCD.h:896
NDR
Definition: OrderScheme.h:21
StandardModelMatching::mcgminus2mu
WilsonCoefficient mcgminus2mu
Definition: StandardModelMatching.h:516
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:685
StandardModelMatching::CMprimeBMll
virtual std::vector< WilsonCoefficient > & CMprimeBMll()
operator basis: current current; qcd penguins; magnetic and chromomagnetic penguins; semileptonic ...
Definition: StandardModelMatching.cpp:1343
StandardModelMatching::CMDLij
virtual std::vector< WilsonCoefficient > & CMDLij(int li_lj)
Definition: StandardModelMatching.cpp:2266
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385