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

#include <HeffDB1.h>

Detailed Description

Definition at line 23 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 > ** ComputeCoeffBMll_Buras (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 ()
 
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 > ** ComputeCoeffsgamma_Buras (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 (QCD::lepton lepton, bool noSM=false)
 
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
 
EvolDF1nlep & getUDF1 () const
 
EvolDB1Mll & getUDF1BMll () const
 
 HeffDB1 (const StandardModel &SM)
 constructor More...
 
virtual ~HeffDB1 ()
 destructor More...
 

Private Member Functions

void setMisiaktoBuras ()
 

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 coeffBMll_Buras
 
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 coeffsgamma_Buras
 
WilsonCoefficient coeffsmumu
 
WilsonCoefficient coeffsnunu
 
gslpp::matrix< double > dR_t = gslpp::matrix< double >(6, 6, 0.)
 
std::unique_ptr< EvolBsmm > evolbd
 
std::unique_ptr< EvolBsmm > evolbs
 
std::unique_ptr< EvolDB1bsg > evolDB1bsg
 
std::unique_ptr< EvolDB1Mll > evolDF1BMll
 
gslpp::matrix< double > MisiaktoBurasNLO = gslpp::matrix< double >(6, 6, 0.)
 
const StandardModel & model
 
gslpp::vector< gslpp::complex > nlep
 
gslpp::vector< gslpp::complex > nlep2
 
gslpp::vector< gslpp::complex > nlepCC
 
gslpp::matrix< double > R_inv_t = gslpp::matrix< double >(6, 6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffBMll = gslpp::vector<gslpp::complex>(6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffBMllLO = gslpp::vector<gslpp::complex>(6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffBMllNLO = gslpp::vector<gslpp::complex>(6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffsgamma = gslpp::vector<gslpp::complex>(6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffsgammaLO = gslpp::vector<gslpp::complex>(6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffsgammaNLO = gslpp::vector<gslpp::complex>(6, 0.)
 
gslpp::vector< gslpp::complex > tmp_coeffsgammaNNLO = gslpp::vector<gslpp::complex>(6, 0.)
 
std::unique_ptr< EvolDF1nlep > u
 

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 (2, NDR, NLO, NLO_QED11), coeffdnunu (2, NDR, NLO, NLO_QED11),
24 coeffsgamma(8,NDR, NNLO),
25 coeffprimesgamma(8,NDR, NNLO),
26 coeffsgamma_Buras(8,NDR, NNLO),
27 coeffBMll (13,NDR, NLO),
28 coeffprimeBMll (13, NDR, NLO),
29 coeffBMll_Buras (8, NDR, NLO),
30 evolDF1BMll(new EvolDB1Mll(13, NDR, NLO, SM)),
31 evolDB1bsg(new EvolDB1bsg(8, NDR, NNLO, SM)),
32 u(new EvolDF1nlep(10, NDR, NLO, NLO_QED11, SM)),
33 evolbs(new EvolBsmm(8, NDR, NNLO, NLO_QED22, SM)), evolbd(new EvolBsmm(8, NDR, NNLO, NLO_QED22, SM)),
34 nlep(12, 0.), nlep2(10, 0.),
35 nlepCC(4, 0.)
36{
37
38 for (unsigned int i = 0; i < 6; i++) {
39 BMll_WC_cache.push_back(coeffBMll);
40 BMll_Mu_cache.push_back(0.);
41 }
42 BMll_mu_cache = 0.;
43 BMll_order_ini_cache = 0;
44
45 for (unsigned int i = 0; i < 6; i++) {
46 BMllprime_WC_cache.push_back(coeffprimeBMll);
47 BMllprime_Mu_cache.push_back(0.);
48 }
49 BMllprime_mu_cache = 0.;
50
51 for (unsigned int i = 0; i < 6; i++) {
52 Bsgamma_WC_cache.push_back(coeffsgamma);
53 Bsgamma_Mu_cache.push_back(0.);
54 }
55 Bsgamma_mu_cache = 0.;
56 Bsgamma_order_ini_cache = 0;
57
58 for (unsigned int i = 0; i < 6; i++) {
59 Bpsgamma_WC_cache.push_back(coeffsgamma);
60 Bpsgamma_Mu_cache.push_back(0.);
61 }
62
63 for (unsigned int i = 0; i < 6; i++) {
64 Bsmumu_WC_cache.push_back(coeffsmumu);
65 Bsmumu_Mu_cache.push_back(0.);
66 }
67 Bsmumu_mu_cache = 0.;
68
69 for (unsigned int i = 0; i < 6; i++) {
70 Bdmumu_WC_cache.push_back(coeffdmumu);
71 Bdmumu_Mu_cache.push_back(0.);
72 }
73 Bdmumu_mu_cache = 0.;
74
75 setMisiaktoBuras();
76}
NNLO
@ NNLO
Definition: OrderScheme.h:36
LO
@ LO
Definition: OrderScheme.h:34
NLO
@ NLO
Definition: OrderScheme.h:35
NDR
@ NDR
Definition: OrderScheme.h:21
NLO_QED11
@ NLO_QED11
Definition: OrderScheme.h:59
NLO_QED22
@ NLO_QED22
Definition: OrderScheme.h:63
EvolDF1nlep
Evolutor Class
Definition: EvolDF1nlep.h:16
HeffDB1::setMisiaktoBuras
void setMisiaktoBuras()
Definition: HeffDB1.cpp:1101
HeffDB1::coeffbtaunu
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:236
HeffDB1::Bsgamma_order_ini_cache
unsigned int Bsgamma_order_ini_cache
Definition: HeffDB1.h:251
HeffDB1::Bsgamma_WC_cache
std::vector< WilsonCoefficient > Bsgamma_WC_cache
Definition: HeffDB1.h:255
HeffDB1::coeffnlep11B
WilsonCoefficient coeffnlep11B
Definition: HeffDB1.h:234
HeffDB1::BMllprime_mu_cache
double BMllprime_mu_cache
Definition: HeffDB1.h:264
HeffDB1::BMll_mu_cache
double BMll_mu_cache
Definition: HeffDB1.h:258
HeffDB1::Bdmumu_Mu_cache
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:276
HeffDB1::BMllprime_Mu_cache
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:266
HeffDB1::coeffprimesgamma
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:238
HeffDB1::evolDB1bsg
std::unique_ptr< EvolDB1bsg > evolDB1bsg
Definition: HeffDB1.h:243
HeffDB1::coeffsmumu
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:235
HeffDB1::Bsmumu_WC_cache
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:272
HeffDB1::coeffBMll
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:240
HeffDB1::Bpsgamma_Mu_cache
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:254
HeffDB1::evolbs
std::unique_ptr< EvolBsmm > evolbs
Definition: HeffDB1.h:245
HeffDB1::evolDF1BMll
std::unique_ptr< EvolDB1Mll > evolDF1BMll
Definition: HeffDB1.h:242
HeffDB1::coeffnlep10qcd
WilsonCoefficient coeffnlep10qcd
Definition: HeffDB1.h:232
HeffDB1::evolbd
std::unique_ptr< EvolBsmm > evolbd
Definition: HeffDB1.h:246
HeffDB1::coeffsgamma
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:238
HeffDB1::Bdmumu_WC_cache
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:277
HeffDB1::nlep
gslpp::vector< gslpp::complex > nlep
Definition: HeffDB1.h:279
HeffDB1::coeffnlep01A
WilsonCoefficient coeffnlep01A
Definition: HeffDB1.h:233
HeffDB1::coeffsgamma_Buras
WilsonCoefficient coeffsgamma_Buras
Definition: HeffDB1.h:239
HeffDB1::Bsmumu_Mu_cache
std::vector< double > Bsmumu_Mu_cache
Definition: HeffDB1.h:271
HeffDB1::u
std::unique_ptr< EvolDF1nlep > u
Definition: HeffDB1.h:244
HeffDB1::coeffnlep10CC
WilsonCoefficient coeffnlep10CC
Definition: HeffDB1.h:234
HeffDB1::coeffnlep01
WilsonCoefficient coeffnlep01
Definition: HeffDB1.h:233
HeffDB1::Bsgamma_Mu_cache
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:253
HeffDB1::coeffnlep00
WilsonCoefficient coeffnlep00
Definition: HeffDB1.h:231
HeffDB1::coeffBMll_Buras
WilsonCoefficient coeffBMll_Buras
Definition: HeffDB1.h:241
HeffDB1::Bdmumu_mu_cache
double Bdmumu_mu_cache
Definition: HeffDB1.h:274
HeffDB1::coeffnlep11
WilsonCoefficient coeffnlep11
Definition: HeffDB1.h:234
HeffDB1::nlepCC
gslpp::vector< gslpp::complex > nlepCC
Definition: HeffDB1.h:279
HeffDB1::coeffnlep00qcd
WilsonCoefficient coeffnlep00qcd
Definition: HeffDB1.h:231
HeffDB1::coeffnlep01B
WilsonCoefficient coeffnlep01B
Definition: HeffDB1.h:233
HeffDB1::Bsgamma_mu_cache
double Bsgamma_mu_cache
Definition: HeffDB1.h:250
HeffDB1::model
const StandardModel & model
Definition: HeffDB1.h:229
HeffDB1::nlep2
gslpp::vector< gslpp::complex > nlep2
Definition: HeffDB1.h:279
HeffDB1::Bsmumu_mu_cache
double Bsmumu_mu_cache
Definition: HeffDB1.h:269
HeffDB1::coeffnlep00CC
WilsonCoefficient coeffnlep00CC
Definition: HeffDB1.h:233
HeffDB1::coeffnlep10
WilsonCoefficient coeffnlep10
Definition: HeffDB1.h:232
HeffDB1::coeffdmumu
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:235
HeffDB1::coeffsnunu
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:237
HeffDB1::Bpsgamma_WC_cache
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:256
HeffDB1::BMllprime_WC_cache
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:267
HeffDB1::BMll_order_ini_cache
unsigned int BMll_order_ini_cache
Definition: HeffDB1.h:259
HeffDB1::BMll_WC_cache
std::vector< WilsonCoefficient > BMll_WC_cache
Definition: HeffDB1.h:262
HeffDB1::coeffdnunu
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:237
HeffDB1::BMll_Mu_cache
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:261
HeffDB1::coeffnlep11A
WilsonCoefficient coeffnlep11A
Definition: HeffDB1.h:234
HeffDB1::coeffprimeBMll
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:240

◆ ~HeffDB1()

HeffDB1::~HeffDB1 ( )
virtual

destructor

Definition at line 78 of file HeffDB1.cpp.

79{}

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

1051{
1052
1053 coeffBMll.setScheme(scheme);
1054 orders ordDF1 = coeffBMll.getOrder();
1055
1056 const std::vector<WilsonCoefficient>& mc = model.getMatching().CMBMll(lepton);
1057
1058 unsigned int order_ini;
1059 if (noSM) order_ini = 1;
1060 else order_ini = 0;
1061
1062 if (mu == BMll_mu_cache && scheme == BMll_scheme_cache && order_ini == BMll_order_ini_cache) {
1063 int check = 1;
1064 for (unsigned int i = order_ini; i < mc.size(); i++) {
1065 if (mc[i].getMu() == BMll_Mu_cache[i]) {
1066 for (int j = LO; j <= ordDF1; j++) {
1067 for (int k = LO; k <= j; k++) {
1068 for (int l = 0; l < 13; l++) {
1069 check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMll_WC_cache[i].getCoeff(orders(j - k))))(l));
1070 }
1071 }
1072 }
1073 } else check = 0;
1074 }
1075 if (check == 1) return coeffBMll.getCoeff();
1076 }
1077
1078 BMll_mu_cache = mu;
1079 BMll_order_ini_cache = order_ini;
1080 BMll_scheme_cache = scheme;
1081 BMll_WC_cache.clear();
1082 BMll_WC_cache = mc;
1083
1084 coeffBMll.setMu(mu);
1085
1086 for (unsigned int i = order_ini; i < mc.size(); i++) {
1087 BMll_Mu_cache[i] = mc[i].getMu();
1088 for (int j = LO; j <= ordDF1; j++) {
1089 for (int k = LO; k <= j; k++) {
1090 coeffBMll.setCoeff(*coeffBMll.getCoeff(orders(j)) +
1091 evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
1092 (*(mc[i].getCoeff(orders(j - k)))), orders(j));
1093 }
1094 }
1095 }
1096
1097 return coeffBMll.getCoeff();
1098}
HeffDB1::BMll_scheme_cache
schemes BMll_scheme_cache
Definition: HeffDB1.h:260
ModelMatching::CMBMll
virtual std::vector< WilsonCoefficient > & CMBMll(QCD::lepton lepton)=0
StandardModel::getMatching
virtual StandardModelMatching & getMatching() const
A get method to access the member reference of type StandardModelMatching.
Definition: StandardModel.h:965
WilsonCoefficient::getCoeff
gslpp::vector< gslpp::complex > ** getCoeff() const
Definition: WilsonCoefficient.h:29
WilsonCoefficient::setCoeff
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: WilsonCoefficient.h:34
WilsonTemplate::setScheme
void setScheme(schemes scheme)
Definition: WilsonTemplate.h:103
WilsonTemplate::setMu
virtual void setMu(double mu)
Definition: WilsonTemplate.h:92
WilsonTemplate::getOrder
orders getOrder() const
Definition: WilsonTemplate.h:65
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:33

◆ ComputeCoeffBMll_Buras()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffBMll_Buras ( 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, Buras basis pdf/hep-ph/9512380v1 (VI.33)

Definition at line 1132 of file HeffDB1.cpp.

1133{
1134 //compute coefficients in Misiak basis:
1135 ComputeCoeffBMll(mu, lepton, noSM, scheme);
1136 orders ordDF1 = coeffBMll_Buras.getOrder();
1137
1138 //LO change of basis for i=1-6
1139 for (unsigned int i = 0; i < 6; i++) {
1140 tmp_coeffBMllLO.assign(i, (*coeffBMll.getCoeff(LO))(i));
1141 }
1142 tmp_coeffBMll = R_inv_t * tmp_coeffBMllLO;
1143 for (unsigned int i = 0; i < 6; i++) {
1144 coeffBMll_Buras.setCoeff(i, tmp_coeffBMll(i), LO);
1145 }
1146 //NLO change of basis for i=1-6
1147 if (ordDF1 >= NLO) {
1148 //transformation matrix at O(a_s): Nuclear Physics B 520 (1998) 279-297, equation 58
1149 MisiaktoBurasNLO.assign(0, 0, - R_inv_t * model.Als(mu) / (4. * M_PI) * dR_t);
1150 for (unsigned int i = 0; i < 6; i++) {
1151 tmp_coeffBMllNLO.assign(i, (*coeffBMll.getCoeff(NLO))(i));
1152 }
1153 tmp_coeffBMll = MisiaktoBurasNLO * tmp_coeffBMllLO + R_inv_t * tmp_coeffBMllNLO;
1154 for (unsigned int i = 0; i < 6; i++) {
1155 coeffBMll_Buras.setCoeff(i, tmp_coeffBMll(i), NLO);
1156 }
1157 }
1158 //i=7,8 stay unchanged
1159 for (int order = LO; order <= ordDF1; order++) {
1160 coeffBMll_Buras.setCoeff(6, (*coeffBMll.getCoeff(orders(order)))(6), orders(order));
1161 coeffBMll_Buras.setCoeff(7, (*coeffBMll.getCoeff(orders(order)))(7), orders(order));
1162 }
1163 return coeffBMll_Buras.getCoeff();
1164}
HeffDB1::dR_t
gslpp::matrix< double > dR_t
Definition: HeffDB1.h:284
HeffDB1::tmp_coeffBMllNLO
gslpp::vector< gslpp::complex > tmp_coeffBMllNLO
Definition: HeffDB1.h:293
HeffDB1::ComputeCoeffBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffBMll(double mu, QCD::lepton lepton, bool noSM=false, schemes scheme=NDR)
Definition: HeffDB1.cpp:1050
HeffDB1::R_inv_t
gslpp::matrix< double > R_inv_t
Definition: HeffDB1.h:283
HeffDB1::tmp_coeffBMll
gslpp::vector< gslpp::complex > tmp_coeffBMll
Definition: HeffDB1.h:291
HeffDB1::tmp_coeffBMllLO
gslpp::vector< gslpp::complex > tmp_coeffBMllLO
Definition: HeffDB1.h:292
HeffDB1::MisiaktoBurasNLO
gslpp::matrix< double > MisiaktoBurasNLO
Definition: HeffDB1.h:285
StandardModel::Als
const double Als(const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
The running QCD coupling in the scheme including QED corrections.
Definition: StandardModel.h:1088

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

Definition at line 86 of file HeffDB1.cpp.

87{
88
89 const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbnlep( 0);
90 const std::vector<WilsonCoefficient>& mcbCC = model.getMatching().CMbnlepCC( 0);
91
92 coeffnlep00qcd.setMu(mu); //inizializes to zero the coefficients
93 coeffnlep00CC.setMu(mu);
94 coeffnlep00.setMu(mu);
95
96 orders_qed ordDF1ew = coeffnlep00.getOrder_qed();
97 orders ordDF1 = coeffnlep00.getOrder();
98
99 for (unsigned int i = 0; i < mcb.size(); i++){
100 for (int j = LO; j <= ordDF1; j++){
101 for (int k = LO; k <= j; k++) {
102
103 //Evolves the LO terms and the ones proportional to alpha_s
104 coeffnlep00qcd.setCoeff(*coeffnlep00qcd.getCoeff(orders(j)) +
105 u->Df1Evolnlep(mu, mcb[i].getMu(), orders(k), NO_QED, mcb[i].getScheme())*
106 (*(mcb[i].getCoeff(orders(j - k)))), orders(j));
107
108
109 //Evolves terms proportional to alpha_e and alpha_e/aplha_s
110 coeffnlep00qcd.setCoeff(*coeffnlep00qcd.getCoeff(orders_qed(j+4)) +
111 u->Df1Evolnlep(mu, mcb[i].getMu(), NNLO, orders_qed(k+4), mcb[i].getScheme()) *
112 (*(mcb[i].getCoeff(orders(j - k)))), orders_qed(j+4));
113
114
115 //Evolves the current*current part of the hamiltonian (the one non-proportional to lambda_t)
116 coeffnlep00CC.setCoeff(*coeffnlep00CC.getCoeff(orders(j)) +
117 u->Df1Evolnlep(mu, mcbCC[i].getMu(), orders(k), NO_QED, mcbCC[i].getScheme()) *
118 (*(mcbCC[i].getCoeff(orders(j - k)))), orders(j));
119
120 }
121 }
122
123 coeffnlep00qcd.setCoeff(*coeffnlep00qcd.getCoeff(orders_qed(NLO_QED11)) +
124 u->Df1Evolnlep(mu, mcb[i].getMu(), orders(LO), NO_QED, mcb[i].getScheme()) *
125 (*(mcb[i].getCoeff(orders_qed(NLO_QED11)))), orders_qed(NLO_QED11));
126
127 }
128
129 coeffnlep00qcd.setScheme(scheme);
130 coeffnlep00CC.setScheme(scheme);
131
132 //Puts all together in a wilson coefficient object of 12 component:
133 //the first 10 terms are the ones proportional to lambda_t
134 //the last two are the remainder current*current operators
135 for (int j=LO; j <= ordDF1; j++) {
136 nlep2 = *coeffnlep00qcd.getCoeff(orders(j));
137 for (int i = 0; i < 10; i++){
138 nlep.assign(i, nlep2(i));
139 }
140 nlep2 = *coeffnlep00CC.getCoeff(orders(j));
141 for (int i = 10; i < 12; i++){
142 nlep.assign(i, nlep2(i-10));
143 }
144 coeffnlep00.setCoeff(nlep, orders(j));
145 }
146 for (int k=LO_QED; k <= ordDF1ew; k++) {
147 nlep2 = *coeffnlep00qcd.getCoeff(orders_qed(k));
148 for (int l = 0; l < 10; l++){
149 nlep.assign(l, nlep2(l));;
150 }
151 coeffnlep00.setCoeff(nlep, orders_qed(k));
152 }
153
154 return coeffnlep00.getCoeff();
155}
LO_QED
@ LO_QED
Definition: OrderScheme.h:58
NO_QED
@ NO_QED
Definition: OrderScheme.h:57
ModelMatching::CMbnlep
virtual std::vector< WilsonCoefficient > & CMbnlep(int a)=0
ModelMatching::CMbnlepCC
virtual std::vector< WilsonCoefficient > & CMbnlepCC(const int a)=0
WilsonTemplate::getOrder_qed
orders_qed getOrder_qed() const
Definition: WilsonTemplate.h:70
orders_qed
orders_qed
An enum type for orders in electroweak.
Definition: OrderScheme.h:56

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

Definition at line 236 of file HeffDB1.cpp.

237{
238
239 const std::vector<WilsonCoefficient>& mcbCC1 =model.getMatching().CMbnlepCC( 2);
240 const std::vector<WilsonCoefficient>& mcbCC2 = model.getMatching().CMbnlepCC( 3);
241
242 coeffnlep01.setMu(mu);
243 coeffnlep01A.setMu(mu);
244 coeffnlep01B.setMu(mu);
245
246 orders ordDF1 = coeffnlep01A.getOrder();
247
248 //evolution of the current*current terms
249 for (unsigned int i = 0; i < mcbCC1.size(); i++)
250 for (int j = LO; j <= ordDF1; j++)
251 for (int k = LO; k <= j; k++){
252
253 coeffnlep01A.setCoeff(*coeffnlep01A.getCoeff(orders(j)) +
254 u->Df1Evolnlep(mu, mcbCC1[i].getMu(), orders(k), NO_QED, mcbCC1[i].getScheme()) *
255 (*(mcbCC1[i].getCoeff(orders(j - k)))), orders(j));
256
257 coeffnlep01B.setCoeff(*coeffnlep01B.getCoeff(orders(j)) +
258 u->Df1Evolnlep(mu, mcbCC2[i].getMu(), orders(k), NO_QED, mcbCC2[i].getScheme()) *
259 (*(mcbCC2[i].getCoeff(orders(j - k)))), orders(j));
260 }
261
262 coeffnlep01A.setScheme(scheme);
263 coeffnlep01B.setScheme(scheme);
264 coeffnlep01.setScheme(scheme);
265
266 //Puts all together in a wilson coefficient object of 4 components
267 for (int j=LO; j <= ordDF1; j++) {
268 nlep2 = *coeffnlep01A.getCoeff(orders(j));
269 for (int i = 0; i < 2; i++){
270 nlep.assign(i, nlep2(i));
271 }
272 nlep2 = *coeffnlep01A.getCoeff(orders(j));
273 for (int i = 2; i < 4; i++){
274 nlep.assign(i, nlep2(i-2));
275 }
276 coeffnlep01.setCoeff(nlep, orders(j));
277 }
278 return coeffnlep01.getCoeff();
279
280}

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

Definition at line 162 of file HeffDB1.cpp.

163{
164
165 const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbnlep( 1);
166 const std::vector<WilsonCoefficient>& mcbCC = model.getMatching().CMbnlepCC( 1);
167
168 coeffnlep10qcd.setMu(mu);
169 coeffnlep10CC.setMu(mu);
170 coeffnlep10.setMu(mu);
171
172 orders_qed ordDF1ew = coeffnlep10.getOrder_qed();
173 orders ordDF1 = coeffnlep10.getOrder();
174
175 for (unsigned int i = 0; i < mcb.size(); i++){
176 for (int j = LO; j <= ordDF1; j++){
177 for (int k = LO; k <= j; k++) {
178
179 //Evolves the LO terms and the ones proportional to alpha_s
180 coeffnlep10qcd.setCoeff(*coeffnlep10qcd.getCoeff(orders(j)) +
181 u->Df1Evolnlep(mu, mcb[i].getMu(), orders(k), NO_QED, mcb[i].getScheme()) *
182 (*(mcb[i].getCoeff(orders(j - k)))), orders(j));
183
184 //Evolves terms proportional to alpha_e and alpha_e/aplha_s
185 coeffnlep10qcd.setCoeff(*coeffnlep10qcd.getCoeff(orders_qed(j+4)) +
186 u->Df1Evolnlep(mu, mcb[i].getMu(), NNLO, orders_qed(k+4), mcb[i].getScheme()) *
187 (*(mcb[i].getCoeff(orders(j - k)))), orders_qed(j+4));
188
189 //Evolves the current*current part of the hamiltonian (the one non-proportional to lambda_t)
190 coeffnlep10CC.setCoeff(*coeffnlep10CC.getCoeff(orders(j)) +
191 u->Df1Evolnlep(mu, mcbCC[i].getMu(), orders(k), NO_QED, mcbCC[i].getScheme()) *
192 (*(mcbCC[i].getCoeff(orders(j - k)))), orders(j));
193
194 }
195 }
196
197 coeffnlep10qcd.setCoeff(*coeffnlep10qcd.getCoeff(orders_qed(NLO_QED11)) +
198 u->Df1Evolnlep(mu, mcb[i].getMu(), orders(LO), NO_QED, mcb[i].getScheme()) *
199 (*(mcb[i].getCoeff(orders(LO_QED)))), orders_qed(NLO_QED11));
200 }
201
202 coeffnlep10qcd.setScheme(scheme);
203 coeffnlep10CC.setScheme(scheme);
204
205 //Puts all together in a wilson coefficient object of 12 component:
206 //the first 10 terms are the one proportional to lambda_t
207 //the last two are the remainder current*current operators
208
209 for (int j=LO; j <= ordDF1; j++) {
210 nlep2 = *coeffnlep10qcd.getCoeff(orders(j));
211 for (int i = 0; i < 10; i++){
212 nlep.assign(i, nlep2(i));
213 }
214 nlep2 = *coeffnlep10CC.getCoeff(orders(j));
215 for (int i = 10; i < 12; i++){
216 nlep.assign(i, nlep2(i-10));
217 }
218 coeffnlep10.setCoeff(nlep, orders(j));
219 }
220 for (int k=LO_QED; k <= ordDF1ew; k++) {
221 nlep2 = *coeffnlep10qcd.getCoeff(orders_qed(k));
222 for (int l = 0; l < 10; l++){
223 nlep.assign(l, nlep2(l));;
224 }
225 coeffnlep10.setCoeff(nlep, orders_qed(k));
226 }
227
228 return coeffnlep10.getCoeff();
229}

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

Definition at line 287 of file HeffDB1.cpp.

288{
289
290 const std::vector<WilsonCoefficient>& mcbCC1 = model.getMatching().CMbnlepCC( 2);
291 const std::vector<WilsonCoefficient>& mcbCC2 = model.getMatching().CMbnlepCC( 3);
292
293 coeffnlep11.setMu(mu);
294 coeffnlep11A.setMu(mu);
295 coeffnlep11B.setMu(mu);
296
297 orders ordDF1 = coeffnlep11A.getOrder();
298
299 for (unsigned int i = 0; i < mcbCC1.size(); i++)
300 for (int j = LO; j <= ordDF1; j++)
301 for (int k = LO; k <= j; k++){
302
303 coeffnlep11A.setCoeff(*coeffnlep11A.getCoeff(orders(j)) +
304 u->Df1Evolnlep(mu, mcbCC1[i].getMu(), orders(k), NO_QED, mcbCC1[i].getScheme()) *
305 (*(mcbCC1[i].getCoeff(orders(j - k)))), orders(j));
306
307 coeffnlep11B.setCoeff(*coeffnlep11B.getCoeff(orders(j)) +
308 u->Df1Evolnlep(mu, mcbCC2[i].getMu(), orders(k), NO_QED, mcbCC2[i].getScheme()) *
309 (*(mcbCC2[i].getCoeff(orders(j - k)))), orders(j));
310 }
311
312 coeffnlep11A.setScheme(scheme);
313 coeffnlep11B.setScheme(scheme);
314 coeffnlep11.setScheme(scheme);
315
316 for (int j=LO; j <= ordDF1; j++) {
317 nlep2 = *coeffnlep11A.getCoeff(orders(j));
318 for (int i = 0; i < 2; i++){
319 nlep.assign(i, nlep2(i));
320 }
321 nlep2 = *coeffnlep11A.getCoeff(orders(j));
322 for (int i = 2; i < 4; i++){
323 nlep.assign(i, nlep2(i-2));
324 }
325 coeffnlep11.setCoeff(nlep, orders(j));
326 }
327 return coeffnlep11.getCoeff();
328
329}

◆ ComputeCoeffbtaunu()

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

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

676{
677
678 coeffdmumu.setScheme(scheme);
679 orders ordDF1 = coeffdmumu.getOrder();
680 orders_qed ordDF1ew = coeffdmumu.getOrder_qed();
681
682 const std::vector<WilsonCoefficient>& mcbdm = model.getMatching().CMbdmm();
683
684 if (mu == Bdmumu_mu_cache && scheme == Bdmumu_scheme_cache) {
685 int check = 1;
686 for (unsigned int i = 0; i < mcbdm.size(); i++) {
687 if (mcbdm[i].getMu() == Bdmumu_Mu_cache[i]) {
688 for (int j = LO; j <= ordDF1; j++) {
689 for (int k = LO; k <= j; k++) {
690 for (int l = 0; l < 8; l++) {
691 check *= ((*(mcbdm[i].getCoeff(orders(j - k))))(l) == (*(Bdmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
692 }
693 }
694 }
695 } else check = 0;
696 }
697 if (check == 1) return coeffdmumu.getCoeff();
698 }
699
700 double nf = 5; //al the process has nf = 5, also the evolutor
701
702 //int L = 6 - (int) nf;
703 int j = 0;
704 double alsM = evolbd->alphatilde_s(mcbdm[0].getMu());
705 double alsmu = evolbd->alphatilde_s(mu);
706 double eta = alsM / alsmu;
707
708 double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
709
710 double B00E = 80./9., B01E = 176./9.;
711
712 double logeta = log(eta);
713 double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
714 double app = B00E * (1. - eta)/ B00S;
715
716 Bdmumu_mu_cache = mu;
717 Bdmumu_scheme_cache = scheme;
718 Bdmumu_WC_cache.clear();
719 Bdmumu_WC_cache = mcbdm;
720
721 coeffdmumu.setMu(mu);
722
723 for (unsigned int i = 0; i < mcbdm.size(); i++){
724 Bdmumu_Mu_cache[i] = mcbdm[i].getMu();
725 for (j = LO; j <= ordDF1; j++){
726 for (int k = LO; k <= j; k++){
727 if ((k <= NNLO) && (j <= NNLO)){
728 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders(j)) + pow(eta,j) *
729 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(k), NO_QED, mcbdm[i].getScheme()) *
730 (*(mcbdm[i].getCoeff(orders(j - k)))), orders(j));
731 }
732 }
733 }
734
735 for (j = LO_QED; j <= ordDF1ew; j++){
736
737 switch(j) {
738
739 case(NLO_QED22):
740
741 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) +
742 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
743 (*(mcbdm[i].getCoeff(orders_qed(NLO_QED22)))) +
744 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbdm[i].getScheme()) *
745 (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
746 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
747 (*(mcbdm[i].getCoeff(orders(LO)))) +
748 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
749 (*(mcbdm[i].getCoeff(orders_qed(NLO_QED21)))) +
750 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbdm[i].getScheme()) *
751 (*(mcbdm[i].getCoeff(orders(NNLO)))) +
752 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbdm[i].getScheme()) *
753 (*(mcbdm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
754 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
755 (*(mcbdm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
756 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
757 (*(mcbdm[i].getCoeff(orders(NNLO)))) +
758 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
759 (*(mcbdm[i].getCoeff(orders(LO)))) +
760 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
761 (*(mcbdm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
762 * app *
763 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
764 (*(mcbdm[i].getCoeff(orders(NLO)))) +
765 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
766 (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
767
768 break;
769
770 case(NLO_QED12):
771
772 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ eta) *
773 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
774 (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
775 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbdm[i].getScheme()) *
776 (*(mcbdm[i].getCoeff(orders(NLO)))) +
777 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
778 (*(mcbdm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
779 * app *
780 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
781 (*(mcbdm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
782 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
783 (*(mcbdm[i].getCoeff(orders(NLO)))) +
784 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
785 (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
786
787 break;
788
789 case(NLO_QED21):
790
791 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + eta *
792 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
793 (*(mcbdm[i].getCoeff(orders_qed(j)))) +
794 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
795 (*(mcbdm[i].getCoeff(orders_qed(NLO_QED11)))) +
796 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbdm[i].getScheme()) *
797 (*(mcbdm[i].getCoeff(orders(NLO)))) +
798 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
799 (*(mcbdm[i].getCoeff(orders(LO)))) +
800 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
801 (*(mcbdm[i].getCoeff(orders(NNLO)))))-
802 eta * logeta * fatt *
803 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
804 (*(mcbdm[i].getCoeff(orders(NLO)))) +
805 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
806 (*(mcbdm[i].getCoeff(orders(LO)))))
807 - eta * app *
808 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
809 (*(mcbdm[i].getCoeff(orders(NNLO)))) +
810 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NNLO), NO_QED, mcbdm[i].getScheme()) *
811 (*(mcbdm[i].getCoeff(orders(LO)))) +
812 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
813 (*(mcbdm[i].getCoeff(orders(NLO)))) ), orders_qed(j));
814
815 break;
816
817 case(NLO_QED02):
818
819 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,2)) *
820 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
821 (*(mcbdm[i].getCoeff(orders(LO)))) + ( app
822 * app/(eta * eta ) ) *
823 evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
824 (*(mcbdm[i].getCoeff(orders(LO)))), orders_qed(j));
825
826 break;
827
828 case(NLO_QED11):
829
830 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) +
831 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
832 (*(mcbdm[i].getCoeff(orders(LO)))) +
833 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
834 (*(mcbdm[i].getCoeff(orders_qed(j)))) +
835 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(LO_QED), mcbdm[i].getScheme()) *
836 (*(mcbdm[i].getCoeff(orders(NLO)))) - logeta * fatt *
837 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NO_QED, mcbdm[i].getScheme()) *
838 (*(mcbdm[i].getCoeff(orders(LO))))) - app *
839 (evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
840 (*(mcbdm[i].getCoeff(orders(NLO)))) +
841 evolbd->Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NO_QED, mcbdm[i].getScheme()) *
842 (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
843
844
845 break;
846
847 case(LO_QED):
848
849 coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,1)) *
850 evolbd->Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_qed(j), mcbdm[i].getScheme()) *
851 (*(mcbdm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
852 ( evolbd->Df1Evol(mu, mcbdm[i].getMu(), LO, orders_qed(NO_QED), mcbdm[i].getScheme()) *
853 (*(mcbdm[i].getCoeff(orders(LO))))), orders_qed(j));
854
855
856
857 break;
858 }
859 }
860 }
861 return coeffdmumu.getCoeff();
862}
NLO_QED02
@ NLO_QED02
Definition: OrderScheme.h:61
NLO_QED12
@ NLO_QED12
Definition: OrderScheme.h:62
NLO_QED21
@ NLO_QED21
Definition: OrderScheme.h:60
HeffDB1::Bdmumu_scheme_cache
schemes Bdmumu_scheme_cache
Definition: HeffDB1.h:275
QCD::Beta1
const double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:606
QCD::Beta0
const double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:601

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

890{
891
892 const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXdnn();
893
894 orders ordDF1 = coeffdnunu.getOrder();
895 orders_qed ordDF1_ew = coeffdnunu.getOrder_qed();
896
897 for (unsigned int i = 0; i < mcb.size(); i++){
898 for (int j = LO; j <= ordDF1; j++){
899 coeffdnunu.setCoeff(*mcb[i].getCoeff(orders(j)), orders(j));
900 }
901 for (int j = LO_QED; j <= ordDF1_ew; j++) {
902 coeffdnunu.setCoeff(*mcb[i].getCoeff(orders_qed(j)), orders_qed(j));
903 }
904 }
905
906 return coeffdnunu.getCoeff();
907}

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

1168{
1169
1170 coeffprimeBMll.setScheme(scheme);
1171 orders ordDF1 = coeffprimeBMll.getOrder();
1172
1173 const std::vector<WilsonCoefficient>& mc = model.getMatching().CMprimeBMll(lepton);
1174
1175 if (mu == BMllprime_mu_cache && scheme == BMllprime_scheme_cache) {
1176 int check = 1;
1177 for (unsigned int i = 0; i < mc.size(); i++) {
1178 if (mc[i].getMu() == BMllprime_Mu_cache[i]) {
1179 for (int j = LO; j <= ordDF1; j++) {
1180 for (int k = LO; k <= j; k++) {
1181 for (int l = 0; l < 13; l++) {
1182 check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMllprime_WC_cache[i].getCoeff(orders(j - k))))(l));
1183 }
1184 }
1185 }
1186 } else check = 0;
1187 }
1188 if (check == 1) return coeffprimeBMll.getCoeff();
1189 }
1190
1191 BMllprime_mu_cache = mu;
1192 BMllprime_scheme_cache = scheme;
1193 BMllprime_WC_cache.clear();
1194 BMllprime_WC_cache = mc;
1195
1196 coeffprimeBMll.setMu(mu);
1197
1198 for (unsigned int i = 0; i < mc.size(); i++){
1199 BMllprime_Mu_cache[i] = mc[i].getMu();
1200 for (int j = LO; j <= ordDF1; j++){
1201 for (int k = LO; k <= j; k++){
1202 coeffprimeBMll.setCoeff(*coeffprimeBMll.getCoeff(orders(j)) +
1203 evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
1204 (*(mc[i].getCoeff(orders(j - k)))), orders(j));
1205 }
1206 }
1207 }
1208
1209
1210 return coeffprimeBMll.getCoeff();
1211}
HeffDB1::BMllprime_scheme_cache
schemes BMllprime_scheme_cache
Definition: HeffDB1.h:265
ModelMatching::CMprimeBMll
virtual std::vector< WilsonCoefficient > & CMprimeBMll(QCD::lepton lepton)=0

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

1006{
1007
1008 coeffprimesgamma.setScheme(scheme);
1009 orders ordDF1 = coeffprimesgamma.getOrder();
1010
1011 const std::vector<WilsonCoefficient>& mcbsgp = model.getMatching().CMprimebsg();
1012
1013 if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
1014 int check = 1;
1015 for (unsigned int i = 0; i < mcbsgp.size(); i++) {
1016 if (mcbsgp[i].getMu() == Bpsgamma_Mu_cache[i]) {
1017 for (int j = LO; j <= ordDF1; j++) {
1018 for (int k = LO; k <= j; k++) {
1019 for (int l = 0; l < 8; l++) {
1020 check *= ((*(mcbsgp[i].getCoeff(orders(j - k))))(l) == (*(Bpsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
1021 }
1022 }
1023 }
1024 } else check = 0;
1025 }
1026 if (check == 1) return coeffprimesgamma.getCoeff();
1027 }
1028
1029 Bsgamma_mu_cache = mu;
1030 Bsgamma_scheme_cache = scheme;
1031 Bpsgamma_WC_cache.clear();
1032 Bpsgamma_WC_cache = mcbsgp;
1033
1034 coeffprimesgamma.setMu(mu);
1035
1036 for (unsigned int i = 0; i < mcbsgp.size(); i++){
1037 Bpsgamma_Mu_cache[i] = mcbsgp[i].getMu();
1038 for (int j = LO; j <= ordDF1; j++){
1039 for (int k = LO; k <= j; k++){
1040 coeffprimesgamma.setCoeff(*coeffprimesgamma.getCoeff(orders(j)) +
1041 evolDB1bsg->Df1Evolbsg(mu, mcbsgp[i].getMu(), orders(k), mcbsgp[i].getScheme()) *
1042 (*(mcbsgp[i].getCoeff(orders(j - k)))), orders(j));
1043 }
1044 }
1045 }
1046
1047 return coeffprimesgamma.getCoeff();
1048}
HeffDB1::Bsgamma_scheme_cache
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:252
ModelMatching::CMprimebsg
virtual std::vector< WilsonCoefficient > & CMprimebsg()=0

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

910{
911 coeffsgamma.setScheme(scheme);
912 orders ordDF1 = coeffsgamma.getOrder();
913
914 unsigned int order_ini;
915 if (noSM) order_ini = 1;
916 else order_ini = 0;
917
918 const std::vector<WilsonCoefficient>& mcbsg = model.getMatching().CMbsg();
919
920 if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache && order_ini == Bsgamma_order_ini_cache) {
921 int check = 1;
922 for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
923 if (mcbsg[i].getMu() == Bsgamma_Mu_cache[i]) {
924 for (int j = LO; j <= ordDF1; j++) {
925 for (int k = LO; k <= j; k++) {
926 for (int l = 0; l < 8; l++) {
927 check *= ((*(mcbsg[i].getCoeff(orders(j - k))))(l) == (*(Bsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
928 }
929 }
930 }
931 } else check = 0;
932 }
933 if (check == 1) return coeffsgamma.getCoeff();
934 }
935
936 Bsgamma_mu_cache = mu;
937 Bsgamma_order_ini_cache = order_ini;
938 Bsgamma_scheme_cache = scheme;
939 Bsgamma_WC_cache.clear();
940 Bsgamma_WC_cache = mcbsg;
941
942 coeffsgamma.setMu(mu);
943
944 for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
945 Bsgamma_Mu_cache[i] = mcbsg[i].getMu();
946 for (int j = LO; j <= ordDF1; j++) {
947 for (int k = LO; k <= j; k++) {
948 coeffsgamma.setCoeff(*coeffsgamma.getCoeff(orders(j)) +
949 evolDB1bsg->Df1Evolbsg(mu, mcbsg[i].getMu(), orders(k), mcbsg[i].getScheme()) *
950 (*(mcbsg[i].getCoeff(orders(j - k)))), orders(j));
951 }
952 }
953 }
954
955 return coeffsgamma.getCoeff();
956}
ModelMatching::CMbsg
virtual std::vector< WilsonCoefficient > & CMbsg()=0

◆ ComputeCoeffsgamma_Buras()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsgamma_Buras ( 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 \), Buras basis pdf/hep-ph/9512380v1 (VI.33)

Definition at line 958 of file HeffDB1.cpp.

959{
960 //compute coefficients in Misiak basis:
961 ComputeCoeffsgamma(mu, noSM, scheme);
962 orders ordDF1 = coeffsgamma_Buras.getOrder();
963
964 //LO change of basis for i=1-6
965 for (unsigned int i = 0; i < 6; i++) {
966 tmp_coeffsgammaLO.assign(i, (*coeffsgamma.getCoeff(LO))(i));
967 }
968 tmp_coeffsgamma = R_inv_t * tmp_coeffsgammaLO;
969 for (unsigned int i = 0; i < 6; i++) {
970 coeffsgamma_Buras.setCoeff(i, tmp_coeffsgamma(i), LO);
971 }
972 //NLO change of basis for i=1-6
973 if (ordDF1 >= NLO) {
974 //transformation matrix at O(a_s): Nuclear Physics B 520 (1998) 279-297, equation 58
975 MisiaktoBurasNLO.assign(0, 0, - R_inv_t * model.Als(mu) / (4. * M_PI) * dR_t);
976 for (unsigned int i = 0; i < 6; i++) {
977 tmp_coeffsgammaNLO.assign(i, (*coeffsgamma.getCoeff(NLO))(i));
978 }
979 tmp_coeffsgamma = MisiaktoBurasNLO * tmp_coeffsgammaLO + R_inv_t * tmp_coeffsgammaNLO;
980 for (unsigned int i = 0; i < 6; i++) {
981 coeffsgamma_Buras.setCoeff(i, tmp_coeffsgamma(i), NLO);
982 }
983 //NLO change of basis for i=1-6
984 if (ordDF1 >= NNLO) {
985 for (unsigned int i = 0; i < 6; i++) {
986 tmp_coeffsgammaNNLO.assign(i, (*coeffsgamma.getCoeff(NNLO))(i));
987 }
988 tmp_coeffsgamma = MisiaktoBurasNLO * tmp_coeffsgammaNLO + R_inv_t * tmp_coeffsgammaNNLO;
989 //Gerlach phd thesis (2.50)
990 tmp_coeffsgamma.assign(0, tmp_coeffsgamma(0) + model.Als(mu) * model.Als(mu) / (16. * M_PI * M_PI) * tmp_coeffsgammaLO(0) * 81. / (40. * 5.));
991 tmp_coeffsgamma.assign(1, tmp_coeffsgamma(1) + model.Als(mu) * model.Als(mu) / (16. * M_PI * M_PI) * (tmp_coeffsgammaLO(0) * 9. / (10. * 5.) + tmp_coeffsgammaLO(1) * -189. / (80. * 5.)));
992 for (unsigned int i = 0; i < 6; i++) {
993 coeffsgamma_Buras.setCoeff(i, tmp_coeffsgamma(i), NNLO);
994 }
995 }
996 }
997 //i=7,8 stay unchanged
998 for (int order = LO; order <= ordDF1; order++) {
999 coeffsgamma_Buras.setCoeff(6, (*coeffsgamma.getCoeff(orders(order)))(6), orders(order));
1000 coeffsgamma_Buras.setCoeff(7, (*coeffsgamma.getCoeff(orders(order)))(7), orders(order));
1001 }
1002 return coeffsgamma_Buras.getCoeff();
1003}
HeffDB1::tmp_coeffsgammaNNLO
gslpp::vector< gslpp::complex > tmp_coeffsgammaNNLO
Definition: HeffDB1.h:290
HeffDB1::tmp_coeffsgamma
gslpp::vector< gslpp::complex > tmp_coeffsgamma
Definition: HeffDB1.h:287
HeffDB1::tmp_coeffsgammaNLO
gslpp::vector< gslpp::complex > tmp_coeffsgammaNLO
Definition: HeffDB1.h:289
HeffDB1::tmp_coeffsgammaLO
gslpp::vector< gslpp::complex > tmp_coeffsgammaLO
Definition: HeffDB1.h:288
HeffDB1::ComputeCoeffsgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma(double mu, bool noSM=false, schemes scheme=NDR)
Definition: HeffDB1.cpp:909

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

332{
333
334
335 coeffsmumu.setScheme(scheme);
336 orders ordDF1 = coeffsmumu.getOrder();
337 orders_qed ordDF1ew = coeffsmumu.getOrder_qed();
338
339 const std::vector<WilsonCoefficient>& mcbsm = model.getMatching().CMbsmm();
340
341 if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
342 int check = 1;
343 for (unsigned int i = 0; i < mcbsm.size(); i++) {
344 if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
345 for (int j = LO; j <= ordDF1; j++) {
346 for (int k = LO; k <= j; k++) {
347 for (int l = 0; l < 8; l++) {
348 check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
349 }
350 }
351 }
352 } else check = 0;
353 }
354 if (check == 1) return coeffsmumu.getCoeff();
355 }
356
357 double nf = 5; //al the process has nf = 5, also the evolutor
358
359 //int L = 6 - (int) nf;
360 int j = 0;
361 double alsM = evolbs->alphatilde_s(mcbsm[0].getMu());
362 double alsmu = evolbs->alphatilde_s(mu);
363 double eta = alsM / alsmu;
364
365 double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
366
367 double B00E = 80./9., B01E = 176./9.;
368
369 double logeta = log(eta);
370 double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
371 double app = B00E * (1. - eta)/ B00S;
372
373 Bsmumu_mu_cache = mu;
374 Bsmumu_scheme_cache = scheme;
375 Bsmumu_WC_cache.clear();
376 Bsmumu_WC_cache = mcbsm;
377
378 coeffsmumu.setMu(mu);
379
380 for (unsigned int i = 0; i < mcbsm.size(); i++){
381 Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
382 for (j = LO; j <= ordDF1; j++){
383 for (int k = LO; k <= j; k++){
384 if ((k <= NNLO) && (j <= NNLO)){
385 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
386 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(k), NO_QED, mcbsm[i].getScheme()) *
387 (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
388 }
389 }
390 }
391
392 for (j = LO_QED; j <= ordDF1ew; j++){
393
394 switch(j) {
395
396 case(NLO_QED22):
397
398 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
399 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
400 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED22)))) +
401 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
402 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
403 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), 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_qed(NLO_QED21)))) +
407 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
408 (*(mcbsm[i].getCoeff(orders(NNLO)))) +
409 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
410 (*(mcbsm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
411 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
412 (*(mcbsm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
413 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
414 (*(mcbsm[i].getCoeff(orders(NNLO)))) +
415 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
416 (*(mcbsm[i].getCoeff(orders(LO)))) +
417 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
418 (*(mcbsm[i].getCoeff(orders(NLO)))) )+ logeta * fatt
419 * app *
420 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
421 (*(mcbsm[i].getCoeff(orders(NLO)))) +
422 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
423 (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
424
425 break;
426
427 case(NLO_QED12):
428
429 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ eta) *
430 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
431 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
432 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
433 (*(mcbsm[i].getCoeff(orders(NLO)))) +
434 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
435 (*(mcbsm[i].getCoeff(orders(LO))))) + ((logeta/eta) * fatt)
436 * app *
437 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
438 (*(mcbsm[i].getCoeff(orders(LO))))) + ( app * app/( eta) ) *
439 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
440 (*(mcbsm[i].getCoeff(orders(NLO)))) +
441 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
442 (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
443
444 break;
445
446 case(NLO_QED21):
447
448 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + eta *
449 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
450 (*(mcbsm[i].getCoeff(orders_qed(j)))) +
451 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
452 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
453 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
454 (*(mcbsm[i].getCoeff(orders(NLO)))) +
455 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
456 (*(mcbsm[i].getCoeff(orders(LO)))) +
457 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
458 (*(mcbsm[i].getCoeff(orders(NNLO)))))-
459 eta * logeta * fatt *
460 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
461 (*(mcbsm[i].getCoeff(orders(NLO)))) +
462 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
463 (*(mcbsm[i].getCoeff(orders(LO)))))
464 - eta * app *
465 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
466 (*(mcbsm[i].getCoeff(orders(NNLO)))) +
467 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NNLO), NO_QED, mcbsm[i].getScheme()) *
468 (*(mcbsm[i].getCoeff(orders(LO)))) +
469 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
470 (*(mcbsm[i].getCoeff(orders(NLO)))) ), orders_qed(j));
471
472 break;
473
474 case(NLO_QED02):
475
476 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,2)) *
477 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
478 (*(mcbsm[i].getCoeff(orders(LO)))) + ( app
479 * app/( eta * eta ) ) *
480 evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
481 (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
482
483 break;
484
485 case(NLO_QED11):
486
487 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
488 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
489 (*(mcbsm[i].getCoeff(orders(LO)))) +
490 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
491 (*(mcbsm[i].getCoeff(orders_qed(j)))) +
492 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
493 (*(mcbsm[i].getCoeff(orders(NLO)))) - logeta * fatt *
494 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
495 (*(mcbsm[i].getCoeff(orders(LO))))) - app *
496 (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
497 (*(mcbsm[i].getCoeff(orders(NLO)))) +
498 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
499 (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
500
501
502 break;
503
504 case(LO_QED):
505
506 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) + (1./ pow(eta,1)) *
507 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
508 (*(mcbsm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
509 ( evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
510 (*(mcbsm[i].getCoeff(orders(LO))))), orders_qed(j));
511
512
513
514 break;
515 }
516 }
517 }
518 return coeffsmumu.getCoeff();
519}
HeffDB1::Bsmumu_scheme_cache
schemes Bsmumu_scheme_cache
Definition: HeffDB1.h:270

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

523{
524 coeffsmumu.setScheme(scheme);
525 orders ordDF1 = coeffsmumu.getOrder();
526 orders_qed ordDF1ew = coeffsmumu.getOrder_qed();
527 const std::vector<WilsonCoefficient>& mcbsm = model.getMatching().CMbsmm();
528
529 if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
530 int check = 1;
531 for (unsigned int i = 0; i < mcbsm.size(); i++) {
532 if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
533 for (int j = LO; j <= ordDF1; j++) {
534 for (int k = LO; k <= j; k++) {
535 for (int l = 0; l < 8; l++) {
536 check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
537 }
538 }
539 }
540 } else check = 0;
541 }
542 if (check == 1) return coeffsmumu.getCoeff();
543 }
544 double nf = 5; //al the process has nf = 5, also the evolutor
545 //int L = 6 - (int) nf;
546 int j = 0;
547 double alsM = evolbs->alphatilde_s(mcbsm[0].getMu());
548 double alsmu = evolbs->alphatilde_s(mu);
549 double eta = alsM / alsmu;
550
551 double B00S = model.Beta0(nf), B10S = model.Beta1(nf);
552
553 double B00E = 80./9., B01E = 176./9.;
554
555 double logeta = log(eta);
556 double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
557 double app = B00E * (1. - eta)/ B00S;
558
559 Bsmumu_mu_cache = mu;
560 Bsmumu_scheme_cache = scheme;
561 Bsmumu_WC_cache.clear();
562 Bsmumu_WC_cache = mcbsm;
563
564 coeffsmumu.setMu(mu);
565
566 for (unsigned int i = 0; i < mcbsm.size(); i++){
567 Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
568 for (j = LO; j <= ordDF1; j++){
569 for (int k = LO; k <= j; k++){
570 if ((k <= NNLO) && (j <= NNLO)){
571 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
572 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(k), NO_QED, mcbsm[i].getScheme()) *
573 (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
574 }
575 }
576 }
577
578 for (j = LO_QED; j <= ordDF1ew; j++){
579
580 switch(j) {
581
582 case(NLO_QED22):
583 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
584 evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
585 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED22)))) +
586 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
587 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
588 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED22), mcbsm[i].getScheme()) *
589 (*(mcbsm[i].getCoeff(orders(LO)))) +
590 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
591 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
592 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
593 (*(mcbsm[i].getCoeff(orders(NNLO)))) +
594 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
595 (*(mcbsm[i].getCoeff(orders(NLO)))) +
596 logeta*fatt * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
597 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
598 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
599 (*(mcbsm[i].getCoeff(orders(LO)))) +
600 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
601 (*(mcbsm[i].getCoeff(orders(NLO))))) +
602 app * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), LO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
603 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
604 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_qed(NO_QED), mcbsm[i].getScheme()) *
605 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
606 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
607 (*(mcbsm[i].getCoeff(orders(NLO)))) +
608 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED21), mcbsm[i].getScheme()) *
609 (*(mcbsm[i].getCoeff(orders(LO)))) +
610 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
611 (*(mcbsm[i].getCoeff(orders(NNLO))))), orders_qed(j));
612 break;
613
614 case(NLO_QED21):
615 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
616 eta * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
617 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED21)))) +
618 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NO_QED, mcbsm[i].getScheme()) *
619 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
620 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
621 (*(mcbsm[i].getCoeff(orders(NLO)))) +
622 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED21), mcbsm[i].getScheme()) *
623 (*(mcbsm[i].getCoeff(orders(LO)))) +
624 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
625 (*(mcbsm[i].getCoeff(orders(NNLO))))), orders_qed(j));
626 break;
627
628 case(NLO_QED12):
629 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
630 (1./eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
631 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
632 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
633 (*(mcbsm[i].getCoeff(orders(NLO)))) +
634 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED12), mcbsm[i].getScheme()) *
635 (*(mcbsm[i].getCoeff(orders(LO))))) +
636 (logeta*fatt/eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
637 (*(mcbsm[i].getCoeff(orders(LO))))) +
638 (app/eta) * (evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
639 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
640 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
641 (*(mcbsm[i].getCoeff(orders(LO)))) +
642 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
643 (*(mcbsm[i].getCoeff(orders(NLO))))), orders_qed(j));
644 break;
645
646 case(NLO_QED02):
647 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
648 (1./ pow(eta,2)) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED02), mcbsm[i].getScheme()) *
649 (*(mcbsm[i].getCoeff(orders(LO)))) +
650 (app/(eta*eta)) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
651 (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
652 break;
653
654 case(NLO_QED11):
655 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
656 evolbs->Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NO_QED, mcbsm[i].getScheme()) *
657 (*(mcbsm[i].getCoeff(orders_qed(NLO_QED11)))) +
658 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(NLO_QED11), mcbsm[i].getScheme()) *
659 (*(mcbsm[i].getCoeff(orders(LO)))) +
660 evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(LO_QED), mcbsm[i].getScheme()) *
661 (*(mcbsm[i].getCoeff(orders(NLO)))), orders_qed(j));
662 break;
663
664 case(LO_QED):
665 coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_qed(j)) +
666 (1./ eta) * evolbs->Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_qed(j), mcbsm[i].getScheme()) *
667 (*(mcbsm[i].getCoeff(orders(LO)))), orders_qed(j));
668 break;
669 }
670 }
671 }
672 return coeffsmumu.getCoeff();
673}

◆ ComputeCoeffsnunu()

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsnunu ( QCD::lepton  lepton,
bool  noSM = false 
)
Parameters
scheme
Returns
short distance contribution to the rare decay \( B_{s} \rightarrow \nu \bar{\nu} \)

Definition at line 864 of file HeffDB1.cpp.

865{
866
867 const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXsnn(lepton);
868
869 coeffsnunu.resetCoefficient();
870 orders ordDF1 = coeffsnunu.getOrder();
871 orders_qed ordDF1_ew = coeffsnunu.getOrder_qed();
872
873 unsigned int order_ini;
874 if (noSM) order_ini = 1;
875 else order_ini = 0;
876
877 for (unsigned int i = order_ini; i < mcb.size(); i++){
878 for (int j = LO; j <= ordDF1; j++){
879 coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders(j)) + *mcb[i].getCoeff(orders(j)), orders(j));
880 }
881 for (int j = LO_QED; j <= ordDF1_ew; j++) {
882 coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders_qed(j)) + *mcb[i].getCoeff(orders_qed(j)), orders_qed(j));
883 }
884 }
885
886 return coeffsnunu.getCoeff();
887}
ModelMatching::CMBXsnn
virtual std::vector< WilsonCoefficient > & CMBXsnn(QCD::lepton lepton)=0
WilsonTemplate::resetCoefficient
virtual void resetCoefficient()
Definition: WilsonTemplate.h:80

◆ getCoeffbtaunu()

WilsonCoefficient HeffDB1::getCoeffbtaunu ( ) const
inline

Definition at line 184 of file HeffDB1.h.

184 {
185 return coeffbtaunu;
186 }

◆ getCoeffdmumu()

WilsonCoefficient HeffDB1::getCoeffdmumu ( ) const
inline

Definition at line 180 of file HeffDB1.h.

180 {
181 return coeffdmumu;
182 }

◆ getCoeffdnunu()

WilsonCoefficient HeffDB1::getCoeffdnunu ( ) const
inline

Definition at line 192 of file HeffDB1.h.

192 {
193 return coeffdnunu;
194 }

◆ getCoeffnlep00()

WilsonCoefficient HeffDB1::getCoeffnlep00 ( ) const
inline

Definition at line 160 of file HeffDB1.h.

160 {
161 return coeffnlep00;
162 }

◆ getCoeffnlep01()

WilsonCoefficient HeffDB1::getCoeffnlep01 ( ) const
inline

Definition at line 168 of file HeffDB1.h.

168 {
169 return coeffnlep10;
170 }

◆ getCoeffnlep10()

WilsonCoefficient HeffDB1::getCoeffnlep10 ( ) const
inline

Definition at line 164 of file HeffDB1.h.

164 {
165 return coeffnlep01;
166 }

◆ getCoeffnlep11()

WilsonCoefficient HeffDB1::getCoeffnlep11 ( ) const
inline

Definition at line 172 of file HeffDB1.h.

172 {
173 return coeffnlep11;
174 }

◆ getCoeffprimesgamma()

WilsonCoefficient HeffDB1::getCoeffprimesgamma ( ) const
inline

Definition at line 200 of file HeffDB1.h.

200 {
201 return coeffprimesgamma;
202 }

◆ getCoeffsgamma()

WilsonCoefficient HeffDB1::getCoeffsgamma ( ) const
inline

Definition at line 196 of file HeffDB1.h.

196 {
197 return coeffsgamma;
198 }

◆ getCoeffsmumu()

WilsonCoefficient HeffDB1::getCoeffsmumu ( ) const
inline

Definition at line 176 of file HeffDB1.h.

176 {
177 return coeffsmumu;
178 }

◆ getCoeffsnunu()

WilsonCoefficient HeffDB1::getCoeffsnunu ( ) const
inline

Definition at line 188 of file HeffDB1.h.

188 {
189 return coeffsnunu;
190 }

◆ GetModel()

const StandardModel & HeffDB1::GetModel ( ) const
inline

Definition at line 224 of file HeffDB1.h.

224 {
225 return model;
226 }

◆ getUBdmm()

EvolBsmm & HeffDB1::getUBdmm ( ) const
inline

Definition at line 208 of file HeffDB1.h.

208 {
209 return *evolbd;
210 }

◆ getUBsmm()

EvolBsmm & HeffDB1::getUBsmm ( ) const
inline

Definition at line 204 of file HeffDB1.h.

204 {
205 return *evolbs;
206 }

◆ getUDB1bsg()

EvolDB1bsg & HeffDB1::getUDB1bsg ( ) const
inline

Definition at line 220 of file HeffDB1.h.

220 {
221 return *evolDB1bsg;
222 }

◆ getUDF1()

EvolDF1nlep & HeffDB1::getUDF1 ( ) const
inline

Definition at line 212 of file HeffDB1.h.

212 {
213 return *u;
214 }

◆ getUDF1BMll()

EvolDB1Mll & HeffDB1::getUDF1BMll ( ) const
inline

Definition at line 216 of file HeffDB1.h.

216 {
217 return *evolDF1BMll;
218 }

◆ setMisiaktoBuras()

void HeffDB1::setMisiaktoBuras ( )
private

Definition at line 1101 of file HeffDB1.cpp.

1101 {
1102 double R_inv_t0[6] = {0.5, 0., 0., 0., 0., 0.},
1103 R_inv_t1[6] = {-0.1666666666666667, 1., 0., 0., 0., 0.},
1104 R_inv_t2[6] = {-0., 0., 1., -0.1666666666666667, 16., -2.6666666666666667},
1105 R_inv_t3[6] = {-0., 0., 0., 0.5, 0., 8.},
1106 R_inv_t4[6] = {0., 0., 1., -0.1666666666666667, 4., -0.6666666666666667},
1107 R_inv_t5[6] = {0., 0., 0., 0.5, 0., 2.};
1108
1109 double dR_t0[6] = {1.6666666666666667, 4., 0., 0., 0., 0},
1110 dR_t1[6] = {0.8888888888888888, 0., 0., 0., 0., 0.},
1111 dR_t2[6] = {0., 0., 0., -1.4814814814814814, 106.66666666666667, -27.25925925925926},
1112 dR_t3[6] = {0., 0., -6.666666666666667, -2.7777777777777777, -128., -143.55555555555555},
1113 dR_t4[6] = {0., 0., 0., 0.14814814814814815, -10.666666666666666, 3.259259259259259},
1114 dR_t5[6] = {0., 0., 0.6666666666666666, 0.2777777777777778, 14.666666666666666, 13.444444444444444};
1115
1116 R_inv_t.assign(0, R_inv_t0);
1117 R_inv_t.assign(1, R_inv_t1);
1118 R_inv_t.assign(2, R_inv_t2);
1119 R_inv_t.assign(3, R_inv_t3);
1120 R_inv_t.assign(4, R_inv_t4);
1121 R_inv_t.assign(5, R_inv_t5);
1122
1123 dR_t.assign(0, dR_t0);
1124 dR_t.assign(1, dR_t1);
1125 dR_t.assign(2, dR_t2);
1126 dR_t.assign(3, dR_t3);
1127 dR_t.assign(4, dR_t4);
1128 dR_t.assign(5, dR_t5);
1129}

Member Data Documentation

◆ Bdmumu_mu_cache

double HeffDB1::Bdmumu_mu_cache
private

Definition at line 274 of file HeffDB1.h.

◆ Bdmumu_Mu_cache

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

Definition at line 276 of file HeffDB1.h.

◆ Bdmumu_scheme_cache

schemes HeffDB1::Bdmumu_scheme_cache
private

Definition at line 275 of file HeffDB1.h.

◆ Bdmumu_WC_cache

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

Definition at line 277 of file HeffDB1.h.

◆ BMll_mu_cache

double HeffDB1::BMll_mu_cache
private

Definition at line 258 of file HeffDB1.h.

◆ BMll_Mu_cache

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

Definition at line 261 of file HeffDB1.h.

◆ BMll_order_ini_cache

unsigned int HeffDB1::BMll_order_ini_cache
private

Definition at line 259 of file HeffDB1.h.

◆ BMll_scheme_cache

schemes HeffDB1::BMll_scheme_cache
private

Definition at line 260 of file HeffDB1.h.

◆ BMll_WC_cache

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

Definition at line 262 of file HeffDB1.h.

◆ BMllprime_mu_cache

double HeffDB1::BMllprime_mu_cache
private

Definition at line 264 of file HeffDB1.h.

◆ BMllprime_Mu_cache

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

Definition at line 266 of file HeffDB1.h.

◆ BMllprime_scheme_cache

schemes HeffDB1::BMllprime_scheme_cache
private

Definition at line 265 of file HeffDB1.h.

◆ BMllprime_WC_cache

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

Definition at line 267 of file HeffDB1.h.

◆ Bpsgamma_Mu_cache

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

Definition at line 254 of file HeffDB1.h.

◆ Bpsgamma_WC_cache

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

Definition at line 256 of file HeffDB1.h.

◆ Bsgamma_mu_cache

double HeffDB1::Bsgamma_mu_cache
private

Definition at line 250 of file HeffDB1.h.

◆ Bsgamma_Mu_cache

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

Definition at line 253 of file HeffDB1.h.

◆ Bsgamma_order_ini_cache

unsigned int HeffDB1::Bsgamma_order_ini_cache
private

Definition at line 251 of file HeffDB1.h.

◆ Bsgamma_scheme_cache

schemes HeffDB1::Bsgamma_scheme_cache
private

Definition at line 252 of file HeffDB1.h.

◆ Bsgamma_WC_cache

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

Definition at line 255 of file HeffDB1.h.

◆ Bsmumu_mu_cache

double HeffDB1::Bsmumu_mu_cache
private

Definition at line 269 of file HeffDB1.h.

◆ Bsmumu_Mu_cache

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

Definition at line 271 of file HeffDB1.h.

◆ Bsmumu_scheme_cache

schemes HeffDB1::Bsmumu_scheme_cache
private

Definition at line 270 of file HeffDB1.h.

◆ Bsmumu_WC_cache

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

Definition at line 272 of file HeffDB1.h.

◆ coeffBMll

WilsonCoefficient HeffDB1::coeffBMll
private

Definition at line 240 of file HeffDB1.h.

◆ coeffBMll_Buras

WilsonCoefficient HeffDB1::coeffBMll_Buras
private

Definition at line 241 of file HeffDB1.h.

◆ coeffbtaunu

WilsonCoefficient HeffDB1::coeffbtaunu
private

Definition at line 236 of file HeffDB1.h.

◆ coeffdmumu

WilsonCoefficient HeffDB1::coeffdmumu
private

Definition at line 235 of file HeffDB1.h.

◆ coeffdnunu

WilsonCoefficient HeffDB1::coeffdnunu
private

Definition at line 237 of file HeffDB1.h.

◆ coeffnlep00

WilsonCoefficient HeffDB1::coeffnlep00
private

Definition at line 231 of file HeffDB1.h.

◆ coeffnlep00CC

WilsonCoefficient HeffDB1::coeffnlep00CC
private

Definition at line 233 of file HeffDB1.h.

◆ coeffnlep00qcd

WilsonCoefficient HeffDB1::coeffnlep00qcd
private

Definition at line 231 of file HeffDB1.h.

◆ coeffnlep01

WilsonCoefficient HeffDB1::coeffnlep01
private

Definition at line 233 of file HeffDB1.h.

◆ coeffnlep01A

WilsonCoefficient HeffDB1::coeffnlep01A
private

Definition at line 233 of file HeffDB1.h.

◆ coeffnlep01B

WilsonCoefficient HeffDB1::coeffnlep01B
private

Definition at line 233 of file HeffDB1.h.

◆ coeffnlep10

WilsonCoefficient HeffDB1::coeffnlep10
private

Definition at line 232 of file HeffDB1.h.

◆ coeffnlep10CC

WilsonCoefficient HeffDB1::coeffnlep10CC
private

Definition at line 234 of file HeffDB1.h.

◆ coeffnlep10qcd

WilsonCoefficient HeffDB1::coeffnlep10qcd
private

Definition at line 232 of file HeffDB1.h.

◆ coeffnlep11

WilsonCoefficient HeffDB1::coeffnlep11
private

Definition at line 234 of file HeffDB1.h.

◆ coeffnlep11A

WilsonCoefficient HeffDB1::coeffnlep11A
private

Definition at line 234 of file HeffDB1.h.

◆ coeffnlep11B

WilsonCoefficient HeffDB1::coeffnlep11B
private

Definition at line 234 of file HeffDB1.h.

◆ coeffprimeBMll

WilsonCoefficient HeffDB1::coeffprimeBMll
private

Definition at line 240 of file HeffDB1.h.

◆ coeffprimesgamma

WilsonCoefficient HeffDB1::coeffprimesgamma
private

Definition at line 238 of file HeffDB1.h.

◆ coeffsgamma

WilsonCoefficient HeffDB1::coeffsgamma
private

Definition at line 238 of file HeffDB1.h.

◆ coeffsgamma_Buras

WilsonCoefficient HeffDB1::coeffsgamma_Buras
private

Definition at line 239 of file HeffDB1.h.

◆ coeffsmumu

WilsonCoefficient HeffDB1::coeffsmumu
private

Definition at line 235 of file HeffDB1.h.

◆ coeffsnunu

WilsonCoefficient HeffDB1::coeffsnunu
private

Definition at line 237 of file HeffDB1.h.

◆ dR_t

gslpp::matrix<double> HeffDB1::dR_t = gslpp::matrix< double >(6, 6, 0.)
private

Definition at line 284 of file HeffDB1.h.

◆ evolbd

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

Definition at line 246 of file HeffDB1.h.

◆ evolbs

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

Definition at line 245 of file HeffDB1.h.

◆ evolDB1bsg

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

Definition at line 243 of file HeffDB1.h.

◆ evolDF1BMll

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

Definition at line 242 of file HeffDB1.h.

◆ MisiaktoBurasNLO

gslpp::matrix<double> HeffDB1::MisiaktoBurasNLO = gslpp::matrix< double >(6, 6, 0.)
private

Definition at line 285 of file HeffDB1.h.

◆ model

const StandardModel& HeffDB1::model
private

Definition at line 229 of file HeffDB1.h.

◆ nlep

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

Definition at line 279 of file HeffDB1.h.

◆ nlep2

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

Definition at line 279 of file HeffDB1.h.

◆ nlepCC

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

Definition at line 279 of file HeffDB1.h.

◆ R_inv_t

gslpp::matrix<double> HeffDB1::R_inv_t = gslpp::matrix< double >(6, 6, 0.)
private

Definition at line 283 of file HeffDB1.h.

◆ tmp_coeffBMll

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffBMll = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 291 of file HeffDB1.h.

◆ tmp_coeffBMllLO

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffBMllLO = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 292 of file HeffDB1.h.

◆ tmp_coeffBMllNLO

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffBMllNLO = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 293 of file HeffDB1.h.

◆ tmp_coeffsgamma

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffsgamma = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 287 of file HeffDB1.h.

◆ tmp_coeffsgammaLO

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffsgammaLO = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 288 of file HeffDB1.h.

◆ tmp_coeffsgammaNLO

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffsgammaNLO = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 289 of file HeffDB1.h.

◆ tmp_coeffsgammaNNLO

gslpp::vector<gslpp::complex> HeffDB1::tmp_coeffsgammaNNLO = gslpp::vector<gslpp::complex>(6, 0.)
private

Definition at line 290 of file HeffDB1.h.

◆ u

std::unique_ptr<EvolDF1nlep> HeffDB1::u
private

Definition at line 244 of file HeffDB1.h.

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