HeffDB1 Class Reference

#include <HeffDB1.h>

Collaboration diagram for HeffDB1:
[legend]

Detailed Description

Definition at line 18 of file HeffDB1.h.

Public Member Functions

gslpp::vector< gslpp::complex > ** ComputeCoeffBMll (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep00 (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep01 (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep10 (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffBnlep11 (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffbtaunu ()
 
gslpp::vector< gslpp::complex > ** ComputeCoeffdmumu (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffdnunu ()
 
gslpp::vector< gslpp::complex > ** ComputeCoeffprimeBMll (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffprimesgamma (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumu (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffsnunu ()
 
WilsonCoefficient getCoeffbtaunu () const
 
WilsonCoefficient getCoeffdmumu () const
 
WilsonCoefficient getCoeffdnunu () const
 
WilsonCoefficient getCoeffnlep00 () const
 
WilsonCoefficient getCoeffnlep01 () const
 
WilsonCoefficient getCoeffnlep10 () const
 
WilsonCoefficient getCoeffnlep11 () const
 
WilsonCoefficient getCoeffprimesgamma () const
 
WilsonCoefficient getCoeffsgamma () const
 
WilsonCoefficient getCoeffsmumu () const
 
WilsonCoefficient getCoeffsnunu () const
 
const StandardModelGetModel () const
 
EvolBsmm getUBdmm () const
 
EvolBsmm getUBsmm () const
 
EvolDB1bsg getUDB1bsg () const
 
EvolDB1Mll getUDF1BMll () const
 
 HeffDB1 (const StandardModel &SM)
 constructor More...
 
virtual ~HeffDB1 ()
 destructor More...
 

Private Attributes

double Bdmumu_mu_cache
 
std::vector< double > Bdmumu_Mu_cache
 
schemes Bdmumu_scheme_cache
 
std::vector< WilsonCoefficientBdmumu_WC_cache
 
double BMll_mu_cache
 
std::vector< double > BMll_Mu_cache
 
schemes BMll_scheme_cache
 
std::vector< WilsonCoefficientBMll_WC_cache
 
double BMllprime_mu_cache
 
std::vector< double > BMllprime_Mu_cache
 
schemes BMllprime_scheme_cache
 
std::vector< WilsonCoefficientBMllprime_WC_cache
 
std::vector< double > Bpsgamma_Mu_cache
 
std::vector< WilsonCoefficientBpsgamma_WC_cache
 
double Bsgamma_mu_cache
 
std::vector< double > Bsgamma_Mu_cache
 
schemes Bsgamma_scheme_cache
 
std::vector< WilsonCoefficientBsgamma_WC_cache
 
double Bsmumu_mu_cache
 
std::vector< double > Bsmumu_Mu_cache
 
schemes Bsmumu_scheme_cache
 
std::vector< WilsonCoefficientBsmumu_WC_cache
 
WilsonCoefficient coeffBMll
 
WilsonCoefficient coeffbtaunu
 
WilsonCoefficient coeffdmumu
 
WilsonCoefficient coeffdnunu
 
WilsonCoefficient coeffnlep00
 
WilsonCoefficient coeffnlep00CC
 
WilsonCoefficient coeffnlep00qcd
 
WilsonCoefficient coeffnlep01
 
WilsonCoefficient coeffnlep01A
 
WilsonCoefficient coeffnlep01B
 
WilsonCoefficient coeffnlep10
 
WilsonCoefficient coeffnlep10CC
 
WilsonCoefficient coeffnlep10qcd
 
WilsonCoefficient coeffnlep11
 
WilsonCoefficient coeffnlep11A
 
WilsonCoefficient coeffnlep11B
 
WilsonCoefficient coeffprimeBMll
 
WilsonCoefficient coeffprimesgamma
 
WilsonCoefficient coeffsgamma
 
WilsonCoefficient coeffsmumu
 
WilsonCoefficient coeffsnunu
 
EvolBsmm evolbd
 
EvolBsmm evolbs
 
EvolDB1bsg evolDB1bsg
 
EvolDB1Mll evolDF1BMll
 
const StandardModelmodel
 
gslpp::vector< gslpp::complexnlep
 
gslpp::vector< gslpp::complexnlep2
 
gslpp::vector< gslpp::complexnlepCC
 

Constructor & Destructor Documentation

HeffDB1::HeffDB1 ( const StandardModel SM)

constructor

Parameters
SM
modelmatching

Definition at line 11 of file HeffDB1.cpp.

12 : model(SM),
18  coeffbtaunu (3, NDR, LO),
19  coeffsnunu (1, NDR, NLO), coeffdnunu (1, NDR, NLO),
20  coeffsgamma(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++) {
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 }
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:207
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:206
WilsonCoefficient coeffnlep01B
Definition: HeffDB1.h:202
gslpp::vector< gslpp::complex > nlepCC
Definition: HeffDB1.h:242
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:218
WilsonCoefficient coeffnlep01A
Definition: HeffDB1.h:202
const StandardModel & model
Definition: HeffDB1.h:198
EvolDB1bsg evolDB1bsg
Definition: HeffDB1.h:210
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:240
WilsonCoefficient coeffnlep00
Definition: HeffDB1.h:200
WilsonCoefficient coeffnlep01
Definition: HeffDB1.h:202
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:207
std::vector< WilsonCoefficient > BMll_WC_cache
Definition: HeffDB1.h:225
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:235
double Bsmumu_mu_cache
Definition: HeffDB1.h:232
double Bdmumu_mu_cache
Definition: HeffDB1.h:237
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:217
double BMllprime_mu_cache
Definition: HeffDB1.h:227
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:208
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:229
WilsonCoefficient coeffnlep00qcd
Definition: HeffDB1.h:200
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:208
WilsonCoefficient coeffnlep11B
Definition: HeffDB1.h:203
gslpp::vector< gslpp::complex > nlep2
Definition: HeffDB1.h:242
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:239
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:230
Definition: OrderScheme.h:33
double BMll_mu_cache
Definition: HeffDB1.h:222
WilsonCoefficient coeffnlep11
Definition: HeffDB1.h:203
EvolDB1Mll evolDF1BMll
Definition: HeffDB1.h:209
WilsonCoefficient coeffnlep10CC
Definition: HeffDB1.h:203
std::vector< double > Bsmumu_Mu_cache
Definition: HeffDB1.h:234
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:224
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:205
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:204
EvolBsmm evolbd
Definition: HeffDB1.h:211
std::vector< WilsonCoefficient > Bsgamma_WC_cache
Definition: HeffDB1.h:219
WilsonCoefficient coeffnlep00CC
Definition: HeffDB1.h:202
WilsonCoefficient coeffnlep10qcd
Definition: HeffDB1.h:201
EvolBsmm evolbs
Definition: HeffDB1.h:211
WilsonCoefficient coeffnlep11A
Definition: HeffDB1.h:203
WilsonCoefficient coeffnlep10
Definition: HeffDB1.h:201
gslpp::vector< gslpp::complex > nlep
Definition: HeffDB1.h:242
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:204
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:206
double Bsgamma_mu_cache
Definition: HeffDB1.h:215
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:220
HeffDB1::~HeffDB1 ( )
virtual

destructor

Definition at line 67 of file HeffDB1.cpp.

68 {}

Member Function Documentation

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffBMll ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu B -> K^*ll decay, Misiak basis, Chetyrkin et al hep-ph/9612313

Definition at line 589 of file HeffDB1.cpp.

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++){
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 }
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
virtual void setMu(double mu)
schemes BMll_scheme_cache
Definition: HeffDB1.h:223
const StandardModel & model
Definition: HeffDB1.h:198
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
std::vector< WilsonCoefficient > BMll_WC_cache
Definition: HeffDB1.h:225
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:208
void setScheme(schemes scheme)
Definition: OrderScheme.h:33
double BMll_mu_cache
Definition: HeffDB1.h:222
EvolDB1Mll evolDF1BMll
Definition: HeffDB1.h:209
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:224
orders getOrder() const
gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep00 ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the reonrmalization scheme
Returns
the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 0 | \), \( |\Delta S = 0 | \)
gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep01 ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 0 | \), \( |\Delta S = 1 | \)
gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep10 ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 1 | \), \( |\Delta S = 0 | \)
gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep11 ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 1 | \), \( |\Delta S = 1 | \)
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffbtaunu ( )
Parameters
scheme
Returns
short distance contribution to the rare decay \( B \rightarrow \tau \nu \)

Definition at line 451 of file HeffDB1.cpp.

452 {
453  std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMbtaunu();
455  orders ordDF1 = coeffbtaunu.getOrder();
456  for (unsigned int i = 0; i < mcb.size(); i++){
457  for (int j = LO; j <= ordDF1; j++){
459  + *mcb[i].getCoeff(orders(j)), orders(j));
460  }
461  }
462  return coeffbtaunu.getCoeff();
463 }
const StandardModel & model
Definition: HeffDB1.h:198
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
virtual void resetCoefficient()
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:205
orders getOrder() const
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffdmumu ( double  mu,
schemes  scheme = NDR 
)
Parameters
scheme
Returns
short distance contribution to the rare decay \( B_{d} \rightarrow \mu \bar{\mu} \)

Definition at line 262 of file HeffDB1.cpp.

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)){
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 
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 
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 
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 }
virtual void setMu(double mu)
const StandardModel & model
Definition: HeffDB1.h:198
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:240
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
complex pow(const complex &z1, const complex &z2)
double Bdmumu_mu_cache
Definition: HeffDB1.h:237
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
orders_ew getOrder_ew() const
orders_ew
An enum type for orders in electroweak.
Definition: OrderScheme.h:45
void setScheme(schemes scheme)
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:239
Definition: OrderScheme.h:33
schemes Bdmumu_scheme_cache
Definition: HeffDB1.h:238
EvolBsmm evolbd
Definition: HeffDB1.h:211
complex log(const complex &z)
orders getOrder() const
gslpp::matrix< double > & Df1Evol(double mu, double M, orders order, orders_ew order_ew, schemes scheme=NDR)
Definition: EvolBsmm.cpp:678
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
double alphatilde_s(double mu)
Definition: EvolBsmm.cpp:1160
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:204
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffdnunu ( )
Parameters
scheme
Returns
short distance contribution to the rare decay \( B_{d} \rightarrow \nu \bar{\nu} \)

Definition at line 482 of file HeffDB1.cpp.

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++){
492  + *mcb[i].getCoeff(orders(j)), orders(j));
493  }
494  }
495 
496  return coeffdnunu.getCoeff();
497 }
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:206
const StandardModel & model
Definition: HeffDB1.h:198
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
orders getOrder() const
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffprimeBMll ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu B -> K^*ll decay, Misiak basis, Chetyrkin et al hep-ph/9612313

Definition at line 635 of file HeffDB1.cpp.

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++){
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 }
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
virtual void setMu(double mu)
const StandardModel & model
Definition: HeffDB1.h:198
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
schemes BMllprime_scheme_cache
Definition: HeffDB1.h:228
gslpp::vector< gslpp::complex > ** getCoeff() const
double BMllprime_mu_cache
Definition: HeffDB1.h:227
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:229
void setScheme(schemes scheme)
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:208
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:230
Definition: OrderScheme.h:33
EvolDB1Mll evolDF1BMll
Definition: HeffDB1.h:209
orders getOrder() const
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffprimesgamma ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
short distance contribution to the rare decay \( b \rightarrow s \gamma \)

Definition at line 544 of file HeffDB1.cpp.

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++){
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 }
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:207
virtual void setMu(double mu)
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:218
const StandardModel & model
Definition: HeffDB1.h:198
EvolDB1bsg evolDB1bsg
Definition: HeffDB1.h:210
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
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
An enum type for orders in QCD.
Definition: OrderScheme.h:31
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
void setScheme(schemes scheme)
Definition: OrderScheme.h:33
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:216
orders getOrder() const
double Bsgamma_mu_cache
Definition: HeffDB1.h:215
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:220
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsgamma ( double  mu,
schemes  scheme = NDR 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
short distance contribution to the rare decay \( b \rightarrow s \gamma \)

Definition at line 499 of file HeffDB1.cpp.

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++){
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 }
virtual void setMu(double mu)
const StandardModel & model
Definition: HeffDB1.h:198
EvolDB1bsg evolDB1bsg
Definition: HeffDB1.h:210
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
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
An enum type for orders in QCD.
Definition: OrderScheme.h:31
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:207
gslpp::vector< gslpp::complex > ** getCoeff() const
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:217
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
void setScheme(schemes scheme)
Definition: OrderScheme.h:33
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:216
std::vector< WilsonCoefficient > Bsgamma_WC_cache
Definition: HeffDB1.h:219
orders getOrder() const
double Bsgamma_mu_cache
Definition: HeffDB1.h:215
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsmumu ( double  mu,
schemes  scheme = NDR 
)
Parameters
scheme
Returns
short distance contribution to the rare decay \( B_{s} \rightarrow \mu \bar{\mu} \)

Definition at line 71 of file HeffDB1.cpp.

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)){
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 
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 
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 
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 }
virtual void setMu(double mu)
const StandardModel & model
Definition: HeffDB1.h:198
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
complex pow(const complex &z1, const complex &z2)
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:235
double Bsmumu_mu_cache
Definition: HeffDB1.h:232
schemes Bsmumu_scheme_cache
Definition: HeffDB1.h:233
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
orders_ew getOrder_ew() const
orders_ew
An enum type for orders in electroweak.
Definition: OrderScheme.h:45
void setScheme(schemes scheme)
Definition: OrderScheme.h:33
std::vector< double > Bsmumu_Mu_cache
Definition: HeffDB1.h:234
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:204
complex log(const complex &z)
orders getOrder() const
EvolBsmm evolbs
Definition: HeffDB1.h:211
gslpp::matrix< double > & Df1Evol(double mu, double M, orders order, orders_ew order_ew, schemes scheme=NDR)
Definition: EvolBsmm.cpp:678
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
double alphatilde_s(double mu)
Definition: EvolBsmm.cpp:1160
gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsnunu ( )
Parameters
scheme
Returns
short distance contribution to the rare decay \( B_{s} \rightarrow \nu \bar{\nu} \)

Definition at line 465 of file HeffDB1.cpp.

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++){
475  + *mcb[i].getCoeff(orders(j)), orders(j));
476  }
477  }
478 
479  return coeffsnunu.getCoeff();
480 }
const StandardModel & model
Definition: HeffDB1.h:198
virtual StandardModelMatching * getMyMatching() const
A get method to access the member pointer of type StandardModelMatching.
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
gslpp::vector< gslpp::complex > ** getCoeff() const
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: OrderScheme.h:33
orders getOrder() const
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:206
WilsonCoefficient HeffDB1::getCoeffbtaunu ( ) const
inline

Definition at line 156 of file HeffDB1.h.

156  {
157  return coeffbtaunu;
158  }
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:205
WilsonCoefficient HeffDB1::getCoeffdmumu ( ) const
inline

Definition at line 152 of file HeffDB1.h.

152  {
153  return coeffdmumu;
154  }
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:204
WilsonCoefficient HeffDB1::getCoeffdnunu ( ) const
inline

Definition at line 164 of file HeffDB1.h.

164  {
165  return coeffdnunu;
166  }
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:206
WilsonCoefficient HeffDB1::getCoeffnlep00 ( ) const
inline

Definition at line 132 of file HeffDB1.h.

132  {
133  return coeffnlep00;
134  }
WilsonCoefficient coeffnlep00
Definition: HeffDB1.h:200
WilsonCoefficient HeffDB1::getCoeffnlep01 ( ) const
inline

Definition at line 140 of file HeffDB1.h.

140  {
141  return coeffnlep10;
142  }
WilsonCoefficient coeffnlep10
Definition: HeffDB1.h:201
WilsonCoefficient HeffDB1::getCoeffnlep10 ( ) const
inline

Definition at line 136 of file HeffDB1.h.

136  {
137  return coeffnlep01;
138  }
WilsonCoefficient coeffnlep01
Definition: HeffDB1.h:202
WilsonCoefficient HeffDB1::getCoeffnlep11 ( ) const
inline

Definition at line 144 of file HeffDB1.h.

144  {
145  return coeffnlep11;
146  }
WilsonCoefficient coeffnlep11
Definition: HeffDB1.h:203
WilsonCoefficient HeffDB1::getCoeffprimesgamma ( ) const
inline

Definition at line 172 of file HeffDB1.h.

172  {
173  return coeffprimesgamma;
174  }
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:207
WilsonCoefficient HeffDB1::getCoeffsgamma ( ) const
inline

Definition at line 168 of file HeffDB1.h.

168  {
169  return coeffsgamma;
170  }
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:207
WilsonCoefficient HeffDB1::getCoeffsmumu ( ) const
inline

Definition at line 148 of file HeffDB1.h.

148  {
149  return coeffsmumu;
150  }
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:204
WilsonCoefficient HeffDB1::getCoeffsnunu ( ) const
inline

Definition at line 160 of file HeffDB1.h.

160  {
161  return coeffsnunu;
162  }
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:206
const StandardModel& HeffDB1::GetModel ( ) const
inline

Definition at line 193 of file HeffDB1.h.

193  {
194  return model;
195  }
const StandardModel & model
Definition: HeffDB1.h:198
EvolBsmm HeffDB1::getUBdmm ( ) const
inline

Definition at line 180 of file HeffDB1.h.

180  {
181  return evolbd;
182  }
EvolBsmm evolbd
Definition: HeffDB1.h:211
EvolBsmm HeffDB1::getUBsmm ( ) const
inline

Definition at line 176 of file HeffDB1.h.

176  {
177  return evolbs;
178  }
EvolBsmm evolbs
Definition: HeffDB1.h:211
EvolDB1bsg HeffDB1::getUDB1bsg ( ) const
inline

Definition at line 189 of file HeffDB1.h.

189  {
190  return evolDB1bsg;
191  }
EvolDB1bsg evolDB1bsg
Definition: HeffDB1.h:210
EvolDB1Mll HeffDB1::getUDF1BMll ( ) const
inline

Definition at line 185 of file HeffDB1.h.

185  {
186  return evolDF1BMll;
187  }
EvolDB1Mll evolDF1BMll
Definition: HeffDB1.h:209

Member Data Documentation

double HeffDB1::Bdmumu_mu_cache
private

Definition at line 237 of file HeffDB1.h.

std::vector<double> HeffDB1::Bdmumu_Mu_cache
private

Definition at line 239 of file HeffDB1.h.

schemes HeffDB1::Bdmumu_scheme_cache
private

Definition at line 238 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bdmumu_WC_cache
private

Definition at line 240 of file HeffDB1.h.

double HeffDB1::BMll_mu_cache
private

Definition at line 222 of file HeffDB1.h.

std::vector<double> HeffDB1::BMll_Mu_cache
private

Definition at line 224 of file HeffDB1.h.

schemes HeffDB1::BMll_scheme_cache
private

Definition at line 223 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::BMll_WC_cache
private

Definition at line 225 of file HeffDB1.h.

double HeffDB1::BMllprime_mu_cache
private

Definition at line 227 of file HeffDB1.h.

std::vector<double> HeffDB1::BMllprime_Mu_cache
private

Definition at line 229 of file HeffDB1.h.

schemes HeffDB1::BMllprime_scheme_cache
private

Definition at line 228 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::BMllprime_WC_cache
private

Definition at line 230 of file HeffDB1.h.

std::vector<double> HeffDB1::Bpsgamma_Mu_cache
private

Definition at line 218 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bpsgamma_WC_cache
private

Definition at line 220 of file HeffDB1.h.

double HeffDB1::Bsgamma_mu_cache
private

Definition at line 215 of file HeffDB1.h.

std::vector<double> HeffDB1::Bsgamma_Mu_cache
private

Definition at line 217 of file HeffDB1.h.

schemes HeffDB1::Bsgamma_scheme_cache
private

Definition at line 216 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bsgamma_WC_cache
private

Definition at line 219 of file HeffDB1.h.

double HeffDB1::Bsmumu_mu_cache
private

Definition at line 232 of file HeffDB1.h.

std::vector<double> HeffDB1::Bsmumu_Mu_cache
private

Definition at line 234 of file HeffDB1.h.

schemes HeffDB1::Bsmumu_scheme_cache
private

Definition at line 233 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bsmumu_WC_cache
private

Definition at line 235 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffBMll
private

Definition at line 208 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffbtaunu
private

Definition at line 205 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffdmumu
private

Definition at line 204 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffdnunu
private

Definition at line 206 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep00
private

Definition at line 200 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep00CC
private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep00qcd
private

Definition at line 200 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep01
private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep01A
private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep01B
private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep10
private

Definition at line 201 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep10CC
private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep10qcd
private

Definition at line 201 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep11
private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep11A
private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep11B
private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffprimeBMll
private

Definition at line 208 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffprimesgamma
private

Definition at line 207 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffsgamma
private

Definition at line 207 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffsmumu
private

Definition at line 204 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffsnunu
private

Definition at line 206 of file HeffDB1.h.

EvolBsmm HeffDB1::evolbd
private

Definition at line 211 of file HeffDB1.h.

EvolBsmm HeffDB1::evolbs
private

Definition at line 211 of file HeffDB1.h.

EvolDB1bsg HeffDB1::evolDB1bsg
private

Definition at line 210 of file HeffDB1.h.

EvolDB1Mll HeffDB1::evolDF1BMll
private

Definition at line 209 of file HeffDB1.h.

const StandardModel& HeffDB1::model
private

Definition at line 198 of file HeffDB1.h.

gslpp::vector<gslpp::complex> HeffDB1::nlep
private

Definition at line 242 of file HeffDB1.h.

gslpp::vector<gslpp::complex> HeffDB1::nlep2
private

Definition at line 242 of file HeffDB1.h.

gslpp::vector<gslpp::complex> HeffDB1::nlepCC
private

Definition at line 242 of file HeffDB1.h.


The documentation for this class was generated from the following files: