a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
Public Member Functions | Private Attributes | List of all members
HeffDB1 Class Reference

#include <HeffDB1.h>

Detailed Description

Definition at line 20 of file HeffDB1.h.

Public Member Functions

gslpp::vector< gslpp::complex > ** ComputeCoeffBMll (double mu, QCD::lepton lepton, bool noSM=false, 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 (QCD::meson meson_i)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffdmumu (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffdnunu ()
 
gslpp::vector< gslpp::complex > ** ComputeCoeffprimeBMll (double mu, QCD::lepton lepton, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffprimesgamma (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma (double mu, bool noSM=false, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumu (double mu, schemes scheme=NDR)
 
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumuStandardNorm (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 StandardModel & GetModel () const
 
EvolBsmm & getUBdmm () const
 
EvolBsmm & getUBsmm () const
 
EvolDB1bsg & getUDB1bsg () 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< WilsonCoefficient > Bdmumu_WC_cache
 
double BMll_mu_cache
 
std::vector< double > BMll_Mu_cache
 
unsigned int BMll_order_ini_cache
 
schemes BMll_scheme_cache
 
std::vector< WilsonCoefficient > BMll_WC_cache
 
double BMllprime_mu_cache
 
std::vector< double > BMllprime_Mu_cache
 
schemes BMllprime_scheme_cache
 
std::vector< WilsonCoefficient > BMllprime_WC_cache
 
std::vector< double > Bpsgamma_Mu_cache
 
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
 
double Bsgamma_mu_cache
 
std::vector< double > Bsgamma_Mu_cache
 
unsigned int Bsgamma_order_ini_cache
 
schemes Bsgamma_scheme_cache
 
std::vector< WilsonCoefficient > Bsgamma_WC_cache
 
double Bsmumu_mu_cache
 
std::vector< double > Bsmumu_Mu_cache
 
schemes Bsmumu_scheme_cache
 
std::vector< WilsonCoefficient > Bsmumu_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
 
std::unique_ptr< EvolBsmm > evolbd
 
std::unique_ptr< EvolBsmm > evolbs
 
std::unique_ptr< EvolDB1bsg > evolDB1bsg
 
std::unique_ptr< EvolDB1Mll > evolDF1BMll
 
const StandardModel & model
 
gslpp::vector< gslpp::complex > nlep
 
gslpp::vector< gslpp::complex > nlep2
 
gslpp::vector< gslpp::complex > nlepCC
 

Constructor & Destructor Documentation

◆ HeffDB1()

HeffDB1::HeffDB1 ( const StandardModel &  SM)

constructor

Parameters
SM
modelmatching

Definition at line 15 of file HeffDB1.cpp.

16 : model(SM),
17  coeffnlep00qcd (10, NDR, NLO, NLO_QED11), coeffnlep00 (12, NDR, NLO, NLO_QED11),
18  coeffnlep10qcd (10, NDR, NLO, NLO_QED11), coeffnlep10 (12, NDR, NLO, NLO_QED11),
19  coeffnlep01 (10, NDR, NLO), coeffnlep01A(10, NDR, NLO), coeffnlep01B(4, NDR, NLO), coeffnlep00CC(10, NDR, NLO),
20  coeffnlep11 (10, NDR, NLO), coeffnlep11A(10, NDR, NLO), coeffnlep11B(4, NDR, NLO), coeffnlep10CC(10, NDR, NLO),
21  coeffsmumu (8, NDR, NNLO, NLO_QED22), coeffdmumu (8, NDR, NNLO, NLO_QED22),
22  coeffbtaunu (3, NDR, LO),
23  coeffsnunu (1, NDR, NLO), coeffdnunu (1, NDR, NLO),
24  coeffsgamma(8,NDR, NNLO),
25  coeffprimesgamma(8,NDR, NNLO),
26  coeffBMll (13,NDR, NLO),
27  coeffprimeBMll (13, NDR, NLO),
28  evolDF1BMll(new EvolDB1Mll(13, NDR, NLO, SM)),
29  evolDB1bsg(new EvolDB1bsg(8, NDR, NNLO, SM)),
30  evolbs(new EvolBsmm(8, NDR, NNLO, NLO_QED22, SM)), evolbd(new EvolBsmm(8, NDR, NNLO, NLO_QED22, SM)),
31  nlep (12, 0.), nlep2(10, 0.),
32  nlepCC(4, 0.)
33 {
34 
35  for (unsigned int i = 0; i < 6; i++) {
36  BMll_WC_cache.push_back(coeffBMll);
37  BMll_Mu_cache.push_back(0.);
38  }
39  BMll_mu_cache = 0.;
40  BMll_order_ini_cache = 0;
41 
42  for (unsigned int i = 0; i < 6; i++) {
43  BMllprime_WC_cache.push_back(coeffprimeBMll);
44  BMllprime_Mu_cache.push_back(0.);
45  }
46  BMllprime_mu_cache = 0.;
47 
48  for (unsigned int i = 0; i < 6; i++) {
49  Bsgamma_WC_cache.push_back(coeffsgamma);
50  Bsgamma_Mu_cache.push_back(0.);
51  }
52  Bsgamma_mu_cache = 0.;
53  Bsgamma_order_ini_cache = 0;
54 
55  for (unsigned int i = 0; i < 6; i++) {
56  Bpsgamma_WC_cache.push_back(coeffsgamma);
57  Bpsgamma_Mu_cache.push_back(0.);
58  }
59 
60  for (unsigned int i = 0; i < 6; i++) {
61  Bsmumu_WC_cache.push_back(coeffsmumu);
62  Bsmumu_Mu_cache.push_back(0.);
63  }
64  Bsmumu_mu_cache = 0.;
65 
66  for (unsigned int i = 0; i < 6; i++) {
67  Bdmumu_WC_cache.push_back(coeffdmumu);
68  Bdmumu_Mu_cache.push_back(0.);
69  }
70  Bdmumu_mu_cache = 0.;
71 }

◆ ~HeffDB1()

HeffDB1::~HeffDB1 ( )
virtual

destructor

Definition at line 73 of file HeffDB1.cpp.

74 {}

Member Function Documentation

◆ ComputeCoeffBMll()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffBMll ( double  mu,
QCD::lepton  lepton,
bool  noSM = false,
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 751 of file HeffDB1.cpp.

752 {
753 
754  coeffBMll.setScheme(scheme);
755  orders ordDF1 = coeffBMll.getOrder();
756 
757  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMBMll(lepton);
758 
759  unsigned int order_ini;
760  if (noSM) order_ini = 1;
761  else order_ini = 0;
762 
763  if (mu == BMll_mu_cache && scheme == BMll_scheme_cache && order_ini == BMll_order_ini_cache) {
764  int check = 1;
765  for (unsigned int i = order_ini; i < mc.size(); i++) {
766  if (mc[i].getMu() == BMll_Mu_cache[i]) {
767  for (int j = LO; j <= ordDF1; j++) {
768  for (int k = LO; k <= j; k++) {
769  for (int l = 0; l < 13; l++) {
770  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMll_WC_cache[i].getCoeff(orders(j - k))))(l));
771  }
772  }
773  }
774  } else check = 0;
775  }
776  if (check == 1) return coeffBMll.getCoeff();
777  }
778 
779  BMll_mu_cache = mu;
780  BMll_order_ini_cache = order_ini;
781  BMll_scheme_cache = scheme;
782  BMll_WC_cache.clear();
783  BMll_WC_cache = mc;
784 
785  coeffBMll.setMu(mu);
786 
787  for (unsigned int i = order_ini; i < mc.size(); i++) {
788  BMll_Mu_cache[i] = mc[i].getMu();
789  for (int j = LO; j <= ordDF1; j++) {
790  for (int k = LO; k <= j; k++) {
791  coeffBMll.setCoeff(*coeffBMll.getCoeff(orders(j)) +
792  evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
793  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
794  }
795  }
796  }
797 
798  return coeffBMll.getCoeff();
799 }

◆ ComputeCoeffBnlep00()

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 | \)

◆ ComputeCoeffBnlep01()

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 | \)

◆ ComputeCoeffBnlep10()

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 | \)

◆ ComputeCoeffBnlep11()

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 | \)

◆ ComputeCoeffbtaunu()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffbtaunu ( QCD::meson  meson_i)
Parameters
scheme
Returns
short distance contribution to the rare decay \( B \rightarrow \tau \nu \)

Definition at line 609 of file HeffDB1.cpp.

610 {
611  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbtaunu(meson_i);
612  coeffbtaunu.resetCoefficient();
613  orders ordDF1 = coeffbtaunu.getOrder();
614  for (unsigned int i = 0; i < mcb.size(); i++){
615  for (int j = LO; j <= ordDF1; j++){
616  coeffbtaunu.setCoeff(*coeffbtaunu.getCoeff(orders(j))
617  + *mcb[i].getCoeff(orders(j)), orders(j));
618  }
619  }
620  return coeffbtaunu.getCoeff();
621 }

◆ ComputeCoeffdmumu()

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 420 of file HeffDB1.cpp.

421 {
422 
423  coeffdmumu.setScheme(scheme);
424  orders ordDF1 = coeffdmumu.getOrder();
425  orders_qed ordDF1ew = coeffdmumu.getOrder_qed();
426 
427  const std::vector<WilsonCoefficient>& mcbdm = model.getMatching().CMbdmm();
428 
429  if (mu == Bdmumu_mu_cache && scheme == Bdmumu_scheme_cache) {
430  int check = 1;
431  for (unsigned int i = 0; i < mcbdm.size(); i++) {
432  if (mcbdm[i].getMu() == Bdmumu_Mu_cache[i]) {
433  for (int j = LO; j <= ordDF1; j++) {
434  for (int k = LO; k <= j; k++) {
435  for (int l = 0; l < 8; l++) {
436  check *= ((*(mcbdm[i].getCoeff(orders(j - k))))(l) == (*(Bdmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
437  }
438  }
439  }
440  } else check = 0;
441  }
442  if (check == 1) return coeffdmumu.getCoeff();
443  }
444 
445  double nf = 5; //al the process has nf = 5, also the evolutor
446 
447  //int L = 6 - (int) nf;
448  int j = 0;
449  double alsM = evolbd->alphatilde_s(mcbdm[0].getMu());
450  double alsmu = evolbd->alphatilde_s(mu);
451  double eta = alsM / alsmu;
452 
453  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
454 
455  double B00E = 80./9., B01E = 176./9.;
456 
457  double logeta = log(eta);
458  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
459  double app = B00E * (1. - eta)/ B00S;
460 
461  Bdmumu_mu_cache = mu;
462  Bdmumu_scheme_cache = scheme;
463  Bdmumu_WC_cache.clear();
464  Bdmumu_WC_cache = mcbdm;
465 
466  coeffdmumu.setMu(mu);
467 
468  for (unsigned int i = 0; i < mcbdm.size(); i++){
469  Bdmumu_Mu_cache[i] = mcbdm[i].getMu();
470  for (j = LO; j <= ordDF1; j++){
471  for (int k = LO; k <= j; k++){
472  if ((k <= NNLO) && (j <= NNLO)){
473  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders(j)) + pow(eta,j) *
474  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(k), NO_QED, mcbdm[i].getScheme()) *
475  (*(mcbdm[i].getCoeff(orders(j - k)))), orders(j));
476  }
477  }
478  }
479 
480  for (j = LO_QED; j <= ordDF1ew; j++){
481 
482  switch(j) {
483 
484  case(NLO_QED22):
485 
486  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) +
487  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
488  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED22)))) +
489  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbdm[i].getScheme()) *
490  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
491  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
492  (*(mcbdm[i].getCoeff(orders(LO)))) +
493  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
494  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED21)))) +
495  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbdm[i].getScheme()) *
496  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
497  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbdm[i].getScheme()) *
498  (*(mcbdm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
499  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
500  (*(mcbdm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
501  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
502  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
503  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
504  (*(mcbdm[i].getCoeff(orders(LO)))) +
505  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
506  (*(mcbdm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
507  * app *
508  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
509  (*(mcbdm[i].getCoeff(orders(NLO)))) +
510  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
511  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
512 
513  break;
514 
515  case(NLO_QED12):
516 
517  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ eta) *
518  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
519  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
520  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbdm[i].getScheme()) *
521  (*(mcbdm[i].getCoeff(orders(NLO)))) +
522  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
523  (*(mcbdm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
524  * app *
525  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
526  (*(mcbdm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
527  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
528  (*(mcbdm[i].getCoeff(orders(NLO)))) +
529  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
530  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
531 
532  break;
533 
534  case(NLO_QED21):
535 
536  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + eta *
537  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
538  (*(mcbdm[i].getCoeff(orders_qed(j)))) +
539  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
540  (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
541  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbdm[i].getScheme()) *
542  (*(mcbdm[i].getCoeff(orders(NLO)))) +
543  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
544  (*(mcbdm[i].getCoeff(orders(LO)))) +
545  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
546  (*(mcbdm[i].getCoeff(orders(NNLO)))))-
547  eta * logeta * fatt *
548  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
549  (*(mcbdm[i].getCoeff(orders(NLO)))) +
550  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
551  (*(mcbdm[i].getCoeff(orders(LO)))))
552  - eta * app *
553  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
554  (*(mcbdm[i].getCoeff(orders(NNLO)))) +
555  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NNLO), NO_QED, mcbdm[i].getScheme()) *
556  (*(mcbdm[i].getCoeff(orders(LO)))) +
557  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
558  (*(mcbdm[i].getCoeff(orders(NLO)))) ), orders_qed(j));
559 
560  break;
561 
562  case(NLO_QED02):
563 
564  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,2)) *
565  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
566  (*(mcbdm[i].getCoeff(orders(LO)))) + ( app
567  * app/(eta * eta ) ) *
568  evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
569  (*(mcbdm[i].getCoeff(orders(LO)))), orders_qed(j));
570 
571  break;
572 
573  case(NLO_QED11):
574 
575  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) +
576  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
577  (*(mcbdm[i].getCoeff(orders(LO)))) +
578  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
579  (*(mcbdm[i].getCoeff(orders_qed(j)))) +
580  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
581  (*(mcbdm[i].getCoeff(orders(NLO)))) - logeta * fatt *
582  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
583  (*(mcbdm[i].getCoeff(orders(LO))))) - app *
584  (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
585  (*(mcbdm[i].getCoeff(orders(NLO)))) +
586  evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
587  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
588 
589 
590  break;
591 
592  case(LO_QED):
593 
594  coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,1)) *
595  evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
596  (*(mcbdm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
597  ( evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
598  (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
599 
600 
601 
602  break;
603  }
604  }
605  }
606  return coeffdmumu.getCoeff();
607 }

◆ ComputeCoeffdnunu()

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 640 of file HeffDB1.cpp.

641 {
642 
643  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXdnn();
644 
645  orders ordDF1 = coeffdnunu.getOrder();
646 
647  for (unsigned int i = 0; i < mcb.size(); i++){
648  for (int j = LO; j <= ordDF1; j++){
649  coeffdnunu.setCoeff(*coeffdnunu.getCoeff(orders(j))
650  + *mcb[i].getCoeff(orders(j)), orders(j));
651  }
652  }
653 
654  return coeffdnunu.getCoeff();
655 }

◆ ComputeCoeffprimeBMll()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffprimeBMll ( double  mu,
QCD::lepton  lepton,
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 802 of file HeffDB1.cpp.

803 {
804 
805  coeffprimeBMll.setScheme(scheme);
806  orders ordDF1 = coeffprimeBMll.getOrder();
807 
808  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMprimeBMll(lepton);
809 
810  if (mu == BMllprime_mu_cache && scheme == BMllprime_scheme_cache) {
811  int check = 1;
812  for (unsigned int i = 0; i < mc.size(); i++) {
813  if (mc[i].getMu() == BMllprime_Mu_cache[i]) {
814  for (int j = LO; j <= ordDF1; j++) {
815  for (int k = LO; k <= j; k++) {
816  for (int l = 0; l < 13; l++) {
817  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMllprime_WC_cache[i].getCoeff(orders(j - k))))(l));
818  }
819  }
820  }
821  } else check = 0;
822  }
823  if (check == 1) return coeffprimeBMll.getCoeff();
824  }
825 
826  BMllprime_mu_cache = mu;
827  BMllprime_scheme_cache = scheme;
828  BMllprime_WC_cache.clear();
829  BMllprime_WC_cache = mc;
830 
831  coeffprimeBMll.setMu(mu);
832 
833  for (unsigned int i = 0; i < mc.size(); i++){
834  BMllprime_Mu_cache[i] = mc[i].getMu();
835  for (int j = LO; j <= ordDF1; j++){
836  for (int k = LO; k <= j; k++){
837  coeffprimeBMll.setCoeff(*coeffprimeBMll.getCoeff(orders(j)) +
838  evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
839  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
840  }
841  }
842  }
843 
844 
845  return coeffprimeBMll.getCoeff();
846 }

◆ ComputeCoeffprimesgamma()

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 706 of file HeffDB1.cpp.

707 {
708 
709  coeffprimesgamma.setScheme(scheme);
710  orders ordDF1 = coeffprimesgamma.getOrder();
711 
712  const std::vector<WilsonCoefficient>& mcbsgp = model.getMatching().CMprimebsg();
713 
714  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
715  int check = 1;
716  for (unsigned int i = 0; i < mcbsgp.size(); i++) {
717  if (mcbsgp[i].getMu() == Bpsgamma_Mu_cache[i]) {
718  for (int j = LO; j <= ordDF1; j++) {
719  for (int k = LO; k <= j; k++) {
720  for (int l = 0; l < 8; l++) {
721  check *= ((*(mcbsgp[i].getCoeff(orders(j - k))))(l) == (*(Bpsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
722  }
723  }
724  }
725  } else check = 0;
726  }
727  if (check == 1) return coeffprimesgamma.getCoeff();
728  }
729 
730  Bsgamma_mu_cache = mu;
731  Bsgamma_scheme_cache = scheme;
732  Bpsgamma_WC_cache.clear();
733  Bpsgamma_WC_cache = mcbsgp;
734 
735  coeffprimesgamma.setMu(mu);
736 
737  for (unsigned int i = 0; i < mcbsgp.size(); i++){
738  Bpsgamma_Mu_cache[i] = mcbsgp[i].getMu();
739  for (int j = LO; j <= ordDF1; j++){
740  for (int k = LO; k <= j; k++){
741  coeffprimesgamma.setCoeff(*coeffprimesgamma.getCoeff(orders(j)) +
742  evolDB1bsg->Df1Evolbsg(mu, mcbsgp[i].getMu(), orders(k), mcbsgp[i].getScheme()) *
743  (*(mcbsgp[i].getCoeff(orders(j - k)))), orders(j));
744  }
745  }
746  }
747 
748  return coeffprimesgamma.getCoeff();
749 }

◆ ComputeCoeffsgamma()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsgamma ( double  mu,
bool  noSM = false,
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 657 of file HeffDB1.cpp.

658 {
659  coeffsgamma.setScheme(scheme);
660  orders ordDF1 = coeffsgamma.getOrder();
661 
662  unsigned int order_ini;
663  if (noSM) order_ini = 1;
664  else order_ini = 0;
665 
666  const std::vector<WilsonCoefficient>& mcbsg = model.getMatching().CMbsg();
667 
668  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache && order_ini == BMll_order_ini_cache) {
669  int check = 1;
670  for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
671  if (mcbsg[i].getMu() == Bsgamma_Mu_cache[i]) {
672  for (int j = LO; j <= ordDF1; j++) {
673  for (int k = LO; k <= j; k++) {
674  for (int l = 0; l < 8; l++) {
675  check *= ((*(mcbsg[i].getCoeff(orders(j - k))))(l) == (*(Bsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
676  }
677  }
678  }
679  } else check = 0;
680  }
681  if (check == 1) return coeffsgamma.getCoeff();
682  }
683 
684  Bsgamma_mu_cache = mu;
685  Bsgamma_order_ini_cache = order_ini;
686  Bsgamma_scheme_cache = scheme;
687  Bsgamma_WC_cache.clear();
688  Bsgamma_WC_cache = mcbsg;
689 
690  coeffsgamma.setMu(mu);
691 
692  for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
693  Bsgamma_Mu_cache[i] = mcbsg[i].getMu();
694  for (int j = LO; j <= ordDF1; j++) {
695  for (int k = LO; k <= j; k++) {
696  coeffsgamma.setCoeff(*coeffsgamma.getCoeff(orders(j)) +
697  evolDB1bsg->Df1Evolbsg(mu, mcbsg[i].getMu(), orders(k), mcbsg[i].getScheme()) *
698  (*(mcbsg[i].getCoeff(orders(j - k)))), orders(j));
699  }
700  }
701  }
702 
703  return coeffsgamma.getCoeff();
704 }

◆ ComputeCoeffsmumu()

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 76 of file HeffDB1.cpp.

77 {
78 
79 
80  coeffsmumu.setScheme(scheme);
81  orders ordDF1 = coeffsmumu.getOrder();
82  orders_qed ordDF1ew = coeffsmumu.getOrder_qed();
83 
84  const std::vector<WilsonCoefficient>& mcbsm = model.getMatching().CMbsmm();
85 
86  if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
87  int check = 1;
88  for (unsigned int i = 0; i < mcbsm.size(); i++) {
89  if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
90  for (int j = LO; j <= ordDF1; j++) {
91  for (int k = LO; k <= j; k++) {
92  for (int l = 0; l < 8; l++) {
93  check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
94  }
95  }
96  }
97  } else check = 0;
98  }
99  if (check == 1) return coeffsmumu.getCoeff();
100  }
101 
102  double nf = 5; //al the process has nf = 5, also the evolutor
103 
104  //int L = 6 - (int) nf;
105  int j = 0;
106  double alsM = evolbs->alphatilde_s(mcbsm[0].getMu());
107  double alsmu = evolbs->alphatilde_s(mu);
108  double eta = alsM / alsmu;
109 
110  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
111 
112  double B00E = 80./9., B01E = 176./9.;
113 
114  double logeta = log(eta);
115  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
116  double app = B00E * (1. - eta)/ B00S;
117 
118  Bsmumu_mu_cache = mu;
119  Bsmumu_scheme_cache = scheme;
120  Bsmumu_WC_cache.clear();
121  Bsmumu_WC_cache = mcbsm;
122 
123  coeffsmumu.setMu(mu);
124 
125  for (unsigned int i = 0; i < mcbsm.size(); i++){
126  Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
127  for (j = LO; j <= ordDF1; j++){
128  for (int k = LO; k <= j; k++){
129  if ((k <= NNLO) && (j <= NNLO)){
130  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
131  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(k), NO_QED, mcbsm[i].getScheme()) *
132  (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
133  }
134  }
135  }
136 
137  for (j = LO_QED; j <= ordDF1ew; j++){
138 
139  switch(j) {
140 
141  case(NLO_QED22):
142 
143  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
144  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
145  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED22)))) +
146  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
147  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
148  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
149  (*(mcbsm[i].getCoeff(orders(LO)))) +
150  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
151  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
152  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
153  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
154  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
155  (*(mcbsm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
156  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
157  (*(mcbsm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
158  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
159  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
160  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
161  (*(mcbsm[i].getCoeff(orders(LO)))) +
162  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
163  (*(mcbsm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
164  * app *
165  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
166  (*(mcbsm[i].getCoeff(orders(NLO)))) +
167  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
168  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
169 
170  break;
171 
172  case(NLO_QED12):
173 
174  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ eta) *
175  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
176  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
177  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
178  (*(mcbsm[i].getCoeff(orders(NLO)))) +
179  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
180  (*(mcbsm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
181  * app *
182  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
183  (*(mcbsm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
184  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
185  (*(mcbsm[i].getCoeff(orders(NLO)))) +
186  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
187  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
188 
189  break;
190 
191  case(NLO_QED21):
192 
193  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + eta *
194  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
195  (*(mcbsm[i].getCoeff(orders_qed(j)))) +
196  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
197  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
198  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
199  (*(mcbsm[i].getCoeff(orders(NLO)))) +
200  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
201  (*(mcbsm[i].getCoeff(orders(LO)))) +
202  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
203  (*(mcbsm[i].getCoeff(orders(NNLO)))))-
204  eta * logeta * fatt *
205  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
206  (*(mcbsm[i].getCoeff(orders(NLO)))) +
207  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
208  (*(mcbsm[i].getCoeff(orders(LO)))))
209  - eta * app *
210  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
211  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
212  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NNLO), NO_QED, mcbsm[i].getScheme()) *
213  (*(mcbsm[i].getCoeff(orders(LO)))) +
214  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
215  (*(mcbsm[i].getCoeff(orders(NLO)))) ), orders_qed(j));
216 
217  break;
218 
219  case(NLO_QED02):
220 
221  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,2)) *
222  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
223  (*(mcbsm[i].getCoeff(orders(LO)))) + ( app
224  * app/( eta * eta ) ) *
225  evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
226  (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
227 
228  break;
229 
230  case(NLO_QED11):
231 
232  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
233  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
234  (*(mcbsm[i].getCoeff(orders(LO)))) +
235  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
236  (*(mcbsm[i].getCoeff(orders_qed(j)))) +
237  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
238  (*(mcbsm[i].getCoeff(orders(NLO)))) - logeta * fatt *
239  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
240  (*(mcbsm[i].getCoeff(orders(LO))))) - app *
241  (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
242  (*(mcbsm[i].getCoeff(orders(NLO)))) +
243  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
244  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
245 
246 
247  break;
248 
249  case(LO_QED):
250 
251  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,1)) *
252  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
253  (*(mcbsm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
254  ( evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
255  (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
256 
257 
258 
259  break;
260  }
261  }
262  }
263  return coeffsmumu.getCoeff();
264 }

◆ ComputeCoeffsmumuStandardNorm()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsmumuStandardNorm ( double  mu,
schemes  scheme = NDR 
)
Parameters
scheme
Returns
short distance contribution to the rare decay \( B_{s} \rightarrow \mu \bar{\mu} \)

Definition at line 267 of file HeffDB1.cpp.

268 {
269  coeffsmumu.setScheme(scheme);
270  orders ordDF1 = coeffsmumu.getOrder();
271  orders_qed ordDF1ew = coeffsmumu.getOrder_qed();
272  const std::vector<WilsonCoefficient>& mcbsm = model.getMatching().CMbsmm();
273 
274  if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
275  int check = 1;
276  for (unsigned int i = 0; i < mcbsm.size(); i++) {
277  if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
278  for (int j = LO; j <= ordDF1; j++) {
279  for (int k = LO; k <= j; k++) {
280  for (int l = 0; l < 8; l++) {
281  check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
282  }
283  }
284  }
285  } else check = 0;
286  }
287  if (check == 1) return coeffsmumu.getCoeff();
288  }
289  double nf = 5; //al the process has nf = 5, also the evolutor
290  //int L = 6 - (int) nf;
291  int j = 0;
292  double alsM = evolbs->alphatilde_s(mcbsm[0].getMu());
293  double alsmu = evolbs->alphatilde_s(mu);
294  double eta = alsM / alsmu;
295 
296  double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
297 
298  double B00E = 80./9., B01E = 176./9.;
299 
300  double logeta = log(eta);
301  double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
302  double app = B00E * (1. - eta)/ B00S;
303 
304  Bsmumu_mu_cache = mu;
305  Bsmumu_scheme_cache = scheme;
306  Bsmumu_WC_cache.clear();
307  Bsmumu_WC_cache = mcbsm;
308 
309  coeffsmumu.setMu(mu);
310 
311  for (unsigned int i = 0; i < mcbsm.size(); i++){
312  Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
313  for (j = LO; j <= ordDF1; j++){
314  for (int k = LO; k <= j; k++){
315  if ((k <= NNLO) && (j <= NNLO)){
316  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
317  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(k), NO_QED, mcbsm[i].getScheme()) *
318  (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
319  }
320  }
321  }
322 
323  for (j = LO_QED; j <= ordDF1ew; j++){
324 
325  switch(j) {
326 
327  case(NLO_QED22):
328  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
329  evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
330  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED22)))) +
331  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
332  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
333  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED22), mcbsm[i].getScheme()) *
334  (*(mcbsm[i].getCoeff(orders(LO)))) +
335  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
336  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
337  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
338  (*(mcbsm[i].getCoeff(orders(NNLO)))) +
339  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
340  (*(mcbsm[i].getCoeff(orders(NLO)))) +
341  logeta*fatt * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
342  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
343  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
344  (*(mcbsm[i].getCoeff(orders(LO)))) +
345  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
346  (*(mcbsm[i].getCoeff(orders(NLO))))) +
347  app * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
348  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
349  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
350  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
351  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
352  (*(mcbsm[i].getCoeff(orders(NLO)))) +
353  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED21), mcbsm[i].getScheme()) *
354  (*(mcbsm[i].getCoeff(orders(LO)))) +
355  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
356  (*(mcbsm[i].getCoeff(orders(NNLO))))), orders_qed(j));
357  break;
358 
359  case(NLO_QED21):
360  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
361  eta * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
362  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
363  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
364  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
365  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
366  (*(mcbsm[i].getCoeff(orders(NLO)))) +
367  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED21), mcbsm[i].getScheme()) *
368  (*(mcbsm[i].getCoeff(orders(LO)))) +
369  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
370  (*(mcbsm[i].getCoeff(orders(NNLO))))), orders_qed(j));
371  break;
372 
373  case(NLO_QED12):
374  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
375  (1./eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
376  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
377  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
378  (*(mcbsm[i].getCoeff(orders(NLO)))) +
379  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
380  (*(mcbsm[i].getCoeff(orders(LO))))) +
381  (logeta*fatt/eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
382  (*(mcbsm[i].getCoeff(orders(LO))))) +
383  (app/eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
384  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
385  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
386  (*(mcbsm[i].getCoeff(orders(LO)))) +
387  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
388  (*(mcbsm[i].getCoeff(orders(NLO))))), orders_qed(j));
389  break;
390 
391  case(NLO_QED02):
392  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
393  (1./ pow(eta,2)) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
394  (*(mcbsm[i].getCoeff(orders(LO)))) +
395  (app/(eta*eta)) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
396  (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
397  break;
398 
399  case(NLO_QED11):
400  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
401  evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
402  (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
403  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
404  (*(mcbsm[i].getCoeff(orders(LO)))) +
405  evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
406  (*(mcbsm[i].getCoeff(orders(NLO)))), orders_qed(j));
407  break;
408 
409  case(LO_QED):
410  coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
411  (1./ eta) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
412  (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
413  break;
414  }
415  }
416  }
417  return coeffsmumu.getCoeff();
418 }

◆ ComputeCoeffsnunu()

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 623 of file HeffDB1.cpp.

624 {
625 
626  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXsnn();
627 
628  orders ordDF1 = coeffsnunu.getOrder();
629 
630  for (unsigned int i = 0; i < mcb.size(); i++){
631  for (int j = LO; j <= ordDF1; j++){
632  coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders(j))
633  + *mcb[i].getCoeff(orders(j)), orders(j));
634  }
635  }
636 
637  return coeffsnunu.getCoeff();
638 }

◆ getCoeffbtaunu()

WilsonCoefficient HeffDB1::getCoeffbtaunu ( ) const
inline

Definition at line 165 of file HeffDB1.h.

165  {
166  return coeffbtaunu;
167  }

◆ getCoeffdmumu()

WilsonCoefficient HeffDB1::getCoeffdmumu ( ) const
inline

Definition at line 161 of file HeffDB1.h.

161  {
162  return coeffdmumu;
163  }

◆ getCoeffdnunu()

WilsonCoefficient HeffDB1::getCoeffdnunu ( ) const
inline

Definition at line 173 of file HeffDB1.h.

173  {
174  return coeffdnunu;
175  }

◆ getCoeffnlep00()

WilsonCoefficient HeffDB1::getCoeffnlep00 ( ) const
inline

Definition at line 141 of file HeffDB1.h.

141  {
142  return coeffnlep00;
143  }

◆ getCoeffnlep01()

WilsonCoefficient HeffDB1::getCoeffnlep01 ( ) const
inline

Definition at line 149 of file HeffDB1.h.

149  {
150  return coeffnlep10;
151  }

◆ getCoeffnlep10()

WilsonCoefficient HeffDB1::getCoeffnlep10 ( ) const
inline

Definition at line 145 of file HeffDB1.h.

145  {
146  return coeffnlep01;
147  }

◆ getCoeffnlep11()

WilsonCoefficient HeffDB1::getCoeffnlep11 ( ) const
inline

Definition at line 153 of file HeffDB1.h.

153  {
154  return coeffnlep11;
155  }

◆ getCoeffprimesgamma()

WilsonCoefficient HeffDB1::getCoeffprimesgamma ( ) const
inline

Definition at line 181 of file HeffDB1.h.

181  {
182  return coeffprimesgamma;
183  }

◆ getCoeffsgamma()

WilsonCoefficient HeffDB1::getCoeffsgamma ( ) const
inline

Definition at line 177 of file HeffDB1.h.

177  {
178  return coeffsgamma;
179  }

◆ getCoeffsmumu()

WilsonCoefficient HeffDB1::getCoeffsmumu ( ) const
inline

Definition at line 157 of file HeffDB1.h.

157  {
158  return coeffsmumu;
159  }

◆ getCoeffsnunu()

WilsonCoefficient HeffDB1::getCoeffsnunu ( ) const
inline

Definition at line 169 of file HeffDB1.h.

169  {
170  return coeffsnunu;
171  }

◆ GetModel()

const StandardModel& HeffDB1::GetModel ( ) const
inline

Definition at line 197 of file HeffDB1.h.

197  {
198  return model;
199  }

◆ getUBdmm()

EvolBsmm& HeffDB1::getUBdmm ( ) const
inline

Definition at line 189 of file HeffDB1.h.

189  {
190  return *evolbd;
191  }

◆ getUBsmm()

EvolBsmm& HeffDB1::getUBsmm ( ) const
inline

Definition at line 185 of file HeffDB1.h.

185  {
186  return *evolbs;
187  }

◆ getUDB1bsg()

EvolDB1bsg& HeffDB1::getUDB1bsg ( ) const
inline

Definition at line 193 of file HeffDB1.h.

193  {
194  return *evolDB1bsg;
195  }

Member Data Documentation

◆ Bdmumu_mu_cache

double HeffDB1::Bdmumu_mu_cache
private

Definition at line 243 of file HeffDB1.h.

◆ Bdmumu_Mu_cache

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

Definition at line 245 of file HeffDB1.h.

◆ Bdmumu_scheme_cache

schemes HeffDB1::Bdmumu_scheme_cache
private

Definition at line 244 of file HeffDB1.h.

◆ Bdmumu_WC_cache

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

Definition at line 246 of file HeffDB1.h.

◆ BMll_mu_cache

double HeffDB1::BMll_mu_cache
private

Definition at line 227 of file HeffDB1.h.

◆ BMll_Mu_cache

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

Definition at line 230 of file HeffDB1.h.

◆ BMll_order_ini_cache

unsigned int HeffDB1::BMll_order_ini_cache
private

Definition at line 228 of file HeffDB1.h.

◆ BMll_scheme_cache

schemes HeffDB1::BMll_scheme_cache
private

Definition at line 229 of file HeffDB1.h.

◆ BMll_WC_cache

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

Definition at line 231 of file HeffDB1.h.

◆ BMllprime_mu_cache

double HeffDB1::BMllprime_mu_cache
private

Definition at line 233 of file HeffDB1.h.

◆ BMllprime_Mu_cache

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

Definition at line 235 of file HeffDB1.h.

◆ BMllprime_scheme_cache

schemes HeffDB1::BMllprime_scheme_cache
private

Definition at line 234 of file HeffDB1.h.

◆ BMllprime_WC_cache

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

Definition at line 236 of file HeffDB1.h.

◆ Bpsgamma_Mu_cache

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

Definition at line 223 of file HeffDB1.h.

◆ Bpsgamma_WC_cache

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

Definition at line 225 of file HeffDB1.h.

◆ Bsgamma_mu_cache

double HeffDB1::Bsgamma_mu_cache
private

Definition at line 219 of file HeffDB1.h.

◆ Bsgamma_Mu_cache

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

Definition at line 222 of file HeffDB1.h.

◆ Bsgamma_order_ini_cache

unsigned int HeffDB1::Bsgamma_order_ini_cache
private

Definition at line 220 of file HeffDB1.h.

◆ Bsgamma_scheme_cache

schemes HeffDB1::Bsgamma_scheme_cache
private

Definition at line 221 of file HeffDB1.h.

◆ Bsgamma_WC_cache

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

Definition at line 224 of file HeffDB1.h.

◆ Bsmumu_mu_cache

double HeffDB1::Bsmumu_mu_cache
private

Definition at line 238 of file HeffDB1.h.

◆ Bsmumu_Mu_cache

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

Definition at line 240 of file HeffDB1.h.

◆ Bsmumu_scheme_cache

schemes HeffDB1::Bsmumu_scheme_cache
private

Definition at line 239 of file HeffDB1.h.

◆ Bsmumu_WC_cache

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

Definition at line 241 of file HeffDB1.h.

◆ coeffBMll

WilsonCoefficient HeffDB1::coeffBMll
private

Definition at line 212 of file HeffDB1.h.

◆ coeffbtaunu

WilsonCoefficient HeffDB1::coeffbtaunu
private

Definition at line 209 of file HeffDB1.h.

◆ coeffdmumu

WilsonCoefficient HeffDB1::coeffdmumu
private

Definition at line 208 of file HeffDB1.h.

◆ coeffdnunu

WilsonCoefficient HeffDB1::coeffdnunu
private

Definition at line 210 of file HeffDB1.h.

◆ coeffnlep00

WilsonCoefficient HeffDB1::coeffnlep00
private

Definition at line 204 of file HeffDB1.h.

◆ coeffnlep00CC

WilsonCoefficient HeffDB1::coeffnlep00CC
private

Definition at line 206 of file HeffDB1.h.

◆ coeffnlep00qcd

WilsonCoefficient HeffDB1::coeffnlep00qcd
private

Definition at line 204 of file HeffDB1.h.

◆ coeffnlep01

WilsonCoefficient HeffDB1::coeffnlep01
private

Definition at line 206 of file HeffDB1.h.

◆ coeffnlep01A

WilsonCoefficient HeffDB1::coeffnlep01A
private

Definition at line 206 of file HeffDB1.h.

◆ coeffnlep01B

WilsonCoefficient HeffDB1::coeffnlep01B
private

Definition at line 206 of file HeffDB1.h.

◆ coeffnlep10

WilsonCoefficient HeffDB1::coeffnlep10
private

Definition at line 205 of file HeffDB1.h.

◆ coeffnlep10CC

WilsonCoefficient HeffDB1::coeffnlep10CC
private

Definition at line 207 of file HeffDB1.h.

◆ coeffnlep10qcd

WilsonCoefficient HeffDB1::coeffnlep10qcd
private

Definition at line 205 of file HeffDB1.h.

◆ coeffnlep11

WilsonCoefficient HeffDB1::coeffnlep11
private

Definition at line 207 of file HeffDB1.h.

◆ coeffnlep11A

WilsonCoefficient HeffDB1::coeffnlep11A
private

Definition at line 207 of file HeffDB1.h.

◆ coeffnlep11B

WilsonCoefficient HeffDB1::coeffnlep11B
private

Definition at line 207 of file HeffDB1.h.

◆ coeffprimeBMll

WilsonCoefficient HeffDB1::coeffprimeBMll
private

Definition at line 212 of file HeffDB1.h.

◆ coeffprimesgamma

WilsonCoefficient HeffDB1::coeffprimesgamma
private

Definition at line 211 of file HeffDB1.h.

◆ coeffsgamma

WilsonCoefficient HeffDB1::coeffsgamma
private

Definition at line 211 of file HeffDB1.h.

◆ coeffsmumu

WilsonCoefficient HeffDB1::coeffsmumu
private

Definition at line 208 of file HeffDB1.h.

◆ coeffsnunu

WilsonCoefficient HeffDB1::coeffsnunu
private

Definition at line 210 of file HeffDB1.h.

◆ evolbd

std::unique_ptr<EvolBsmm> HeffDB1::evolbd
private

Definition at line 216 of file HeffDB1.h.

◆ evolbs

std::unique_ptr<EvolBsmm> HeffDB1::evolbs
private

Definition at line 215 of file HeffDB1.h.

◆ evolDB1bsg

std::unique_ptr<EvolDB1bsg> HeffDB1::evolDB1bsg
private

Definition at line 214 of file HeffDB1.h.

◆ evolDF1BMll

std::unique_ptr<EvolDB1Mll> HeffDB1::evolDF1BMll
private

Definition at line 213 of file HeffDB1.h.

◆ model

const StandardModel& HeffDB1::model
private

Definition at line 202 of file HeffDB1.h.

◆ nlep

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

Definition at line 248 of file HeffDB1.h.

◆ nlep2

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

Definition at line 248 of file HeffDB1.h.

◆ nlepCC

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

Definition at line 248 of file HeffDB1.h.

The documentation for this class was generated from the following files:
WilsonTemplate::setScheme
void setScheme(schemes scheme)
Definition: WilsonTemplate.h:103
ModelMatching::CMprimeBMll
virtual std::vector< WilsonCoefficient > & CMprimeBMll(QCD::lepton lepton)=0
NO_QED
Definition: OrderScheme.h:49
HeffDB1::coeffnlep00qcd
WilsonCoefficient coeffnlep00qcd
Definition: HeffDB1.h:204
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:248
HeffDB1::BMll_order_ini_cache
unsigned int BMll_order_ini_cache
Definition: HeffDB1.h:228
HeffDB1::evolDF1BMll
std::unique_ptr< EvolDB1Mll > evolDF1BMll
Definition: HeffDB1.h:213
HeffDB1::coeffBMll
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:212
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:214
HeffDB1::coeffnlep11A
WilsonCoefficient coeffnlep11A
Definition: HeffDB1.h:207
HeffDB1::coeffnlep11B
WilsonCoefficient coeffnlep11B
Definition: HeffDB1.h:207
HeffDB1::coeffnlep10
WilsonCoefficient coeffnlep10
Definition: HeffDB1.h:205
HeffDB1::Bpsgamma_WC_cache
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:225
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:240
HeffDB1::coeffbtaunu
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:209
HeffDB1::evolbd
std::unique_ptr< EvolBsmm > evolbd
Definition: HeffDB1.h:216
HeffDB1::BMllprime_WC_cache
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:236
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
HeffDB1::coeffdmumu
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:208
HeffDB1::nlep
gslpp::vector< gslpp::complex > nlep
Definition: HeffDB1.h:248
EvolDB1Mll
Definition: EvolDB1Mll.h:14
HeffDB1::coeffprimesgamma
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:211
HeffDB1::Bdmumu_scheme_cache
schemes Bdmumu_scheme_cache
Definition: HeffDB1.h:244
HeffDB1::coeffsmumu
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:208
HeffDB1::coeffnlep10CC
WilsonCoefficient coeffnlep10CC
Definition: HeffDB1.h:207
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:466
WilsonTemplate::getOrder
orders getOrder() const
Definition: WilsonTemplate.h:65
HeffDB1::BMll_scheme_cache
schemes BMll_scheme_cache
Definition: HeffDB1.h:229
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:224
HeffDB1::Bsgamma_scheme_cache
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:221
HeffDB1::coeffnlep01
WilsonCoefficient coeffnlep01
Definition: HeffDB1.h:206
ModelMatching::CMBMll
virtual std::vector< WilsonCoefficient > & CMBMll(QCD::lepton lepton)=0
HeffDB1::coeffnlep00CC
WilsonCoefficient coeffnlep00CC
Definition: HeffDB1.h:206
EvolBsmm
Definition: EvolBsmm.h:16
HeffDB1::model
const StandardModel & model
Definition: HeffDB1.h:202
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
LO_QED
Definition: OrderScheme.h:50
HeffDB1::Bsmumu_scheme_cache
schemes Bsmumu_scheme_cache
Definition: HeffDB1.h:239
HeffDB1::coeffnlep10qcd
WilsonCoefficient coeffnlep10qcd
Definition: HeffDB1.h:205
HeffDB1::Bdmumu_mu_cache
double Bdmumu_mu_cache
Definition: HeffDB1.h:243
HeffDB1::coeffsgamma
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:211
NNLO
Definition: OrderScheme.h:35
HeffDB1::Bsgamma_Mu_cache
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:222
HeffDB1::coeffsnunu
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:210
HeffDB1::BMllprime_scheme_cache
schemes BMllprime_scheme_cache
Definition: HeffDB1.h:234
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:238
HeffDB1::BMllprime_Mu_cache
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:235
ModelMatching::CMprimebsg
virtual std::vector< WilsonCoefficient > & CMprimebsg()=0
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
NLO_QED12
Definition: OrderScheme.h:54
HeffDB1::Bsgamma_mu_cache
double Bsgamma_mu_cache
Definition: HeffDB1.h:219
HeffDB1::BMllprime_mu_cache
double BMllprime_mu_cache
Definition: HeffDB1.h:233
HeffDB1::coeffnlep01A
WilsonCoefficient coeffnlep01A
Definition: HeffDB1.h:206
StandardModel::getMatching
virtual StandardModelMatching & getMatching() const
A get method to access the member reference of type StandardModelMatching.
Definition: StandardModel.h:949
HeffDB1::Bdmumu_Mu_cache
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:245
HeffDB1::coeffdnunu
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:210
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:220
HeffDB1::coeffprimeBMll
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:212
HeffDB1::coeffnlep01B
WilsonCoefficient coeffnlep01B
Definition: HeffDB1.h:206
HeffDB1::BMll_mu_cache
double BMll_mu_cache
Definition: HeffDB1.h:227
HeffDB1::coeffnlep11
WilsonCoefficient coeffnlep11
Definition: HeffDB1.h:207
HeffDB1::coeffnlep00
WilsonCoefficient coeffnlep00
Definition: HeffDB1.h:204
HeffDB1::Bpsgamma_Mu_cache
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:223
HeffDB1::nlepCC
gslpp::vector< gslpp::complex > nlepCC
Definition: HeffDB1.h:248
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:231
HeffDB1::Bsmumu_WC_cache
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:241
HeffDB1::evolbs
std::unique_ptr< EvolBsmm > evolbs
Definition: HeffDB1.h:215
HeffDB1::Bdmumu_WC_cache
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:246
HeffDB1::BMll_Mu_cache
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:230