(Generated on Fri Feb 19 2016 13:25:07 by doxygen 1.8.9.1)
HeffDB1.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 "HeffDB1.h"
9 #include "gslpp_complex.h"
10 
11 HeffDB1::HeffDB1(const StandardModel & SM)
12 : model(SM),
13  coeffnlep00qcd (10, NDR, NLO, NLO_ew), coeffnlep00 (12, NDR, NLO, NLO_ew),
14  coeffnlep10qcd (10, NDR, NLO, NLO_ew), coeffnlep10 (12, NDR, NLO, NLO_ew),
15  coeffnlep01 (10, NDR, NLO), coeffnlep01A(10, NDR, NLO), coeffnlep01B(4, NDR, NLO), coeffnlep00CC(10, NDR, NLO),
16  coeffnlep11 (10, NDR, NLO), coeffnlep11A(10, NDR, NLO), coeffnlep11B(4, NDR, NLO), coeffnlep10CC(10, NDR, NLO),
17  coeffsmumu (8, NDR, NNLO, NLO_ewt4), coeffdmumu (8, NDR, NNLO, NLO_ewt4),
18  coeffbtaunu (3, NDR, LO),
19  coeffsnunu (1, NDR, NLO), coeffdnunu (1, NDR, NLO),
20  coeffsgamma(8,NDR, NLO),
21  coeffprimesgamma(8,NDR, NLO),
22  coeffBMll (13,NDR, NLO),
23  coeffprimeBMll (13, NDR, NLO),
24  evolDF1BMll(13, NDR, NLO, SM),
25  evolDB1bsg(8, NDR, NLO, SM),
26  evolbs(8, NDR, NNLO, NLO_ewt4, SM), evolbd(8, NDR, NNLO, NLO_ewt4, SM),
27  nlep (12, 0.), nlep2(10, 0.),
28  nlepCC(4, 0.)
29 {
30 
31  for (unsigned int i = 0; i < 6; i++) {
32  BMll_WC_cache.push_back(coeffBMll);
33  BMll_Mu_cache.push_back(0.);
34  }
35  BMll_mu_cache = 0.;
36 
37  for (unsigned int i = 0; i < 6; i++) {
38  BMllprime_WC_cache.push_back(coeffprimeBMll);
39  BMllprime_Mu_cache.push_back(0.);
40  }
41  BMllprime_mu_cache = 0.;
42 
43  for (unsigned int i = 0; i < 6; i++) {
44  Bsgamma_WC_cache.push_back(coeffsgamma);
45  Bsgamma_Mu_cache.push_back(0.);
46  }
47  Bsgamma_mu_cache = 0.;
48 
49  for (unsigned int i = 0; i < 6; i++) {
50  Bpsgamma_WC_cache.push_back(coeffsgamma);
51  Bpsgamma_Mu_cache.push_back(0.);
52  }
53 
54  for (unsigned int i = 0; i < 6; i++) {
55  Bsmumu_WC_cache.push_back(coeffsmumu);
56  Bsmumu_Mu_cache.push_back(0.);
57  }
58  Bsmumu_mu_cache = 0.;
59 
60  for (unsigned int i = 0; i < 6; i++) {
61  Bdmumu_WC_cache.push_back(coeffdmumu);
62  Bdmumu_Mu_cache.push_back(0.);
63  }
64  Bdmumu_mu_cache = 0.;
65 }
66 
67 HeffDB1::~HeffDB1()
68 {}
69 
70 
71 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsmumu(double mu, schemes scheme)
72 {
73 
74 
75  coeffsmumu.setScheme(scheme);
76  orders ordDF1 = coeffsmumu.getOrder();
77  orders_ew ordDF1ew = coeffsmumu.getOrder_ew();
78 
79  const std::vector<WilsonCoefficient>& mcbsm = model.getMyMatching() -> CMbsmm();
80 
81  if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
82  int check = 1;
83  for (unsigned int i = 0; i < mcbsm.size(); i++) {
84  if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
85  for (int j = LO; j <= ordDF1; j++) {
86  for (int k = LO; k <= j; k++) {
87  for (int l = 0; l < 8; l++) {
88  check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
89  }
90  }
91  }
92  } else check = 0;
93  }
94  if (check == 1) return coeffsmumu.getCoeff();
95  }
96 
97  double nf = 5; //al the process has nf = 5, also the evolutor
98 
99  //int L = 6 - (int) nf;
100  int j = 0;
101  double alsM = evolbs.alphatilde_s(mcbsm[0].getMu());
102  double alsmu = evolbs.alphatilde_s(mu);
103  double eta = alsM / alsmu;
104 
105  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
106 
107  double B00E = 80./9., B01E = 176./9.;
108 
109  double logeta = log(eta);
110  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
111  double app = B00E * (1. - eta)/ B00S;
112 
113  Bsmumu_mu_cache = mu;
114  Bsmumu_scheme_cache = scheme;
115  Bsmumu_WC_cache.clear();
116  Bsmumu_WC_cache = mcbsm;
117 
118  coeffsmumu.setMu(mu);
119 
120  for (unsigned int i = 0; i < mcbsm.size(); i++){
121  Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
122  for (j = LO; j <= ordDF1; j++){
123  for (int k = LO; k <= j; k++){
124  if ((k <= NNLO) && (j <= NNLO)){
125  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
126  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(k), NULL_ew, mcbsm[i].getScheme()) *
127  (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
128  }
129  }
130  }
131 
132  for (j = LO_ew; j <= ordDF1ew; j++){
133 
134  switch(j) {
135 
136  case(NLO_ewt4):
137 
138  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) +
139  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
140  (*(mcbsm[i].getCoeff(orders_ew(NLO_ewt4)))) +
141  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbsm[i].getScheme()) *
142  (*(mcbsm[i].getCoeff(orders_ew(NLO_ew)))) +
143  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
144  (*(mcbsm[i].getCoeff(orders(LO)))) +
145  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
146  (*(mcbsm[i].getCoeff(orders_ew(NLO_ewt2)))) +
147  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbsm[i].getScheme()) *
148  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
149  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ewt3), mcbsm[i].getScheme()) *
150  (*(mcbsm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
151  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
152  (*(mcbsm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
153  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
154  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
155  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
156  (*(mcbsm[i].getCoeff(orders(LO)))) +
157  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
158  (*(mcbsm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
159  * app *
160  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
161  (*(mcbsm[i].getCoeff(orders(NLO)))) +
162  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
163  (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
164 
165  break;
166 
167  case(NLO_ewt3):
168 
169  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + (1./ eta) *
170  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
171  (*(mcbsm[i].getCoeff(orders_ew(NLO_ew)))) +
172  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbsm[i].getScheme()) *
173  (*(mcbsm[i].getCoeff(orders(NLO)))) +
174  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
175  (*(mcbsm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
176  * app *
177  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
178  (*(mcbsm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
179  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
180  (*(mcbsm[i].getCoeff(orders(NLO)))) +
181  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
182  (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
183 
184  break;
185 
186  case(NLO_ewt2):
187 
188  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + eta *
189  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
190  (*(mcbsm[i].getCoeff(orders_ew(j)))) +
191  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
192  (*(mcbsm[i].getCoeff(orders_ew(NLO_ew)))) +
193  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbsm[i].getScheme()) *
194  (*(mcbsm[i].getCoeff(orders(NLO)))) +
195  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
196  (*(mcbsm[i].getCoeff(orders(LO)))) +
197  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
198  (*(mcbsm[i].getCoeff(orders(NNLO)))))-
199  eta * logeta * fatt *
200  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
201  (*(mcbsm[i].getCoeff(orders(NLO)))) +
202  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
203  (*(mcbsm[i].getCoeff(orders(LO)))))
204  - eta * app *
205  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
206  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
207  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NNLO), NULL_ew, mcbsm[i].getScheme()) *
208  (*(mcbsm[i].getCoeff(orders(LO)))) +
209  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
210  (*(mcbsm[i].getCoeff(orders(NLO)))) ), orders_ew(j));
211 
212  break;
213 
214  case(NLO_ewt1):
215 
216  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,2)) *
217  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
218  (*(mcbsm[i].getCoeff(orders(LO)))) + ( app
219  * app/( eta * eta ) ) *
220  evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
221  (*(mcbsm[i].getCoeff(orders(LO)))), orders_ew(j));
222 
223  break;
224 
225  case(NLO_ew):
226 
227  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) +
228  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
229  (*(mcbsm[i].getCoeff(orders(LO)))) +
230  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
231  (*(mcbsm[i].getCoeff(orders_ew(j)))) +
232  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
233  (*(mcbsm[i].getCoeff(orders(NLO)))) - logeta * fatt *
234  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
235  (*(mcbsm[i].getCoeff(orders(LO))))) - app *
236  (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
237  (*(mcbsm[i].getCoeff(orders(NLO)))) +
238  evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
239  (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
240 
241 
242  break;
243 
244  case(LO_ew):
245 
246  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,1)) *
247  evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
248  (*(mcbsm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
249  ( evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
250  (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
251 
252 
253 
254  break;
255  }
256  }
257  }
258  return coeffsmumu.getCoeff();
259 }
260 
261 
262 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffdmumu(double mu, schemes scheme)
263 {
264 
265  coeffdmumu.setScheme(scheme);
266  orders ordDF1 = coeffdmumu.getOrder();
267  orders_ew ordDF1ew = coeffdmumu.getOrder_ew();
268 
269  const std::vector<WilsonCoefficient>& mcbdm = model.getMyMatching() -> CMbdmm();
270 
271  if (mu == Bdmumu_mu_cache && scheme == Bdmumu_scheme_cache) {
272  int check = 1;
273  for (unsigned int i = 0; i < mcbdm.size(); i++) {
274  if (mcbdm[i].getMu() == Bdmumu_Mu_cache[i]) {
275  for (int j = LO; j <= ordDF1; j++) {
276  for (int k = LO; k <= j; k++) {
277  for (int l = 0; l < 8; l++) {
278  check *= ((*(mcbdm[i].getCoeff(orders(j - k))))(l) == (*(Bdmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
279  }
280  }
281  }
282  } else check = 0;
283  }
284  if (check == 1) return coeffdmumu.getCoeff();
285  }
286 
287  double nf = 5; //al the process has nf = 5, also the evolutor
288 
289  //int L = 6 - (int) nf;
290  int j = 0;
291  double alsM = evolbd.alphatilde_s(mcbdm[0].getMu());
292  double alsmu = evolbd.alphatilde_s(mu);
293  double eta = alsM / alsmu;
294 
295  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
296 
297  double B00E = 80./9., B01E = 176./9.;
298 
299  double logeta = log(eta);
300  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
301  double app = B00E * (1. - eta)/ B00S;
302 
303  Bdmumu_mu_cache = mu;
304  Bdmumu_scheme_cache = scheme;
305  Bdmumu_WC_cache.clear();
306  Bdmumu_WC_cache = mcbdm;
307 
308  coeffdmumu.setMu(mu);
309 
310  for (unsigned int i = 0; i < mcbdm.size(); i++){
311  Bdmumu_Mu_cache[i] = mcbdm[i].getMu();
312  for (j = LO; j <= ordDF1; j++){
313  for (int k = LO; k <= j; k++){
314  if ((k <= NNLO) && (j <= NNLO)){
315  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders(j)) + pow(eta,j) *
316  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(k), NULL_ew, mcbdm[i].getScheme()) *
317  (*(mcbdm[i].getCoeff(orders(j - k)))), orders(j));
318  }
319  }
320  }
321 
322  for (j = LO_ew; j <= ordDF1ew; j++){
323 
324  switch(j) {
325 
326  case(NLO_ewt4):
327 
328  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) +
329  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
330  (*(mcbdm[i].getCoeff(orders_ew(NLO_ewt4)))) +
331  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbdm[i].getScheme()) *
332  (*(mcbdm[i].getCoeff(orders_ew(NLO_ew)))) +
333  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
334  (*(mcbdm[i].getCoeff(orders(LO)))) +
335  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
336  (*(mcbdm[i].getCoeff(orders_ew(NLO_ewt2)))) +
337  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbdm[i].getScheme()) *
338  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
339  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ewt3), mcbdm[i].getScheme()) *
340  (*(mcbdm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
341  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
342  (*(mcbdm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
343  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
344  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
345  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
346  (*(mcbdm[i].getCoeff(orders(LO)))) +
347  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
348  (*(mcbdm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
349  * app *
350  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
351  (*(mcbdm[i].getCoeff(orders(NLO)))) +
352  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
353  (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
354 
355  break;
356 
357  case(NLO_ewt3):
358 
359  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + (1./ eta) *
360  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
361  (*(mcbdm[i].getCoeff(orders_ew(NLO_ew)))) +
362  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbdm[i].getScheme()) *
363  (*(mcbdm[i].getCoeff(orders(NLO)))) +
364  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
365  (*(mcbdm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
366  * app *
367  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
368  (*(mcbdm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
369  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
370  (*(mcbdm[i].getCoeff(orders(NLO)))) +
371  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
372  (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
373 
374  break;
375 
376  case(NLO_ewt2):
377 
378  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + eta *
379  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
380  (*(mcbdm[i].getCoeff(orders_ew(j)))) +
381  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
382  (*(mcbdm[i].getCoeff(orders_ew(NLO_ew)))) +
383  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbdm[i].getScheme()) *
384  (*(mcbdm[i].getCoeff(orders(NLO)))) +
385  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
386  (*(mcbdm[i].getCoeff(orders(LO)))) +
387  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
388  (*(mcbdm[i].getCoeff(orders(NNLO)))))-
389  eta * logeta * fatt *
390  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
391  (*(mcbdm[i].getCoeff(orders(NLO)))) +
392  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
393  (*(mcbdm[i].getCoeff(orders(LO)))))
394  - eta * app *
395  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
396  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
397  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NNLO), NULL_ew, mcbdm[i].getScheme()) *
398  (*(mcbdm[i].getCoeff(orders(LO)))) +
399  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
400  (*(mcbdm[i].getCoeff(orders(NLO)))) ), orders_ew(j));
401 
402  break;
403 
404  case(NLO_ewt1):
405 
406  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,2)) *
407  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
408  (*(mcbdm[i].getCoeff(orders(LO)))) + ( app
409  * app/(eta * eta ) ) *
410  evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
411  (*(mcbdm[i].getCoeff(orders(LO)))), orders_ew(j));
412 
413  break;
414 
415  case(NLO_ew):
416 
417  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) +
418  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
419  (*(mcbdm[i].getCoeff(orders(LO)))) +
420  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
421  (*(mcbdm[i].getCoeff(orders_ew(j)))) +
422  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
423  (*(mcbdm[i].getCoeff(orders(NLO)))) - logeta * fatt *
424  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
425  (*(mcbdm[i].getCoeff(orders(LO))))) - app *
426  (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
427  (*(mcbdm[i].getCoeff(orders(NLO)))) +
428  evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
429  (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
430 
431 
432  break;
433 
434  case(LO_ew):
435 
436  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,1)) *
437  evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
438  (*(mcbdm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
439  ( evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
440  (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
441 
442 
443 
444  break;
445  }
446  }
447  }
448  return coeffdmumu.getCoeff();
449 }
450 
451 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffbtaunu()
452 {
453  std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMbtaunu();
454  coeffbtaunu.resetCoefficient();
455  orders ordDF1 = coeffbtaunu.getOrder();
456  for (unsigned int i = 0; i < mcb.size(); i++){
457  for (int j = LO; j <= ordDF1; j++){
458  coeffbtaunu.setCoeff(*coeffbtaunu.getCoeff(orders(j))
459  + *mcb[i].getCoeff(orders(j)), orders(j));
460  }
461  }
462  return coeffbtaunu.getCoeff();
463 }
464 
465 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsnunu()
466 {
467 
468  std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMBXsnn();
469 
470  orders ordDF1 = coeffsnunu.getOrder();
471 
472  for (unsigned int i = 0; i < mcb.size(); i++){
473  for (int j = LO; j <= ordDF1; j++){
474  coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders(j))
475  + *mcb[i].getCoeff(orders(j)), orders(j));
476  }
477  }
478 
479  return coeffsnunu.getCoeff();
480 }
481 
482 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffdnunu()
483 {
484 
485  std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMBXdnn();
486 
487  orders ordDF1 = coeffdnunu.getOrder();
488 
489  for (unsigned int i = 0; i < mcb.size(); i++){
490  for (int j = LO; j <= ordDF1; j++){
491  coeffdnunu.setCoeff(*coeffdnunu.getCoeff(orders(j))
492  + *mcb[i].getCoeff(orders(j)), orders(j));
493  }
494  }
495 
496  return coeffdnunu.getCoeff();
497 }
498 
499 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsgamma(double mu, schemes scheme)
500 {
501 
502  coeffsgamma.setScheme(scheme);
503  orders ordDF1 = coeffsgamma.getOrder();
504 
505  const std::vector<WilsonCoefficient>& mcbsg = model.getMyMatching() -> CMbsg();
506 
507  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
508  int check = 1;
509  for (unsigned int i = 0; i < mcbsg.size(); i++) {
510  if (mcbsg[i].getMu() == Bsgamma_Mu_cache[i]) {
511  for (int j = LO; j <= ordDF1; j++) {
512  for (int k = LO; k <= j; k++) {
513  for (int l = 0; l < 8; l++) {
514  check *= ((*(mcbsg[i].getCoeff(orders(j - k))))(l) == (*(Bsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
515  }
516  }
517  }
518  } else check = 0;
519  }
520  if (check == 1) return coeffsgamma.getCoeff();
521  }
522 
523  Bsgamma_mu_cache = mu;
524  Bsgamma_scheme_cache = scheme;
525  Bsgamma_WC_cache.clear();
526  Bsgamma_WC_cache = mcbsg;
527 
528  coeffsgamma.setMu(mu);
529 
530  for (unsigned int i = 0; i < mcbsg.size(); i++){
531  Bsgamma_Mu_cache[i] = mcbsg[i].getMu();
532  for (int j = LO; j <= ordDF1; j++){
533  for (int k = LO; k <= j; k++){
534  coeffsgamma.setCoeff(*coeffsgamma.getCoeff(orders(j)) +
535  evolDB1bsg.Df1Evolbsg(mu, mcbsg[i].getMu(), orders(k), mcbsg[i].getScheme()) *
536  (*(mcbsg[i].getCoeff(orders(j - k)))), orders(j));
537  }
538  }
539  }
540 
541  return coeffsgamma.getCoeff();
542 }
543 
544 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffprimesgamma(double mu, schemes scheme)
545 {
546 
547  coeffprimesgamma.setScheme(scheme);
548  orders ordDF1 = coeffprimesgamma.getOrder();
549 
550  const std::vector<WilsonCoefficient>& mcbsgp = model.getMyMatching() -> CMprimebsg();
551 
552  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
553  int check = 1;
554  for (unsigned int i = 0; i < mcbsgp.size(); i++) {
555  if (mcbsgp[i].getMu() == Bpsgamma_Mu_cache[i]) {
556  for (int j = LO; j <= ordDF1; j++) {
557  for (int k = LO; k <= j; k++) {
558  for (int l = 0; l < 8; l++) {
559  check *= ((*(mcbsgp[i].getCoeff(orders(j - k))))(l) == (*(Bpsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
560  }
561  }
562  }
563  } else check = 0;
564  }
565  if (check == 1) return coeffprimesgamma.getCoeff();
566  }
567 
568  Bsgamma_mu_cache = mu;
569  Bsgamma_scheme_cache = scheme;
570  Bpsgamma_WC_cache.clear();
571  Bpsgamma_WC_cache = mcbsgp;
572 
573  coeffprimesgamma.setMu(mu);
574 
575  for (unsigned int i = 0; i < mcbsgp.size(); i++){
576  Bpsgamma_Mu_cache[i] = mcbsgp[i].getMu();
577  for (int j = LO; j <= ordDF1; j++){
578  for (int k = LO; k <= j; k++){
579  coeffprimesgamma.setCoeff(*coeffprimesgamma.getCoeff(orders(j)) +
580  evolDB1bsg.Df1Evolbsg(mu, mcbsgp[i].getMu(), orders(k), mcbsgp[i].getScheme()) *
581  (*(mcbsgp[i].getCoeff(orders(j - k)))), orders(j));
582  }
583  }
584  }
585 
586  return coeffprimesgamma.getCoeff();
587 }
588 
589 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBMll(double mu, schemes scheme)
590 {
591 
592  coeffBMll.setScheme(scheme);
593  orders ordDF1 = coeffBMll.getOrder();
594 
595  const std::vector<WilsonCoefficient>& mc = model.getMyMatching() -> CMBMll();
596 
597  if (mu == BMll_mu_cache && scheme == BMll_scheme_cache) {
598  int check = 1;
599  for (unsigned int i = 0; i < mc.size(); i++) {
600  if (mc[i].getMu() == BMll_Mu_cache[i]){
601  for (int j = LO; j <= ordDF1; j++) {
602  for (int k = LO; k <= j; k++) {
603  for (int l = 0; l < 13; l++) {
604  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMll_WC_cache[i].getCoeff(orders(j - k))))(l));
605  }
606  }
607  }
608  } else check = 0;
609  }
610  if (check == 1) return coeffBMll.getCoeff();
611  }
612 
613  BMll_mu_cache = mu;
614  BMll_scheme_cache = scheme;
615  BMll_WC_cache.clear();
616  BMll_WC_cache = mc;
617 
618  coeffBMll.setMu(mu);
619 
620  for (unsigned int i = 0; i < mc.size(); i++){
621  BMll_Mu_cache[i] = mc[i].getMu();
622  for (int j = LO; j <= ordDF1; j++){
623  for (int k = LO; k <= j; k++){
624  coeffBMll.setCoeff(*coeffBMll.getCoeff(orders(j)) +
625  evolDF1BMll.Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
626  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
627  }
628  }
629  }
630 
631  return coeffBMll.getCoeff();
632 }
633 
634 
635 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffprimeBMll(double mu, schemes scheme)
636 {
637 
638  coeffprimeBMll.setScheme(scheme);
639  orders ordDF1 = coeffprimeBMll.getOrder();
640 
641  const std::vector<WilsonCoefficient>& mc = model.getMyMatching() -> CMprimeBMll();
642 
643  if (mu == BMllprime_mu_cache && scheme == BMllprime_scheme_cache) {
644  int check = 1;
645  for (unsigned int i = 0; i < mc.size(); i++) {
646  if (mc[i].getMu() == BMllprime_Mu_cache[i]) {
647  for (int j = LO; j <= ordDF1; j++) {
648  for (int k = LO; k <= j; k++) {
649  for (int l = 0; l < 13; l++) {
650  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMllprime_WC_cache[i].getCoeff(orders(j - k))))(l));
651  }
652  }
653  }
654  } else check = 0;
655  }
656  if (check == 1) return coeffprimeBMll.getCoeff();
657  }
658 
659  BMllprime_mu_cache = mu;
660  BMllprime_scheme_cache = scheme;
661  BMllprime_WC_cache.clear();
662  BMllprime_WC_cache = mc;
663 
664  coeffprimeBMll.setMu(mu);
665 
666  for (unsigned int i = 0; i < mc.size(); i++){
667  BMllprime_Mu_cache[i] = mc[i].getMu();
668  for (int j = LO; j <= ordDF1; j++){
669  for (int k = LO; k <= j; k++){
670  coeffprimeBMll.setCoeff(*coeffprimeBMll.getCoeff(orders(j)) +
671  evolDF1BMll.Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
672  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
673  }
674  }
675  }
676 
677 
678  return coeffprimeBMll.getCoeff();
679 }
HeffDB1::ComputeCoeffdmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffdmumu(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:262
HeffDB1::ComputeCoeffBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffBMll(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:589
EvolDB1Mll::Df1EvolMll
gslpp::matrix< double > & Df1EvolMll(double mu, double M, orders order, schemes scheme=NDR)
a method returning the evolutor related to the high scale and the low scale
Definition: EvolDB1Mll.cpp:343
HeffDB1::coeffprimesgamma
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:207
WilsonTemplate::setMu
virtual void setMu(double mu)
Definition: WilsonTemplate.h:97
HeffDB1::coeffdnunu
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:206
HeffDB1.h
HeffDB1::BMll_scheme_cache
schemes BMll_scheme_cache
Definition: HeffDB1.h:223
NULL_ew
Definition: OrderScheme.h:47
HeffDB1::Bpsgamma_Mu_cache
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:218
NLO_ew
Definition: OrderScheme.h:49
NLO_ewt2
Definition: OrderScheme.h:51
HeffDB1::model
const StandardModel & model
Definition: HeffDB1.h:198
HeffDB1::evolDB1bsg
EvolDB1bsg evolDB1bsg
Definition: HeffDB1.h:210
QCD::Beta1
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
LO_ew
Definition: OrderScheme.h:48
StandardModel::getMyMatching
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
Definition: StandardModel.h:920
WilsonTemplate::resetCoefficient
virtual void resetCoefficient()
Definition: WilsonTemplate.h:85
HeffDB1::Bdmumu_WC_cache
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:240
EvolDB1bsg::Df1Evolbsg
gslpp::matrix< double > & Df1Evolbsg(double mu, double M, orders order, schemes scheme=NDR)
a method returning the evolutor related to the high scale and the low scale
Definition: EvolDB1bsg.cpp:285
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
HeffDB1::coeffsgamma
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:207
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
HeffDB1::BMllprime_scheme_cache
schemes BMllprime_scheme_cache
Definition: HeffDB1.h:228
HeffDB1::BMll_WC_cache
std::vector< WilsonCoefficient > BMll_WC_cache
Definition: HeffDB1.h:225
HeffDB1::Bsmumu_WC_cache
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:235
HeffDB1::Bsmumu_mu_cache
double Bsmumu_mu_cache
Definition: HeffDB1.h:232
NLO_ewt4
Definition: OrderScheme.h:53
HeffDB1::Bsmumu_scheme_cache
schemes Bsmumu_scheme_cache
Definition: HeffDB1.h:233
HeffDB1::Bdmumu_mu_cache
double Bdmumu_mu_cache
Definition: HeffDB1.h:237
WilsonCoefficient::getCoeff
gslpp::vector< gslpp::complex > ** getCoeff() const
Definition: WilsonCoefficient.h:35
HeffDB1::Bsgamma_Mu_cache
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:217
HeffDB1::~HeffDB1
virtual ~HeffDB1()
destructor
Definition: HeffDB1.cpp:67
NLO
Definition: OrderScheme.h:34
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:443
HeffDB1::BMllprime_mu_cache
double BMllprime_mu_cache
Definition: HeffDB1.h:227
WilsonCoefficient::setCoeff
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: WilsonCoefficient.h:40
schemes
schemes
An enum type for regularization schemes.
Definition: OrderScheme.h:19
HeffDB1::coeffBMll
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:208
HeffDB1::BMllprime_Mu_cache
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:229
HeffDB1::ComputeCoeffsmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumu(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:71
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
WilsonTemplate::setScheme
void setScheme(schemes scheme)
Definition: WilsonTemplate.h:108
NNLO
Definition: OrderScheme.h:35
HeffDB1::coeffprimeBMll
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:208
HeffDB1::ComputeCoeffbtaunu
gslpp::vector< gslpp::complex > ** ComputeCoeffbtaunu()
Definition: HeffDB1.cpp:451
HeffDB1::Bdmumu_Mu_cache
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:239
HeffDB1::BMllprime_WC_cache
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:230
NLO_ewt3
Definition: OrderScheme.h:52
LO
Definition: OrderScheme.h:33
HeffDB1::BMll_mu_cache
double BMll_mu_cache
Definition: HeffDB1.h:222
NLO_ewt1
Definition: OrderScheme.h:50
HeffDB1::evolDF1BMll
EvolDB1Mll evolDF1BMll
Definition: HeffDB1.h:209
HeffDB1::Bsmumu_Mu_cache
std::vector< double > Bsmumu_Mu_cache
Definition: HeffDB1.h:234
HeffDB1::BMll_Mu_cache
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:224
HeffDB1::coeffbtaunu
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:205
HeffDB1::coeffsmumu
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:204
HeffDB1::Bdmumu_scheme_cache
schemes Bdmumu_scheme_cache
Definition: HeffDB1.h:238
HeffDB1::HeffDB1
HeffDB1(const StandardModel &SM)
constructor
Definition: HeffDB1.cpp:11
HeffDB1::Bsgamma_scheme_cache
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:216
HeffDB1::ComputeCoeffprimesgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffprimesgamma(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:544
HeffDB1::evolbd
EvolBsmm evolbd
Definition: HeffDB1.h:211
HeffDB1::ComputeCoeffdnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffdnunu()
Definition: HeffDB1.cpp:482
HeffDB1::Bsgamma_WC_cache
std::vector< WilsonCoefficient > Bsgamma_WC_cache
Definition: HeffDB1.h:219
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
gslpp_complex.h
WilsonTemplate::getOrder
orders getOrder() const
Definition: WilsonTemplate.h:70
HeffDB1::evolbs
EvolBsmm evolbs
Definition: HeffDB1.h:211
HeffDB1::ComputeCoeffsgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:499
EvolBsmm::Df1Evol
gslpp::matrix< double > & Df1Evol(double mu, double M, orders order, orders_ew order_ew, schemes scheme=NDR)
Definition: EvolBsmm.cpp:678
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
EvolBsmm::alphatilde_s
double alphatilde_s(double mu)
Definition: EvolBsmm.cpp:1160
HeffDB1::ComputeCoeffprimeBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffprimeBMll(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:635
HeffDB1::coeffdmumu
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:204
HeffDB1::ComputeCoeffsnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffsnunu()
Definition: HeffDB1.cpp:465
HeffDB1::coeffsnunu
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:206
NDR
Definition: OrderScheme.h:21
HeffDB1::Bsgamma_mu_cache
double Bsgamma_mu_cache
Definition: HeffDB1.h:215
HeffDB1::Bpsgamma_WC_cache
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:220