a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HeffDB1.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 HEPfit Collaboration
3  *
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "HeffDB1.h"
9 #include "gslpp_complex.h"
10 #include "StandardModel.h"
11 #include "EvolDF1nlep.h"
12 #include "EvolDB1Mll.h"
13 #include "EvolDB1bsg.h"
14 #include "EvolBsmm.h"
15 
16 HeffDB1::HeffDB1(const StandardModel & SM)
17 : model(SM),
18  coeffnlep00qcd (10, NDR, NLO, NLO_QED11), coeffnlep00 (12, NDR, NLO, NLO_QED11),
19  coeffnlep10qcd (10, NDR, NLO, NLO_QED11), coeffnlep10 (12, NDR, NLO, NLO_QED11),
20  coeffnlep01 (10, NDR, NLO), coeffnlep01A(10, NDR, NLO), coeffnlep01B(4, NDR, NLO), coeffnlep00CC(10, NDR, NLO),
21  coeffnlep11 (10, NDR, NLO), coeffnlep11A(10, NDR, NLO), coeffnlep11B(4, NDR, NLO), coeffnlep10CC(10, NDR, NLO),
22  coeffsmumu (8, NDR, NNLO, NLO_QED22), coeffdmumu (8, NDR, NNLO, NLO_QED22),
23  coeffbtaunu (3, NDR, LO),
24  coeffsnunu (1, NDR, NLO), coeffdnunu (1, NDR, NLO),
25  coeffsgamma(8,NDR, NNLO),
26  coeffprimesgamma(8,NDR, NNLO),
27  coeffBMll (13,NDR, NLO),
28  coeffprimeBMll (13, NDR, NLO),
29  evolDF1BMll(new EvolDB1Mll(13, NDR, NLO, SM)),
30  evolDB1bsg(new EvolDB1bsg(8, NDR, NNLO, SM)),
31  u(new EvolDF1nlep(10, NDR, NLO, NLO_QED11, SM)),
32  evolbs(new EvolBsmm(8, NDR, NNLO, NLO_QED22, SM)), evolbd(new EvolBsmm(8, NDR, NNLO, NLO_QED22, SM)),
33  nlep (12, 0.), nlep2(10, 0.),
34  nlepCC(4, 0.)
35 {
36 
37  for (unsigned int i = 0; i < 6; i++) {
38  BMll_WC_cache.push_back(coeffBMll);
39  BMll_Mu_cache.push_back(0.);
40  }
41  BMll_mu_cache = 0.;
42  BMll_order_ini_cache = 0;
43 
44  for (unsigned int i = 0; i < 6; i++) {
45  BMllprime_WC_cache.push_back(coeffprimeBMll);
46  BMllprime_Mu_cache.push_back(0.);
47  }
48  BMllprime_mu_cache = 0.;
49 
50  for (unsigned int i = 0; i < 6; i++) {
51  Bsgamma_WC_cache.push_back(coeffsgamma);
52  Bsgamma_Mu_cache.push_back(0.);
53  }
54  Bsgamma_mu_cache = 0.;
55  Bsgamma_order_ini_cache = 0;
56 
57  for (unsigned int i = 0; i < 6; i++) {
58  Bpsgamma_WC_cache.push_back(coeffsgamma);
59  Bpsgamma_Mu_cache.push_back(0.);
60  }
61 
62  for (unsigned int i = 0; i < 6; i++) {
63  Bsmumu_WC_cache.push_back(coeffsmumu);
64  Bsmumu_Mu_cache.push_back(0.);
65  }
66  Bsmumu_mu_cache = 0.;
67 
68  for (unsigned int i = 0; i < 6; i++) {
69  Bdmumu_WC_cache.push_back(coeffdmumu);
70  Bdmumu_Mu_cache.push_back(0.);
71  }
72  Bdmumu_mu_cache = 0.;
73 }
74 
75 HeffDB1::~HeffDB1()
76 {}
77 
78 /*******************************************************************************
79  * evolution Wilson Coefficients b-> nonlep. *
80  * Buras base *
81  * deltaB=1 deltaC=0 deltaS=0 *
82  ******************************************************************************/
83 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep00(double mu, schemes scheme)
84 {
85 
86  std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbnlep( 0);
87  std::vector<WilsonCoefficient>& mcbCC = model.getMatching().CMbnlepCC( 0);
88 
89  coeffnlep00qcd.setMu(mu); //inizializes to zero the coefficients
90  coeffnlep00CC.setMu(mu);
91  coeffnlep00.setMu(mu);
92 
93  orders_qed ordDF1ew = coeffnlep00.getOrder_qed();
94  orders ordDF1 = coeffnlep00.getOrder();
95 
96  for (unsigned int i = 0; i < mcb.size(); i++){
97  for (int j = LO; j <= ordDF1; j++){
98  for (int k = LO; k <= j; k++) {
99 
100  //Evolves the LO terms and the ones proportional to alpha_s
101  coeffnlep00qcd.setCoeff(*coeffnlep00qcd.getCoeff(orders(j)) +
102  u->Df1Evolnlep(mu, mcb[i].getMu(), orders(k), NO_QED, mcb[i].getScheme())*
103  (*(mcb[i].getCoeff(orders(j - k)))), orders(j));
104 
105 
106  //Evolves terms proportional to alpha_e and alpha_e/aplha_s
107  coeffnlep00qcd.setCoeff(*coeffnlep00qcd.getCoeff(orders_qed(j+4)) +
108  u->Df1Evolnlep(mu, mcb[i].getMu(), NNLO, orders_qed(k+4), mcb[i].getScheme()) *
109  (*(mcb[i].getCoeff(orders(j - k)))), orders_qed(j+4));
110 
111 
112  //Evolves the current*current part of the hamiltonian (the one non-proportional to lambda_t)
113  coeffnlep00CC.setCoeff(*coeffnlep00CC.getCoeff(orders(j)) +
114  u->Df1Evolnlep(mu, mcbCC[i].getMu(), orders(k), NO_QED, mcbCC[i].getScheme()) *
115  (*(mcbCC[i].getCoeff(orders(j - k)))), orders(j));
116 
117  }
118  }
119 
120  coeffnlep00qcd.setCoeff(*coeffnlep00qcd.getCoeff(orders_qed(NLO_QED11)) +
121  u->Df1Evolnlep(mu, mcb[i].getMu(), orders(LO), NO_QED, mcb[i].getScheme()) *
122  (*(mcb[i].getCoeff(orders_qed(NLO_QED11)))), orders_qed(NLO_QED11));
123 
124  }
125 
126  coeffnlep00qcd.setScheme(scheme);
127  coeffnlep00CC.setScheme(scheme);
128 
129  //Puts all together in a wilson coefficient object of 12 component:
130  //the first 10 terms are the ones proportional to lambda_t
131  //the last two are the remainder current*current operators
132  for (int j=LO; j <= ordDF1; j++) {
133  nlep2 = *coeffnlep00qcd.getCoeff(orders(j));
134  for (int i = 0; i < 10; i++){
135  nlep.assign(i, nlep2(i));
136  }
137  nlep2 = *coeffnlep00CC.getCoeff(orders(j));
138  for (int i = 10; i < 12; i++){
139  nlep.assign(i, nlep2(i-10));
140  }
141  coeffnlep00.setCoeff(nlep, orders(j));
142  }
143  for (int k=LO_QED; k <= ordDF1ew; k++) {
144  nlep2 = *coeffnlep00qcd.getCoeff(orders_qed(k));
145  for (int l = 0; l < 10; l++){
146  nlep.assign(l, nlep2(l));;
147  }
148  coeffnlep00.setCoeff(nlep, orders_qed(k));
149  }
150 
151  return coeffnlep00.getCoeff();
152 }
153 
154 /*******************************************************************************
155  * evolution Wilson Coefficienys b-> nonlep. *
156  * Buras base *
157  * deltaB=1 deltaC=0 deltaS=1 *
158  ******************************************************************************/
159 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep10(double mu, schemes scheme)
160 {
161 
162  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbnlep( 1);
163  const std::vector<WilsonCoefficient>& mcbCC = model.getMatching().CMbnlepCC( 1);
164 
165  coeffnlep10qcd.setMu(mu);
166  coeffnlep10CC.setMu(mu);
167  coeffnlep10.setMu(mu);
168 
169  orders_qed ordDF1ew = coeffnlep10.getOrder_qed();
170  orders ordDF1 = coeffnlep10.getOrder();
171 
172  for (unsigned int i = 0; i < mcb.size(); i++){
173  for (int j = LO; j <= ordDF1; j++){
174  for (int k = LO; k <= j; k++) {
175 
176  //Evolves the LO terms and the ones proportional to alpha_s
177  coeffnlep10qcd.setCoeff(*coeffnlep10qcd.getCoeff(orders(j)) +
178  u->Df1Evolnlep(mu, mcb[i].getMu(), orders(k), NO_QED, mcb[i].getScheme()) *
179  (*(mcb[i].getCoeff(orders(j - k)))), orders(j));
180 
181  //Evolves terms proportional to alpha_e and alpha_e/aplha_s
182  coeffnlep10qcd.setCoeff(*coeffnlep10qcd.getCoeff(orders_qed(j+4)) +
183  u->Df1Evolnlep(mu, mcb[i].getMu(), NNLO, orders_qed(k+4), mcb[i].getScheme()) *
184  (*(mcb[i].getCoeff(orders(j - k)))), orders_qed(j+4));
185 
186  //Evolves the current*current part of the hamiltonian (the one non-proportional to lambda_t)
187  coeffnlep10CC.setCoeff(*coeffnlep10CC.getCoeff(orders(j)) +
188  u->Df1Evolnlep(mu, mcbCC[i].getMu(), orders(k), NO_QED, mcbCC[i].getScheme()) *
189  (*(mcbCC[i].getCoeff(orders(j - k)))), orders(j));
190 
191  }
192  }
193 
194  coeffnlep10qcd.setCoeff(*coeffnlep10qcd.getCoeff(orders_qed(NLO_QED11)) +
195  u->Df1Evolnlep(mu, mcb[i].getMu(), orders(LO), NO_QED, mcb[i].getScheme()) *
196  (*(mcb[i].getCoeff(orders(LO_QED)))), orders_qed(NLO_QED11));
197  }
198 
199  coeffnlep10qcd.setScheme(scheme);
200  coeffnlep10CC.setScheme(scheme);
201 
202  //Puts all together in a wilson coefficient object of 12 component:
203  //the first 10 terms are the one proportional to lambda_t
204  //the last two are the remainder current*current operators
205 
206  for (int j=LO; j <= ordDF1; j++) {
207  nlep2 = *coeffnlep10qcd.getCoeff(orders(j));
208  for (int i = 0; i < 10; i++){
209  nlep.assign(i, nlep2(i));
210  }
211  nlep2 = *coeffnlep10CC.getCoeff(orders(j));
212  for (int i = 10; i < 12; i++){
213  nlep.assign(i, nlep2(i-10));
214  }
215  coeffnlep10.setCoeff(nlep, orders(j));
216  }
217  for (int k=LO_QED; k <= ordDF1ew; k++) {
218  nlep2 = *coeffnlep10qcd.getCoeff(orders_qed(k));
219  for (int l = 0; l < 10; l++){
220  nlep.assign(l, nlep2(l));;
221  }
222  coeffnlep10.setCoeff(nlep, orders_qed(k));
223  }
224 
225  return coeffnlep10.getCoeff();
226 }
227 
228 /*******************************************************************************
229  * evolution Wilson Coefficienys b-> nonlep. *
230  * Buras base *
231  * deltaB=1 deltaC=1 deltaS=0 *
232  ******************************************************************************/
233 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep01(double mu, schemes scheme)
234 {
235 
236  const std::vector<WilsonCoefficient>& mcbCC1 =model.getMatching().CMbnlepCC( 2);
237  const std::vector<WilsonCoefficient>& mcbCC2 = model.getMatching().CMbnlepCC( 3);
238 
239  coeffnlep01.setMu(mu);
240  coeffnlep01A.setMu(mu);
241  coeffnlep01B.setMu(mu);
242 
243  orders ordDF1 = coeffnlep01A.getOrder();
244 
245  //evolution of the current*current terms
246  for (unsigned int i = 0; i < mcbCC1.size(); i++)
247  for (int j = LO; j <= ordDF1; j++)
248  for (int k = LO; k <= j; k++){
249 
250  coeffnlep01A.setCoeff(*coeffnlep01A.getCoeff(orders(j)) +
251  u->Df1Evolnlep(mu, mcbCC1[i].getMu(), orders(k), NO_QED, mcbCC1[i].getScheme()) *
252  (*(mcbCC1[i].getCoeff(orders(j - k)))), orders(j));
253 
254  coeffnlep01B.setCoeff(*coeffnlep01B.getCoeff(orders(j)) +
255  u->Df1Evolnlep(mu, mcbCC2[i].getMu(), orders(k), NO_QED, mcbCC2[i].getScheme()) *
256  (*(mcbCC2[i].getCoeff(orders(j - k)))), orders(j));
257  }
258 
259  coeffnlep01A.setScheme(scheme);
260  coeffnlep01B.setScheme(scheme);
261  coeffnlep01.setScheme(scheme);
262 
263  //Puts all together in a wilson coefficient object of 4 components
264  for (int j=LO; j <= ordDF1; j++) {
265  nlep2 = *coeffnlep01A.getCoeff(orders(j));
266  for (int i = 0; i < 2; i++){
267  nlep.assign(i, nlep2(i));
268  }
269  nlep2 = *coeffnlep01A.getCoeff(orders(j));
270  for (int i = 2; i < 4; i++){
271  nlep.assign(i, nlep2(i-2));
272  }
273  coeffnlep01.setCoeff(nlep, orders(j));
274  }
275  return coeffnlep01.getCoeff();
276 
277 }
278 
279 /*******************************************************************************
280  * evolution Wilson Coefficienys b-> nonlep. *
281  * Buras base *
282  * deltaB=1 deltaC=1 deltaS=1 *
283  ******************************************************************************/
284 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep11(double mu, schemes scheme)
285 {
286 
287  const std::vector<WilsonCoefficient>& mcbCC1 = model.getMatching().CMbnlepCC( 2);
288  const std::vector<WilsonCoefficient>& mcbCC2 = model.getMatching().CMbnlepCC( 3);
289 
290  coeffnlep11.setMu(mu);
291  coeffnlep11A.setMu(mu);
292  coeffnlep11B.setMu(mu);
293 
294  orders ordDF1 = coeffnlep11A.getOrder();
295 
296  for (unsigned int i = 0; i < mcbCC1.size(); i++)
297  for (int j = LO; j <= ordDF1; j++)
298  for (int k = LO; k <= j; k++){
299 
300  coeffnlep11A.setCoeff(*coeffnlep11A.getCoeff(orders(j)) +
301  u->Df1Evolnlep(mu, mcbCC1[i].getMu(), orders(k), NO_QED, mcbCC1[i].getScheme()) *
302  (*(mcbCC1[i].getCoeff(orders(j - k)))), orders(j));
303 
304  coeffnlep11B.setCoeff(*coeffnlep11B.getCoeff(orders(j)) +
305  u->Df1Evolnlep(mu, mcbCC2[i].getMu(), orders(k), NO_QED, mcbCC2[i].getScheme()) *
306  (*(mcbCC2[i].getCoeff(orders(j - k)))), orders(j));
307  }
308 
309  coeffnlep11A.setScheme(scheme);
310  coeffnlep11B.setScheme(scheme);
311  coeffnlep11.setScheme(scheme);
312 
313  for (int j=LO; j <= ordDF1; j++) {
314  nlep2 = *coeffnlep11A.getCoeff(orders(j));
315  for (int i = 0; i < 2; i++){
316  nlep.assign(i, nlep2(i));
317  }
318  nlep2 = *coeffnlep11A.getCoeff(orders(j));
319  for (int i = 2; i < 4; i++){
320  nlep.assign(i, nlep2(i-2));
321  }
322  coeffnlep11.setCoeff(nlep, orders(j));
323  }
324  return coeffnlep11.getCoeff();
325 
326 }
327 
328 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsmumu(double mu, schemes scheme)
329 {
330 
331 
332  coeffsmumu.setScheme(scheme);
333  orders ordDF1 = coeffsmumu.getOrder();
334  orders_qed ordDF1ew = coeffsmumu.getOrder_qed();
335 
336  const std::vector<WilsonCoefficient>& mcbsm = model.getMatching().CMbsmm();
337 
338  if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
339  int check = 1;
340  for (unsigned int i = 0; i < mcbsm.size(); i++) {
341  if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
342  for (int j = LO; j <= ordDF1; j++) {
343  for (int k = LO; k <= j; k++) {
344  for (int l = 0; l < 8; l++) {
345  check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
346  }
347  }
348  }
349  } else check = 0;
350  }
351  if (check == 1) return coeffsmumu.getCoeff();
352  }
353 
354  double nf = 5; //al the process has nf = 5, also the evolutor
355 
356  //int L = 6 - (int) nf;
357  int j = 0;
358  double alsM = evolbs->alphatilde_s(mcbsm[0].getMu());
359  double alsmu = evolbs->alphatilde_s(mu);
360  double eta = alsM / alsmu;
361 
362  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
363 
364  double B00E = 80./9., B01E = 176./9.;
365 
366  double logeta = log(eta);
367  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
368  double app = B00E * (1. - eta)/ B00S;
369 
370  Bsmumu_mu_cache = mu;
371  Bsmumu_scheme_cache = scheme;
372  Bsmumu_WC_cache.clear();
373  Bsmumu_WC_cache = mcbsm;
374 
375  coeffsmumu.setMu(mu);
376 
377  for (unsigned int i = 0; i < mcbsm.size(); i++){
378  Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
379  for (j = LO; j <= ordDF1; j++){
380  for (int k = LO; k <= j; k++){
381  if ((k <= NNLO) && (j <= NNLO)){
382  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
383  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(k), NO_QED, mcbsm[i].getScheme()) *
384  (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
385  }
386  }
387  }
388 
389  for (j = LO_QED; j <= ordDF1ew; j++){
390 
391  switch(j) {
392 
393  case(NLO_QED22):
394 
395  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
396  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
397  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED22)))) +
398  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
399  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
400  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
401  (*(mcbsm[i].getCoeff(orders(LO)))) +
402  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
403  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
404  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
405  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
406  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
407  (*(mcbsm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
408  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
409  (*(mcbsm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
410  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
411  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
412  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
413  (*(mcbsm[i].getCoeff(orders(LO)))) +
414  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
415  (*(mcbsm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
416  * app *
417  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
418  (*(mcbsm[i].getCoeff(orders(NLO)))) +
419  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
420  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
421 
422  break;
423 
424  case(NLO_QED12):
425 
426  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ eta) *
427  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
428  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
429  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
430  (*(mcbsm[i].getCoeff(orders(NLO)))) +
431  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
432  (*(mcbsm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
433  * app *
434  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
435  (*(mcbsm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
436  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
437  (*(mcbsm[i].getCoeff(orders(NLO)))) +
438  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
439  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
440 
441  break;
442 
443  case(NLO_QED21):
444 
445  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + eta *
446  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
447  (*(mcbsm[i].getCoeff(orders_qed(j)))) +
448  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
449  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
450  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
451  (*(mcbsm[i].getCoeff(orders(NLO)))) +
452  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
453  (*(mcbsm[i].getCoeff(orders(LO)))) +
454  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
455  (*(mcbsm[i].getCoeff(orders(NNLO)))))-
456  eta * logeta * fatt *
457  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
458  (*(mcbsm[i].getCoeff(orders(NLO)))) +
459  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
460  (*(mcbsm[i].getCoeff(orders(LO)))))
461  - eta * app *
462  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
463  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
464  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NNLO), NO_QED, mcbsm[i].getScheme()) *
465  (*(mcbsm[i].getCoeff(orders(LO)))) +
466  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
467  (*(mcbsm[i].getCoeff(orders(NLO)))) ), orders_qed(j));
468 
469  break;
470 
471  case(NLO_QED02):
472 
473  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,2)) *
474  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
475  (*(mcbsm[i].getCoeff(orders(LO)))) + ( app
476  * app/( eta * eta ) ) *
477  evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
478  (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
479 
480  break;
481 
482  case(NLO_QED11):
483 
484  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
485  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
486  (*(mcbsm[i].getCoeff(orders(LO)))) +
487  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
488  (*(mcbsm[i].getCoeff(orders_qed(j)))) +
489  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
490  (*(mcbsm[i].getCoeff(orders(NLO)))) - logeta * fatt *
491  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
492  (*(mcbsm[i].getCoeff(orders(LO))))) - app *
493  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
494  (*(mcbsm[i].getCoeff(orders(NLO)))) +
495  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
496  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
497 
498 
499  break;
500 
501  case(LO_QED):
502 
503  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,1)) *
504  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
505  (*(mcbsm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
506  ( evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
507  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
508 
509 
510 
511  break;
512  }
513  }
514  }
515  return coeffsmumu.getCoeff();
516 }
517 
518 
519 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsmumuStandardNorm(double mu, schemes scheme)
520 {
521  coeffsmumu.setScheme(scheme);
522  orders ordDF1 = coeffsmumu.getOrder();
523  orders_qed ordDF1ew = coeffsmumu.getOrder_qed();
524  const std::vector<WilsonCoefficient>& mcbsm = model.getMatching().CMbsmm();
525 
526  if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
527  int check = 1;
528  for (unsigned int i = 0; i < mcbsm.size(); i++) {
529  if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
530  for (int j = LO; j <= ordDF1; j++) {
531  for (int k = LO; k <= j; k++) {
532  for (int l = 0; l < 8; l++) {
533  check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
534  }
535  }
536  }
537  } else check = 0;
538  }
539  if (check == 1) return coeffsmumu.getCoeff();
540  }
541  double nf = 5; //al the process has nf = 5, also the evolutor
542  //int L = 6 - (int) nf;
543  int j = 0;
544  double alsM = evolbs->alphatilde_s(mcbsm[0].getMu());
545  double alsmu = evolbs->alphatilde_s(mu);
546  double eta = alsM / alsmu;
547 
548  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
549 
550  double B00E = 80./9., B01E = 176./9.;
551 
552  double logeta = log(eta);
553  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
554  double app = B00E * (1. - eta)/ B00S;
555 
556  Bsmumu_mu_cache = mu;
557  Bsmumu_scheme_cache = scheme;
558  Bsmumu_WC_cache.clear();
559  Bsmumu_WC_cache = mcbsm;
560 
561  coeffsmumu.setMu(mu);
562 
563  for (unsigned int i = 0; i < mcbsm.size(); i++){
564  Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
565  for (j = LO; j <= ordDF1; j++){
566  for (int k = LO; k <= j; k++){
567  if ((k <= NNLO) && (j <= NNLO)){
568  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
569  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(k), NO_QED, mcbsm[i].getScheme()) *
570  (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
571  }
572  }
573  }
574 
575  for (j = LO_QED; j <= ordDF1ew; j++){
576 
577  switch(j) {
578 
579  case(NLO_QED22):
580  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
581  evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
582  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED22)))) +
583  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
584  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
585  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED22), mcbsm[i].getScheme()) *
586  (*(mcbsm[i].getCoeff(orders(LO)))) +
587  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
588  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
589  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
590  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
591  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
592  (*(mcbsm[i].getCoeff(orders(NLO)))) +
593  logeta*fatt * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
594  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
595  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
596  (*(mcbsm[i].getCoeff(orders(LO)))) +
597  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
598  (*(mcbsm[i].getCoeff(orders(NLO))))) +
599  app * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
600  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
601  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
602  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
603  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
604  (*(mcbsm[i].getCoeff(orders(NLO)))) +
605  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED21), mcbsm[i].getScheme()) *
606  (*(mcbsm[i].getCoeff(orders(LO)))) +
607  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
608  (*(mcbsm[i].getCoeff(orders(NNLO))))), orders_qed(j));
609  break;
610 
611  case(NLO_QED21):
612  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
613  eta * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
614  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
615  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
616  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
617  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
618  (*(mcbsm[i].getCoeff(orders(NLO)))) +
619  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED21), mcbsm[i].getScheme()) *
620  (*(mcbsm[i].getCoeff(orders(LO)))) +
621  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
622  (*(mcbsm[i].getCoeff(orders(NNLO))))), orders_qed(j));
623  break;
624 
625  case(NLO_QED12):
626  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
627  (1./eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
628  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
629  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
630  (*(mcbsm[i].getCoeff(orders(NLO)))) +
631  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
632  (*(mcbsm[i].getCoeff(orders(LO))))) +
633  (logeta*fatt/eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
634  (*(mcbsm[i].getCoeff(orders(LO))))) +
635  (app/eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
636  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
637  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
638  (*(mcbsm[i].getCoeff(orders(LO)))) +
639  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
640  (*(mcbsm[i].getCoeff(orders(NLO))))), orders_qed(j));
641  break;
642 
643  case(NLO_QED02):
644  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
645  (1./ pow(eta,2)) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
646  (*(mcbsm[i].getCoeff(orders(LO)))) +
647  (app/(eta*eta)) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
648  (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
649  break;
650 
651  case(NLO_QED11):
652  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
653  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
654  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
655  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
656  (*(mcbsm[i].getCoeff(orders(LO)))) +
657  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
658  (*(mcbsm[i].getCoeff(orders(NLO)))), orders_qed(j));
659  break;
660 
661  case(LO_QED):
662  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
663  (1./ eta) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
664  (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
665  break;
666  }
667  }
668  }
669  return coeffsmumu.getCoeff();
670 }
671 
672 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffdmumu(double mu, schemes scheme)
673 {
674 
675  coeffdmumu.setScheme(scheme);
676  orders ordDF1 = coeffdmumu.getOrder();
677  orders_qed ordDF1ew = coeffdmumu.getOrder_qed();
678 
679  const std::vector<WilsonCoefficient>& mcbdm = model.getMatching().CMbdmm();
680 
681  if (mu == Bdmumu_mu_cache && scheme == Bdmumu_scheme_cache) {
682  int check = 1;
683  for (unsigned int i = 0; i < mcbdm.size(); i++) {
684  if (mcbdm[i].getMu() == Bdmumu_Mu_cache[i]) {
685  for (int j = LO; j <= ordDF1; j++) {
686  for (int k = LO; k <= j; k++) {
687  for (int l = 0; l < 8; l++) {
688  check *= ((*(mcbdm[i].getCoeff(orders(j - k))))(l) == (*(Bdmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
689  }
690  }
691  }
692  } else check = 0;
693  }
694  if (check == 1) return coeffdmumu.getCoeff();
695  }
696 
697  double nf = 5; //al the process has nf = 5, also the evolutor
698 
699  //int L = 6 - (int) nf;
700  int j = 0;
701  double alsM = evolbd->alphatilde_s(mcbdm[0].getMu());
702  double alsmu = evolbd->alphatilde_s(mu);
703  double eta = alsM / alsmu;
704 
705  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
706 
707  double B00E = 80./9., B01E = 176./9.;
708 
709  double logeta = log(eta);
710  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
711  double app = B00E * (1. - eta)/ B00S;
712 
713  Bdmumu_mu_cache = mu;
714  Bdmumu_scheme_cache = scheme;
715  Bdmumu_WC_cache.clear();
716  Bdmumu_WC_cache = mcbdm;
717 
718  coeffdmumu.setMu(mu);
719 
720  for (unsigned int i = 0; i < mcbdm.size(); i++){
721  Bdmumu_Mu_cache[i] = mcbdm[i].getMu();
722  for (j = LO; j <= ordDF1; j++){
723  for (int k = LO; k <= j; k++){
724  if ((k <= NNLO) && (j <= NNLO)){
725  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders(j)) + pow(eta,j) *
726  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(k), NO_QED, mcbdm[i].getScheme()) *
727  (*(mcbdm[i].getCoeff(orders(j - k)))), orders(j));
728  }
729  }
730  }
731 
732  for (j = LO_QED; j <= ordDF1ew; j++){
733 
734  switch(j) {
735 
736  case(NLO_QED22):
737 
738  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) +
739  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
740  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED22)))) +
741  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbdm[i].getScheme()) *
742  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
743  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
744  (*(mcbdm[i].getCoeff(orders(LO)))) +
745  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
746  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED21)))) +
747  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbdm[i].getScheme()) *
748  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
749  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbdm[i].getScheme()) *
750  (*(mcbdm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
751  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
752  (*(mcbdm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
753  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
754  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
755  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
756  (*(mcbdm[i].getCoeff(orders(LO)))) +
757  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
758  (*(mcbdm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
759  * app *
760  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
761  (*(mcbdm[i].getCoeff(orders(NLO)))) +
762  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
763  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
764 
765  break;
766 
767  case(NLO_QED12):
768 
769  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ eta) *
770  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
771  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
772  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbdm[i].getScheme()) *
773  (*(mcbdm[i].getCoeff(orders(NLO)))) +
774  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
775  (*(mcbdm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
776  * app *
777  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
778  (*(mcbdm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
779  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
780  (*(mcbdm[i].getCoeff(orders(NLO)))) +
781  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
782  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
783 
784  break;
785 
786  case(NLO_QED21):
787 
788  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + eta *
789  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
790  (*(mcbdm[i].getCoeff(orders_qed(j)))) +
791  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
792  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
793  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbdm[i].getScheme()) *
794  (*(mcbdm[i].getCoeff(orders(NLO)))) +
795  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
796  (*(mcbdm[i].getCoeff(orders(LO)))) +
797  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
798  (*(mcbdm[i].getCoeff(orders(NNLO)))))-
799  eta * logeta * fatt *
800  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
801  (*(mcbdm[i].getCoeff(orders(NLO)))) +
802  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
803  (*(mcbdm[i].getCoeff(orders(LO)))))
804  - eta * app *
805  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
806  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
807  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NNLO), NO_QED, mcbdm[i].getScheme()) *
808  (*(mcbdm[i].getCoeff(orders(LO)))) +
809  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
810  (*(mcbdm[i].getCoeff(orders(NLO)))) ), orders_qed(j));
811 
812  break;
813 
814  case(NLO_QED02):
815 
816  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,2)) *
817  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
818  (*(mcbdm[i].getCoeff(orders(LO)))) + ( app
819  * app/(eta * eta ) ) *
820  evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
821  (*(mcbdm[i].getCoeff(orders(LO)))), orders_qed(j));
822 
823  break;
824 
825  case(NLO_QED11):
826 
827  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) +
828  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
829  (*(mcbdm[i].getCoeff(orders(LO)))) +
830  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
831  (*(mcbdm[i].getCoeff(orders_qed(j)))) +
832  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
833  (*(mcbdm[i].getCoeff(orders(NLO)))) - logeta * fatt *
834  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
835  (*(mcbdm[i].getCoeff(orders(LO))))) - app *
836  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
837  (*(mcbdm[i].getCoeff(orders(NLO)))) +
838  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
839  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
840 
841 
842  break;
843 
844  case(LO_QED):
845 
846  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,1)) *
847  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
848  (*(mcbdm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
849  ( evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
850  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
851 
852 
853 
854  break;
855  }
856  }
857  }
858  return coeffdmumu.getCoeff();
859 }
860 
861 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffbtaunu(QCD::meson meson_i)
862 {
863  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbtaunu(meson_i);
864  coeffbtaunu.resetCoefficient();
865  orders ordDF1 = coeffbtaunu.getOrder();
866  for (unsigned int i = 0; i < mcb.size(); i++){
867  for (int j = LO; j <= ordDF1; j++){
868  coeffbtaunu.setCoeff(*coeffbtaunu.getCoeff(orders(j))
869  + *mcb[i].getCoeff(orders(j)), orders(j));
870  }
871  }
872  return coeffbtaunu.getCoeff();
873 }
874 
875 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsnunu()
876 {
877 
878  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXsnn();
879 
880  orders ordDF1 = coeffsnunu.getOrder();
881 
882  for (unsigned int i = 0; i < mcb.size(); i++){
883  for (int j = LO; j <= ordDF1; j++){
884  coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders(j))
885  + *mcb[i].getCoeff(orders(j)), orders(j));
886  }
887  }
888 
889  return coeffsnunu.getCoeff();
890 }
891 
892 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffdnunu()
893 {
894 
895  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXdnn();
896 
897  orders ordDF1 = coeffdnunu.getOrder();
898 
899  for (unsigned int i = 0; i < mcb.size(); i++){
900  for (int j = LO; j <= ordDF1; j++){
901  coeffdnunu.setCoeff(*coeffdnunu.getCoeff(orders(j))
902  + *mcb[i].getCoeff(orders(j)), orders(j));
903  }
904  }
905 
906  return coeffdnunu.getCoeff();
907 }
908 
909 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffsgamma(double mu, bool noSM, schemes scheme)
910 {
911  coeffsgamma.setScheme(scheme);
912  orders ordDF1 = coeffsgamma.getOrder();
913 
914  unsigned int order_ini;
915  if (noSM) order_ini = 1;
916  else order_ini = 0;
917 
918  const std::vector<WilsonCoefficient>& mcbsg = model.getMatching().CMbsg();
919 
920  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache && order_ini == BMll_order_ini_cache) {
921  int check = 1;
922  for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
923  if (mcbsg[i].getMu() == Bsgamma_Mu_cache[i]) {
924  for (int j = LO; j <= ordDF1; j++) {
925  for (int k = LO; k <= j; k++) {
926  for (int l = 0; l < 8; l++) {
927  check *= ((*(mcbsg[i].getCoeff(orders(j - k))))(l) == (*(Bsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
928  }
929  }
930  }
931  } else check = 0;
932  }
933  if (check == 1) return coeffsgamma.getCoeff();
934  }
935 
936  Bsgamma_mu_cache = mu;
937  Bsgamma_order_ini_cache = order_ini;
938  Bsgamma_scheme_cache = scheme;
939  Bsgamma_WC_cache.clear();
940  Bsgamma_WC_cache = mcbsg;
941 
942  coeffsgamma.setMu(mu);
943 
944  for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
945  Bsgamma_Mu_cache[i] = mcbsg[i].getMu();
946  for (int j = LO; j <= ordDF1; j++) {
947  for (int k = LO; k <= j; k++) {
948  coeffsgamma.setCoeff(*coeffsgamma.getCoeff(orders(j)) +
949  evolDB1bsg->Df1Evolbsg(mu, mcbsg[i].getMu(), orders(k), mcbsg[i].getScheme()) *
950  (*(mcbsg[i].getCoeff(orders(j - k)))), orders(j));
951  }
952  }
953  }
954 
955  return coeffsgamma.getCoeff();
956 }
957 
958 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffprimesgamma(double mu, schemes scheme)
959 {
960 
961  coeffprimesgamma.setScheme(scheme);
962  orders ordDF1 = coeffprimesgamma.getOrder();
963 
964  const std::vector<WilsonCoefficient>& mcbsgp = model.getMatching().CMprimebsg();
965 
966  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
967  int check = 1;
968  for (unsigned int i = 0; i < mcbsgp.size(); i++) {
969  if (mcbsgp[i].getMu() == Bpsgamma_Mu_cache[i]) {
970  for (int j = LO; j <= ordDF1; j++) {
971  for (int k = LO; k <= j; k++) {
972  for (int l = 0; l < 8; l++) {
973  check *= ((*(mcbsgp[i].getCoeff(orders(j - k))))(l) == (*(Bpsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
974  }
975  }
976  }
977  } else check = 0;
978  }
979  if (check == 1) return coeffprimesgamma.getCoeff();
980  }
981 
982  Bsgamma_mu_cache = mu;
983  Bsgamma_scheme_cache = scheme;
984  Bpsgamma_WC_cache.clear();
985  Bpsgamma_WC_cache = mcbsgp;
986 
987  coeffprimesgamma.setMu(mu);
988 
989  for (unsigned int i = 0; i < mcbsgp.size(); i++){
990  Bpsgamma_Mu_cache[i] = mcbsgp[i].getMu();
991  for (int j = LO; j <= ordDF1; j++){
992  for (int k = LO; k <= j; k++){
993  coeffprimesgamma.setCoeff(*coeffprimesgamma.getCoeff(orders(j)) +
994  evolDB1bsg->Df1Evolbsg(mu, mcbsgp[i].getMu(), orders(k), mcbsgp[i].getScheme()) *
995  (*(mcbsgp[i].getCoeff(orders(j - k)))), orders(j));
996  }
997  }
998  }
999 
1000  return coeffprimesgamma.getCoeff();
1001 }
1002 
1003 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBMll(double mu, QCD::lepton lepton, bool noSM, schemes scheme)
1004 {
1005 
1006  coeffBMll.setScheme(scheme);
1007  orders ordDF1 = coeffBMll.getOrder();
1008 
1009  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMBMll(lepton);
1010 
1011  unsigned int order_ini;
1012  if (noSM) order_ini = 1;
1013  else order_ini = 0;
1014 
1015  if (mu == BMll_mu_cache && scheme == BMll_scheme_cache && order_ini == BMll_order_ini_cache) {
1016  int check = 1;
1017  for (unsigned int i = order_ini; i < mc.size(); i++) {
1018  if (mc[i].getMu() == BMll_Mu_cache[i]) {
1019  for (int j = LO; j <= ordDF1; j++) {
1020  for (int k = LO; k <= j; k++) {
1021  for (int l = 0; l < 13; l++) {
1022  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMll_WC_cache[i].getCoeff(orders(j - k))))(l));
1023  }
1024  }
1025  }
1026  } else check = 0;
1027  }
1028  if (check == 1) return coeffBMll.getCoeff();
1029  }
1030 
1031  BMll_mu_cache = mu;
1032  BMll_order_ini_cache = order_ini;
1033  BMll_scheme_cache = scheme;
1034  BMll_WC_cache.clear();
1035  BMll_WC_cache = mc;
1036 
1037  coeffBMll.setMu(mu);
1038 
1039  for (unsigned int i = order_ini; i < mc.size(); i++) {
1040  BMll_Mu_cache[i] = mc[i].getMu();
1041  for (int j = LO; j <= ordDF1; j++) {
1042  for (int k = LO; k <= j; k++) {
1043  coeffBMll.setCoeff(*coeffBMll.getCoeff(orders(j)) +
1044  evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
1045  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
1046  }
1047  }
1048  }
1049 
1050  return coeffBMll.getCoeff();
1051 }
1052 
1053 
1054 gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffprimeBMll(double mu, QCD::lepton lepton, schemes scheme)
1055 {
1056 
1057  coeffprimeBMll.setScheme(scheme);
1058  orders ordDF1 = coeffprimeBMll.getOrder();
1059 
1060  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMprimeBMll(lepton);
1061 
1062  if (mu == BMllprime_mu_cache && scheme == BMllprime_scheme_cache) {
1063  int check = 1;
1064  for (unsigned int i = 0; i < mc.size(); i++) {
1065  if (mc[i].getMu() == BMllprime_Mu_cache[i]) {
1066  for (int j = LO; j <= ordDF1; j++) {
1067  for (int k = LO; k <= j; k++) {
1068  for (int l = 0; l < 13; l++) {
1069  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMllprime_WC_cache[i].getCoeff(orders(j - k))))(l));
1070  }
1071  }
1072  }
1073  } else check = 0;
1074  }
1075  if (check == 1) return coeffprimeBMll.getCoeff();
1076  }
1077 
1078  BMllprime_mu_cache = mu;
1079  BMllprime_scheme_cache = scheme;
1080  BMllprime_WC_cache.clear();
1081  BMllprime_WC_cache = mc;
1082 
1083  coeffprimeBMll.setMu(mu);
1084 
1085  for (unsigned int i = 0; i < mc.size(); i++){
1086  BMllprime_Mu_cache[i] = mc[i].getMu();
1087  for (int j = LO; j <= ordDF1; j++){
1088  for (int k = LO; k <= j; k++){
1089  coeffprimeBMll.setCoeff(*coeffprimeBMll.getCoeff(orders(j)) +
1090  evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
1091  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
1092  }
1093  }
1094  }
1095 
1096 
1097  return coeffprimeBMll.getCoeff();
1098 }
WilsonTemplate::setScheme
void setScheme(schemes scheme)
Definition: WilsonTemplate.h:103
HeffDB1::ComputeCoeffsgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma(double mu, bool noSM=false, schemes scheme=NDR)
Definition: HeffDB1.cpp:905
HeffDB1::u
std::unique_ptr< EvolDF1nlep > u
Definition: HeffDB1.h:224
ModelMatching::CMprimeBMll
virtual std::vector< WilsonCoefficient > & CMprimeBMll(QCD::lepton lepton)=0
EvolDF1nlep.h
NO_QED
Definition: OrderScheme.h:49
HeffDB1::coeffnlep00qcd
WilsonCoefficient coeffnlep00qcd
Definition: HeffDB1.h:213
HeffDB1::ComputeCoeffsmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumu(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:324
NLO_QED11
Definition: OrderScheme.h:51
QCD::Beta1
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:471
HeffDB1::nlep2
gslpp::vector< gslpp::complex > nlep2
Definition: HeffDB1.h:259
HeffDB1::BMll_order_ini_cache
unsigned int BMll_order_ini_cache
Definition: HeffDB1.h:239
HeffDB1::ComputeCoeffdnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffdnunu()
Definition: HeffDB1.cpp:888
HeffDB1::evolDF1BMll
std::unique_ptr< EvolDB1Mll > evolDF1BMll
Definition: HeffDB1.h:222
HeffDB1::coeffBMll
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:221
WilsonTemplate::getOrder_qed
orders_qed getOrder_qed() const
Definition: WilsonTemplate.h:70
LO
Definition: OrderScheme.h:33
HeffDB1::evolDB1bsg
std::unique_ptr< EvolDB1bsg > evolDB1bsg
Definition: HeffDB1.h:223
EvolBsmm.h
HeffDB1::coeffnlep11A
WilsonCoefficient coeffnlep11A
Definition: HeffDB1.h:216
HeffDB1::coeffnlep11B
WilsonCoefficient coeffnlep11B
Definition: HeffDB1.h:216
StandardModel.h
HeffDB1::coeffnlep10
WilsonCoefficient coeffnlep10
Definition: HeffDB1.h:214
HeffDB1::Bpsgamma_WC_cache
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:236
ModelMatching::CMbnlepCC
virtual std::vector< WilsonCoefficient > & CMbnlepCC(const int a)=0
NDR
Definition: OrderScheme.h:21
ModelMatching::CMbsg
virtual std::vector< WilsonCoefficient > & CMbsg()=0
HeffDB1::Bsmumu_Mu_cache
std::vector< double > Bsmumu_Mu_cache
Definition: HeffDB1.h:251
HeffDB1::coeffbtaunu
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:218
HeffDB1::evolbd
std::unique_ptr< EvolBsmm > evolbd
Definition: HeffDB1.h:226
HeffDB1::BMllprime_WC_cache
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:247
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
HeffDB1::coeffdmumu
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:217
HeffDB1::nlep
gslpp::vector< gslpp::complex > nlep
Definition: HeffDB1.h:259
EvolDF1nlep
Evolutor Class
Definition: EvolDF1nlep.h:16
EvolDB1Mll
Definition: EvolDB1Mll.h:14
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:477
HeffDB1::coeffprimesgamma
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:220
HeffDB1::Bdmumu_scheme_cache
schemes Bdmumu_scheme_cache
Definition: HeffDB1.h:255
HeffDB1::coeffsmumu
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:217
HeffDB1::coeffnlep10CC
WilsonCoefficient coeffnlep10CC
Definition: HeffDB1.h:216
HeffDB1::ComputeCoeffBnlep00
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep00(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:82
ModelMatching::CMbnlep
virtual std::vector< WilsonCoefficient > & CMbnlep(const int a)=0
HeffDB1::ComputeCoeffBnlep11
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep11(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:280
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:466
HeffDB1::ComputeCoeffprimesgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffprimesgamma(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:954
WilsonTemplate::getOrder
orders getOrder() const
Definition: WilsonTemplate.h:65
HeffDB1::BMll_scheme_cache
schemes BMll_scheme_cache
Definition: HeffDB1.h:240
HeffDB1::ComputeCoeffbtaunu
gslpp::vector< gslpp::complex > ** ComputeCoeffbtaunu(QCD::meson meson_i)
Definition: HeffDB1.cpp:857
WilsonCoefficient::setCoeff
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: WilsonCoefficient.h:34
HeffDB1::Bsgamma_WC_cache
std::vector< WilsonCoefficient > Bsgamma_WC_cache
Definition: HeffDB1.h:235
schemes
schemes
An enum type for regularization schemes.
Definition: OrderScheme.h:19
HeffDB1::Bsgamma_scheme_cache
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:232
HeffDB1::coeffnlep01
WilsonCoefficient coeffnlep01
Definition: HeffDB1.h:215
ModelMatching::CMBMll
virtual std::vector< WilsonCoefficient > & CMBMll(QCD::lepton lepton)=0
HeffDB1::coeffnlep00CC
WilsonCoefficient coeffnlep00CC
Definition: HeffDB1.h:215
QCD::meson
meson
An enum type for mesons.
Definition: QCD.h:336
EvolBsmm
Definition: EvolBsmm.h:16
HeffDB1::model
const StandardModel & model
Definition: HeffDB1.h:211
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
HeffDB1.h
HeffDB1::ComputeCoeffprimeBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffprimeBMll(double mu, QCD::lepton lepton, schemes scheme=NDR)
Definition: HeffDB1.cpp:1050
HeffDB1::ComputeCoeffBnlep10
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep10(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:157
HeffDB1::ComputeCoeffBnlep01
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep01(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:230
LO_QED
Definition: OrderScheme.h:50
EvolDB1bsg.h
HeffDB1::Bsmumu_scheme_cache
schemes Bsmumu_scheme_cache
Definition: HeffDB1.h:250
HeffDB1::coeffnlep10qcd
WilsonCoefficient coeffnlep10qcd
Definition: HeffDB1.h:214
HeffDB1::Bdmumu_mu_cache
double Bdmumu_mu_cache
Definition: HeffDB1.h:254
HeffDB1::coeffsgamma
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:220
NNLO
Definition: OrderScheme.h:35
HeffDB1::Bsgamma_Mu_cache
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:233
HeffDB1::coeffsnunu
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:219
HeffDB1::BMllprime_scheme_cache
schemes BMllprime_scheme_cache
Definition: HeffDB1.h:245
NLO_QED22
Definition: OrderScheme.h:55
WilsonTemplate::setMu
virtual void setMu(double mu)
Definition: WilsonTemplate.h:92
orders_qed
orders_qed
An enum type for orders in electroweak.
Definition: OrderScheme.h:47
WilsonTemplate::resetCoefficient
virtual void resetCoefficient()
Definition: WilsonTemplate.h:80
HeffDB1::Bsmumu_mu_cache
double Bsmumu_mu_cache
Definition: HeffDB1.h:249
HeffDB1::ComputeCoeffsmumuStandardNorm
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumuStandardNorm(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:515
HeffDB1::BMllprime_Mu_cache
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:246
HeffDB1::ComputeCoeffsnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffsnunu()
Definition: HeffDB1.cpp:871
ModelMatching::CMprimebsg
virtual std::vector< WilsonCoefficient > & CMprimebsg()=0
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
HeffDB1::~HeffDB1
virtual ~HeffDB1()
destructor
Definition: HeffDB1.cpp:75
NLO_QED12
Definition: OrderScheme.h:54
HeffDB1::Bsgamma_mu_cache
double Bsgamma_mu_cache
Definition: HeffDB1.h:230
HeffDB1::BMllprime_mu_cache
double BMllprime_mu_cache
Definition: HeffDB1.h:244
HeffDB1::ComputeCoeffdmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffdmumu(double mu, schemes scheme=NDR)
Definition: HeffDB1.cpp:668
HeffDB1::ComputeCoeffBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffBMll(double mu, QCD::lepton lepton, bool noSM=false, schemes scheme=NDR)
Definition: HeffDB1.cpp:999
HeffDB1::coeffnlep01A
WilsonCoefficient coeffnlep01A
Definition: HeffDB1.h:215
StandardModel::getMatching
virtual StandardModelMatching & getMatching() const
A get method to access the member reference of type StandardModelMatching.
Definition: StandardModel.h:952
HeffDB1::Bdmumu_Mu_cache
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:256
HeffDB1::coeffdnunu
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:219
WilsonCoefficient::getCoeff
gslpp::vector< gslpp::complex > ** getCoeff() const
Definition: WilsonCoefficient.h:29
HeffDB1::Bsgamma_order_ini_cache
unsigned int Bsgamma_order_ini_cache
Definition: HeffDB1.h:231
HeffDB1::coeffnlep01B
WilsonCoefficient coeffnlep01B
Definition: HeffDB1.h:215
HeffDB1::coeffprimeBMll
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:221
HeffDB1::BMll_mu_cache
double BMll_mu_cache
Definition: HeffDB1.h:238
HeffDB1::coeffnlep11
WilsonCoefficient coeffnlep11
Definition: HeffDB1.h:216
gslpp_complex.h
HeffDB1::coeffnlep00
WilsonCoefficient coeffnlep00
Definition: HeffDB1.h:213
HeffDB1::Bpsgamma_Mu_cache
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:234
NLO
Definition: OrderScheme.h:34
NLO_QED21
Definition: OrderScheme.h:52
EvolDB1bsg
Definition: EvolDB1bsg.h:14
NLO_QED02
Definition: OrderScheme.h:53
HeffDB1::BMll_WC_cache
std::vector< WilsonCoefficient > BMll_WC_cache
Definition: HeffDB1.h:242
EvolDB1Mll.h
HeffDB1::Bsmumu_WC_cache
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:252
HeffDB1::evolbs
std::unique_ptr< EvolBsmm > evolbs
Definition: HeffDB1.h:225
HeffDB1::HeffDB1
HeffDB1(const StandardModel &SM)
constructor
Definition: HeffDB1.cpp:16
HeffDB1::Bdmumu_WC_cache
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:257
gslpp::vector< gslpp::complex >
HeffDB1::BMll_Mu_cache
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:241
QCD::lepton
lepton
An enum type for leptons.
Definition: QCD.h:310