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 21 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
 
EvolDF1nlep & getUDF1 () const
 
EvolDB1Mll & getUDF1BMll () const
 
 HeffDB1 (const StandardModel &SM)
 constructor More...
 
virtual ~HeffDB1 ()
 destructor More...
 

Private Attributes

double Bdmumu_mu_cache
 
std::vector< double > Bdmumu_Mu_cache
 
schemes Bdmumu_scheme_cache
 
std::vector< 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
 
std::unique_ptr< EvolDF1nlep > u
 

Constructor & Destructor Documentation

◆ HeffDB1()

HeffDB1::HeffDB1 ( const StandardModel &  SM)

constructor

Parameters
SM
modelmatching

Definition at line 16 of file HeffDB1.cpp.

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

◆ ~HeffDB1()

HeffDB1::~HeffDB1 ( )
virtual

destructor

Definition at line 75 of file HeffDB1.cpp.

76 {}

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

1004 {
1005 
1006  coeffBMll.setScheme(scheme);
1007  orders ordDF1 = coeffBMll.getOrder();
1008 
1009  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMBMll(lepton);
1010 
1011  unsigned int order_ini;
1012  if (noSM) order_ini = 1;
1013  else order_ini = 0;
1014 
1015  if (mu == BMll_mu_cache && scheme == BMll_scheme_cache && order_ini == BMll_order_ini_cache) {
1016  int check = 1;
1017  for (unsigned int i = order_ini; i < mc.size(); i++) {
1018  if (mc[i].getMu() == BMll_Mu_cache[i]) {
1019  for (int j = LO; j <= ordDF1; j++) {
1020  for (int k = LO; k <= j; k++) {
1021  for (int l = 0; l < 13; l++) {
1022  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMll_WC_cache[i].getCoeff(orders(j - k))))(l));
1023  }
1024  }
1025  }
1026  } else check = 0;
1027  }
1028  if (check == 1) return coeffBMll.getCoeff();
1029  }
1030 
1031  BMll_mu_cache = mu;
1032  BMll_order_ini_cache = order_ini;
1033  BMll_scheme_cache = scheme;
1034  BMll_WC_cache.clear();
1035  BMll_WC_cache = mc;
1036 
1037  coeffBMll.setMu(mu);
1038 
1039  for (unsigned int i = order_ini; i < mc.size(); i++) {
1040  BMll_Mu_cache[i] = mc[i].getMu();
1041  for (int j = LO; j <= ordDF1; j++) {
1042  for (int k = LO; k <= j; k++) {
1043  coeffBMll.setCoeff(*coeffBMll.getCoeff(orders(j)) +
1044  evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
1045  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
1046  }
1047  }

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

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

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

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

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

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

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

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

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

862 {
863  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbtaunu(meson_i);
864  coeffbtaunu.resetCoefficient();
865  orders ordDF1 = coeffbtaunu.getOrder();
866  for (unsigned int i = 0; i < mcb.size(); i++){
867  for (int j = LO; j <= ordDF1; j++){
868  coeffbtaunu.setCoeff(*coeffbtaunu.getCoeff(orders(j))
869  + *mcb[i].getCoeff(orders(j)), orders(j));

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

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

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

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

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

1055 {
1056 
1057  coeffprimeBMll.setScheme(scheme);
1058  orders ordDF1 = coeffprimeBMll.getOrder();
1059 
1060  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMprimeBMll(lepton);
1061 
1062  if (mu == BMllprime_mu_cache && scheme == BMllprime_scheme_cache) {
1063  int check = 1;
1064  for (unsigned int i = 0; i < mc.size(); i++) {
1065  if (mc[i].getMu() == BMllprime_Mu_cache[i]) {
1066  for (int j = LO; j <= ordDF1; j++) {
1067  for (int k = LO; k <= j; k++) {
1068  for (int l = 0; l < 13; l++) {
1069  check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMllprime_WC_cache[i].getCoeff(orders(j - k))))(l));
1070  }
1071  }
1072  }
1073  } else check = 0;
1074  }
1075  if (check == 1) return coeffprimeBMll.getCoeff();
1076  }
1077 
1078  BMllprime_mu_cache = mu;
1079  BMllprime_scheme_cache = scheme;
1080  BMllprime_WC_cache.clear();
1081  BMllprime_WC_cache = mc;
1082 
1083  coeffprimeBMll.setMu(mu);
1084 
1085  for (unsigned int i = 0; i < mc.size(); i++){
1086  BMllprime_Mu_cache[i] = mc[i].getMu();
1087  for (int j = LO; j <= ordDF1; j++){
1088  for (int k = LO; k <= j; k++){
1089  coeffprimeBMll.setCoeff(*coeffprimeBMll.getCoeff(orders(j)) +
1090  evolDF1BMll->Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
1091  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
1092  }
1093  }
1094  }

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

959 {
960 
961  coeffprimesgamma.setScheme(scheme);
962  orders ordDF1 = coeffprimesgamma.getOrder();
963 
964  const std::vector<WilsonCoefficient>& mcbsgp = model.getMatching().CMprimebsg();
965 
966  if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
967  int check = 1;
968  for (unsigned int i = 0; i < mcbsgp.size(); i++) {
969  if (mcbsgp[i].getMu() == Bpsgamma_Mu_cache[i]) {
970  for (int j = LO; j <= ordDF1; j++) {
971  for (int k = LO; k <= j; k++) {
972  for (int l = 0; l < 8; l++) {
973  check *= ((*(mcbsgp[i].getCoeff(orders(j - k))))(l) == (*(Bpsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
974  }
975  }
976  }
977  } else check = 0;
978  }
979  if (check == 1) return coeffprimesgamma.getCoeff();
980  }
981 
982  Bsgamma_mu_cache = mu;
983  Bsgamma_scheme_cache = scheme;
984  Bpsgamma_WC_cache.clear();
985  Bpsgamma_WC_cache = mcbsgp;
986 
987  coeffprimesgamma.setMu(mu);
988 
989  for (unsigned int i = 0; i < mcbsgp.size(); i++){
990  Bpsgamma_Mu_cache[i] = mcbsgp[i].getMu();
991  for (int j = LO; j <= ordDF1; j++){
992  for (int k = LO; k <= j; k++){
993  coeffprimesgamma.setCoeff(*coeffprimesgamma.getCoeff(orders(j)) +
994  evolDB1bsg->Df1Evolbsg(mu, mcbsgp[i].getMu(), orders(k), mcbsgp[i].getScheme()) *
995  (*(mcbsgp[i].getCoeff(orders(j - k)))), orders(j));
996  }
997  }

◆ 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 905 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 == BMll_order_ini_cache) {
921  int check = 1;
922  for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
923  if (mcbsg[i].getMu() == Bsgamma_Mu_cache[i]) {
924  for (int j = LO; j <= ordDF1; j++) {
925  for (int k = LO; k <= j; k++) {
926  for (int l = 0; l < 8; l++) {
927  check *= ((*(mcbsg[i].getCoeff(orders(j - k))))(l) == (*(Bsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
928  }
929  }
930  }
931  } else check = 0;
932  }
933  if (check == 1) return coeffsgamma.getCoeff();
934  }
935 
936  Bsgamma_mu_cache = mu;
937  Bsgamma_order_ini_cache = order_ini;
938  Bsgamma_scheme_cache = scheme;
939  Bsgamma_WC_cache.clear();
940  Bsgamma_WC_cache = mcbsg;
941 
942  coeffsgamma.setMu(mu);
943 
944  for (unsigned int i = order_ini; i < mcbsg.size(); i++) {
945  Bsgamma_Mu_cache[i] = mcbsg[i].getMu();
946  for (int j = LO; j <= ordDF1; j++) {
947  for (int k = LO; k <= j; k++) {
948  coeffsgamma.setCoeff(*coeffsgamma.getCoeff(orders(j)) +
949  evolDB1bsg->Df1Evolbsg(mu, mcbsg[i].getMu(), orders(k), mcbsg[i].getScheme()) *
950  (*(mcbsg[i].getCoeff(orders(j - k)))), orders(j));
951  }
952  }

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

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

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

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

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

876 {
877 
878  const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMBXsnn();
879 
880  orders ordDF1 = coeffsnunu.getOrder();
881 
882  for (unsigned int i = 0; i < mcb.size(); i++){
883  for (int j = LO; j <= ordDF1; j++){
884  coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders(j))
885  + *mcb[i].getCoeff(orders(j)), orders(j));
886  }

◆ getCoeffbtaunu()

WilsonCoefficient HeffDB1::getCoeffbtaunu ( ) const
inline

Definition at line 166 of file HeffDB1.h.

166  {
167  return coeffbtaunu;
168  }

◆ getCoeffdmumu()

WilsonCoefficient HeffDB1::getCoeffdmumu ( ) const
inline

Definition at line 162 of file HeffDB1.h.

162  {
163  return coeffdmumu;
164  }

◆ getCoeffdnunu()

WilsonCoefficient HeffDB1::getCoeffdnunu ( ) const
inline

Definition at line 174 of file HeffDB1.h.

174  {
175  return coeffdnunu;
176  }

◆ getCoeffnlep00()

WilsonCoefficient HeffDB1::getCoeffnlep00 ( ) const
inline

Definition at line 142 of file HeffDB1.h.

142  {
143  return coeffnlep00;
144  }

◆ getCoeffnlep01()

WilsonCoefficient HeffDB1::getCoeffnlep01 ( ) const
inline

Definition at line 150 of file HeffDB1.h.

150  {
151  return coeffnlep10;
152  }

◆ getCoeffnlep10()

WilsonCoefficient HeffDB1::getCoeffnlep10 ( ) const
inline

Definition at line 146 of file HeffDB1.h.

146  {
147  return coeffnlep01;
148  }

◆ getCoeffnlep11()

WilsonCoefficient HeffDB1::getCoeffnlep11 ( ) const
inline

Definition at line 154 of file HeffDB1.h.

154  {
155  return coeffnlep11;
156  }

◆ getCoeffprimesgamma()

WilsonCoefficient HeffDB1::getCoeffprimesgamma ( ) const
inline

Definition at line 182 of file HeffDB1.h.

182  {
183  return coeffprimesgamma;
184  }

◆ getCoeffsgamma()

WilsonCoefficient HeffDB1::getCoeffsgamma ( ) const
inline

Definition at line 178 of file HeffDB1.h.

178  {
179  return coeffsgamma;
180  }

◆ getCoeffsmumu()

WilsonCoefficient HeffDB1::getCoeffsmumu ( ) const
inline

Definition at line 158 of file HeffDB1.h.

158  {
159  return coeffsmumu;
160  }

◆ getCoeffsnunu()

WilsonCoefficient HeffDB1::getCoeffsnunu ( ) const
inline

Definition at line 170 of file HeffDB1.h.

170  {
171  return coeffsnunu;
172  }

◆ GetModel()

const StandardModel& HeffDB1::GetModel ( ) const
inline

Definition at line 206 of file HeffDB1.h.

206  {
207  return model;
208  }

◆ getUBdmm()

EvolBsmm& HeffDB1::getUBdmm ( ) const
inline

Definition at line 190 of file HeffDB1.h.

190  {
191  return *evolbd;
192  }

◆ getUBsmm()

EvolBsmm& HeffDB1::getUBsmm ( ) const
inline

Definition at line 186 of file HeffDB1.h.

186  {
187  return *evolbs;
188  }

◆ getUDB1bsg()

EvolDB1bsg& HeffDB1::getUDB1bsg ( ) const
inline

Definition at line 202 of file HeffDB1.h.

202  {
203  return *evolDB1bsg;
204  }

◆ getUDF1()

EvolDF1nlep& HeffDB1::getUDF1 ( ) const
inline

Definition at line 194 of file HeffDB1.h.

194  {
195  return *u;
196  }

◆ getUDF1BMll()

EvolDB1Mll& HeffDB1::getUDF1BMll ( ) const
inline

Definition at line 198 of file HeffDB1.h.

198  {
199  return *evolDF1BMll;
200  }

Member Data Documentation

◆ Bdmumu_mu_cache

double HeffDB1::Bdmumu_mu_cache
private

Definition at line 254 of file HeffDB1.h.

◆ Bdmumu_Mu_cache

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

Definition at line 256 of file HeffDB1.h.

◆ Bdmumu_scheme_cache

schemes HeffDB1::Bdmumu_scheme_cache
private

Definition at line 255 of file HeffDB1.h.

◆ Bdmumu_WC_cache

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

Definition at line 257 of file HeffDB1.h.

◆ BMll_mu_cache

double HeffDB1::BMll_mu_cache
private

Definition at line 238 of file HeffDB1.h.

◆ BMll_Mu_cache

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

Definition at line 241 of file HeffDB1.h.

◆ BMll_order_ini_cache

unsigned int HeffDB1::BMll_order_ini_cache
private

Definition at line 239 of file HeffDB1.h.

◆ BMll_scheme_cache

schemes HeffDB1::BMll_scheme_cache
private

Definition at line 240 of file HeffDB1.h.

◆ BMll_WC_cache

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

Definition at line 242 of file HeffDB1.h.

◆ BMllprime_mu_cache

double HeffDB1::BMllprime_mu_cache
private

Definition at line 244 of file HeffDB1.h.

◆ BMllprime_Mu_cache

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

Definition at line 246 of file HeffDB1.h.

◆ BMllprime_scheme_cache

schemes HeffDB1::BMllprime_scheme_cache
private

Definition at line 245 of file HeffDB1.h.

◆ BMllprime_WC_cache

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

Definition at line 247 of file HeffDB1.h.

◆ Bpsgamma_Mu_cache

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

Definition at line 234 of file HeffDB1.h.

◆ Bpsgamma_WC_cache

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

Definition at line 236 of file HeffDB1.h.

◆ Bsgamma_mu_cache

double HeffDB1::Bsgamma_mu_cache
private

Definition at line 230 of file HeffDB1.h.

◆ Bsgamma_Mu_cache

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

Definition at line 233 of file HeffDB1.h.

◆ Bsgamma_order_ini_cache

unsigned int HeffDB1::Bsgamma_order_ini_cache
private

Definition at line 231 of file HeffDB1.h.

◆ Bsgamma_scheme_cache

schemes HeffDB1::Bsgamma_scheme_cache
private

Definition at line 232 of file HeffDB1.h.

◆ Bsgamma_WC_cache

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

Definition at line 235 of file HeffDB1.h.

◆ Bsmumu_mu_cache

double HeffDB1::Bsmumu_mu_cache
private

Definition at line 249 of file HeffDB1.h.

◆ Bsmumu_Mu_cache

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

Definition at line 251 of file HeffDB1.h.

◆ Bsmumu_scheme_cache

schemes HeffDB1::Bsmumu_scheme_cache
private

Definition at line 250 of file HeffDB1.h.

◆ Bsmumu_WC_cache

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

Definition at line 252 of file HeffDB1.h.

◆ coeffBMll

WilsonCoefficient HeffDB1::coeffBMll
private

Definition at line 221 of file HeffDB1.h.

◆ coeffbtaunu

WilsonCoefficient HeffDB1::coeffbtaunu
private

Definition at line 218 of file HeffDB1.h.

◆ coeffdmumu

WilsonCoefficient HeffDB1::coeffdmumu
private

Definition at line 217 of file HeffDB1.h.

◆ coeffdnunu

WilsonCoefficient HeffDB1::coeffdnunu
private

Definition at line 219 of file HeffDB1.h.

◆ coeffnlep00

WilsonCoefficient HeffDB1::coeffnlep00
private

Definition at line 213 of file HeffDB1.h.

◆ coeffnlep00CC

WilsonCoefficient HeffDB1::coeffnlep00CC
private

Definition at line 215 of file HeffDB1.h.

◆ coeffnlep00qcd

WilsonCoefficient HeffDB1::coeffnlep00qcd
private

Definition at line 213 of file HeffDB1.h.

◆ coeffnlep01

WilsonCoefficient HeffDB1::coeffnlep01
private

Definition at line 215 of file HeffDB1.h.

◆ coeffnlep01A

WilsonCoefficient HeffDB1::coeffnlep01A
private

Definition at line 215 of file HeffDB1.h.

◆ coeffnlep01B

WilsonCoefficient HeffDB1::coeffnlep01B
private

Definition at line 215 of file HeffDB1.h.

◆ coeffnlep10

WilsonCoefficient HeffDB1::coeffnlep10
private

Definition at line 214 of file HeffDB1.h.

◆ coeffnlep10CC

WilsonCoefficient HeffDB1::coeffnlep10CC
private

Definition at line 216 of file HeffDB1.h.

◆ coeffnlep10qcd

WilsonCoefficient HeffDB1::coeffnlep10qcd
private

Definition at line 214 of file HeffDB1.h.

◆ coeffnlep11

WilsonCoefficient HeffDB1::coeffnlep11
private

Definition at line 216 of file HeffDB1.h.

◆ coeffnlep11A

WilsonCoefficient HeffDB1::coeffnlep11A
private

Definition at line 216 of file HeffDB1.h.

◆ coeffnlep11B

WilsonCoefficient HeffDB1::coeffnlep11B
private

Definition at line 216 of file HeffDB1.h.

◆ coeffprimeBMll

WilsonCoefficient HeffDB1::coeffprimeBMll
private

Definition at line 221 of file HeffDB1.h.

◆ coeffprimesgamma

WilsonCoefficient HeffDB1::coeffprimesgamma
private

Definition at line 220 of file HeffDB1.h.

◆ coeffsgamma

WilsonCoefficient HeffDB1::coeffsgamma
private

Definition at line 220 of file HeffDB1.h.

◆ coeffsmumu

WilsonCoefficient HeffDB1::coeffsmumu
private

Definition at line 217 of file HeffDB1.h.

◆ coeffsnunu

WilsonCoefficient HeffDB1::coeffsnunu
private

Definition at line 219 of file HeffDB1.h.

◆ evolbd

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

Definition at line 226 of file HeffDB1.h.

◆ evolbs

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

Definition at line 225 of file HeffDB1.h.

◆ evolDB1bsg

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

Definition at line 223 of file HeffDB1.h.

◆ evolDF1BMll

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

Definition at line 222 of file HeffDB1.h.

◆ model

const StandardModel& HeffDB1::model
private

Definition at line 211 of file HeffDB1.h.

◆ nlep

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

Definition at line 259 of file HeffDB1.h.

◆ nlep2

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

Definition at line 259 of file HeffDB1.h.

◆ nlepCC

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

Definition at line 259 of file HeffDB1.h.

◆ u

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

Definition at line 224 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
HeffDB1::u
std::unique_ptr< EvolDF1nlep > u
Definition: HeffDB1.h:224
ModelMatching::CMprimeBMll
virtual std::vector< WilsonCoefficient > & CMprimeBMll(QCD::lepton lepton)=0
NO_QED
Definition: OrderScheme.h:49
HeffDB1::coeffnlep00qcd
WilsonCoefficient coeffnlep00qcd
Definition: HeffDB1.h:213
NLO_QED11
Definition: OrderScheme.h:51
QCD::Beta1
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:471
HeffDB1::nlep2
gslpp::vector< gslpp::complex > nlep2
Definition: HeffDB1.h:259
HeffDB1::BMll_order_ini_cache
unsigned int BMll_order_ini_cache
Definition: HeffDB1.h:239
HeffDB1::evolDF1BMll
std::unique_ptr< EvolDB1Mll > evolDF1BMll
Definition: HeffDB1.h:222
HeffDB1::coeffBMll
WilsonCoefficient coeffBMll
Definition: HeffDB1.h:221
WilsonTemplate::getOrder_qed
orders_qed getOrder_qed() const
Definition: WilsonTemplate.h:70
LO
Definition: OrderScheme.h:33
HeffDB1::evolDB1bsg
std::unique_ptr< EvolDB1bsg > evolDB1bsg
Definition: HeffDB1.h:223
HeffDB1::coeffnlep11A
WilsonCoefficient coeffnlep11A
Definition: HeffDB1.h:216
HeffDB1::coeffnlep11B
WilsonCoefficient coeffnlep11B
Definition: HeffDB1.h:216
HeffDB1::coeffnlep10
WilsonCoefficient coeffnlep10
Definition: HeffDB1.h:214
HeffDB1::Bpsgamma_WC_cache
std::vector< WilsonCoefficient > Bpsgamma_WC_cache
Definition: HeffDB1.h:236
ModelMatching::CMbnlepCC
virtual std::vector< WilsonCoefficient > & CMbnlepCC(const int a)=0
NDR
Definition: OrderScheme.h:21
ModelMatching::CMbsg
virtual std::vector< WilsonCoefficient > & CMbsg()=0
HeffDB1::Bsmumu_Mu_cache
std::vector< double > Bsmumu_Mu_cache
Definition: HeffDB1.h:251
HeffDB1::coeffbtaunu
WilsonCoefficient coeffbtaunu
Definition: HeffDB1.h:218
HeffDB1::evolbd
std::unique_ptr< EvolBsmm > evolbd
Definition: HeffDB1.h:226
HeffDB1::BMllprime_WC_cache
std::vector< WilsonCoefficient > BMllprime_WC_cache
Definition: HeffDB1.h:247
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
HeffDB1::coeffdmumu
WilsonCoefficient coeffdmumu
Definition: HeffDB1.h:217
HeffDB1::nlep
gslpp::vector< gslpp::complex > nlep
Definition: HeffDB1.h:259
EvolDF1nlep
Evolutor Class
Definition: EvolDF1nlep.h:16
EvolDB1Mll
Definition: EvolDB1Mll.h:14
HeffDB1::coeffprimesgamma
WilsonCoefficient coeffprimesgamma
Definition: HeffDB1.h:220
HeffDB1::Bdmumu_scheme_cache
schemes Bdmumu_scheme_cache
Definition: HeffDB1.h:255
HeffDB1::coeffsmumu
WilsonCoefficient coeffsmumu
Definition: HeffDB1.h:217
HeffDB1::coeffnlep10CC
WilsonCoefficient coeffnlep10CC
Definition: HeffDB1.h:216
ModelMatching::CMbnlep
virtual std::vector< WilsonCoefficient > & CMbnlep(const int a)=0
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:240
WilsonCoefficient::setCoeff
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: WilsonCoefficient.h:34
HeffDB1::Bsgamma_WC_cache
std::vector< WilsonCoefficient > Bsgamma_WC_cache
Definition: HeffDB1.h:235
HeffDB1::Bsgamma_scheme_cache
schemes Bsgamma_scheme_cache
Definition: HeffDB1.h:232
HeffDB1::coeffnlep01
WilsonCoefficient coeffnlep01
Definition: HeffDB1.h:215
ModelMatching::CMBMll
virtual std::vector< WilsonCoefficient > & CMBMll(QCD::lepton lepton)=0
HeffDB1::coeffnlep00CC
WilsonCoefficient coeffnlep00CC
Definition: HeffDB1.h:215
EvolBsmm
Definition: EvolBsmm.h:16
HeffDB1::model
const StandardModel & model
Definition: HeffDB1.h:211
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
LO_QED
Definition: OrderScheme.h:50
HeffDB1::Bsmumu_scheme_cache
schemes Bsmumu_scheme_cache
Definition: HeffDB1.h:250
HeffDB1::coeffnlep10qcd
WilsonCoefficient coeffnlep10qcd
Definition: HeffDB1.h:214
HeffDB1::Bdmumu_mu_cache
double Bdmumu_mu_cache
Definition: HeffDB1.h:254
HeffDB1::coeffsgamma
WilsonCoefficient coeffsgamma
Definition: HeffDB1.h:220
NNLO
Definition: OrderScheme.h:35
HeffDB1::Bsgamma_Mu_cache
std::vector< double > Bsgamma_Mu_cache
Definition: HeffDB1.h:233
HeffDB1::coeffsnunu
WilsonCoefficient coeffsnunu
Definition: HeffDB1.h:219
HeffDB1::BMllprime_scheme_cache
schemes BMllprime_scheme_cache
Definition: HeffDB1.h:245
NLO_QED22
Definition: OrderScheme.h:55
WilsonTemplate::setMu
virtual void setMu(double mu)
Definition: WilsonTemplate.h:92
orders_qed
orders_qed
An enum type for orders in electroweak.
Definition: OrderScheme.h:47
WilsonTemplate::resetCoefficient
virtual void resetCoefficient()
Definition: WilsonTemplate.h:80
HeffDB1::Bsmumu_mu_cache
double Bsmumu_mu_cache
Definition: HeffDB1.h:249
HeffDB1::BMllprime_Mu_cache
std::vector< double > BMllprime_Mu_cache
Definition: HeffDB1.h:246
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:230
HeffDB1::BMllprime_mu_cache
double BMllprime_mu_cache
Definition: HeffDB1.h:244
HeffDB1::coeffnlep01A
WilsonCoefficient coeffnlep01A
Definition: HeffDB1.h:215
StandardModel::getMatching
virtual StandardModelMatching & getMatching() const
A get method to access the member reference of type StandardModelMatching.
Definition: StandardModel.h:952
HeffDB1::Bdmumu_Mu_cache
std::vector< double > Bdmumu_Mu_cache
Definition: HeffDB1.h:256
HeffDB1::coeffdnunu
WilsonCoefficient coeffdnunu
Definition: HeffDB1.h:219
WilsonCoefficient::getCoeff
gslpp::vector< gslpp::complex > ** getCoeff() const
Definition: WilsonCoefficient.h:29
HeffDB1::Bsgamma_order_ini_cache
unsigned int Bsgamma_order_ini_cache
Definition: HeffDB1.h:231
HeffDB1::coeffprimeBMll
WilsonCoefficient coeffprimeBMll
Definition: HeffDB1.h:221
HeffDB1::coeffnlep01B
WilsonCoefficient coeffnlep01B
Definition: HeffDB1.h:215
HeffDB1::BMll_mu_cache
double BMll_mu_cache
Definition: HeffDB1.h:238
HeffDB1::coeffnlep11
WilsonCoefficient coeffnlep11
Definition: HeffDB1.h:216
HeffDB1::coeffnlep00
WilsonCoefficient coeffnlep00
Definition: HeffDB1.h:213
HeffDB1::Bpsgamma_Mu_cache
std::vector< double > Bpsgamma_Mu_cache
Definition: HeffDB1.h:234
HeffDB1::nlepCC
gslpp::vector< gslpp::complex > nlepCC
Definition: HeffDB1.h:259
NLO
Definition: OrderScheme.h:34
NLO_QED21
Definition: OrderScheme.h:52
EvolDB1bsg
Definition: EvolDB1bsg.h:14
NLO_QED02
Definition: OrderScheme.h:53
HeffDB1::BMll_WC_cache
std::vector< WilsonCoefficient > BMll_WC_cache
Definition: HeffDB1.h:242
HeffDB1::Bsmumu_WC_cache
std::vector< WilsonCoefficient > Bsmumu_WC_cache
Definition: HeffDB1.h:252
HeffDB1::evolbs
std::unique_ptr< EvolBsmm > evolbs
Definition: HeffDB1.h:225
HeffDB1::Bdmumu_WC_cache
std::vector< WilsonCoefficient > Bdmumu_WC_cache
Definition: HeffDB1.h:257
HeffDB1::BMll_Mu_cache
std::vector< double > BMll_Mu_cache
Definition: HeffDB1.h:241