a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HeffDC1.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 HEPfit Collaboration
3  *
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "HeffDC1.h"
9 #include "StandardModel.h"
10 #include "EvolDC1.h"
11 #include "EvolDC1Buras.h"
12 
13 HeffDC1::HeffDC1(const StandardModel & SM)
14 : model(SM), coeffdc1(10, NDR, NLO),
15  coeffdc1g(10, NDR, NLO), ug(new EvolDC1(10, NDR, NLO, SM)), u(new EvolDC1Buras(10, NDR, NLO, SM)),
16  ckm(3,0.), COEFF_pi(10,0.), COEFF_K(10,0.)
17 {
18 
19  double co = - 4. * model.getGF() / sqrt(2);
20  ckm = model.getVCKM();
21  gslpp::complex lambdab_cu = - ckm(1,2)*ckm(0,2).conjugate(); // - V_cb * V_ub^{*}
22  gslpp::complex lambdad_cu = ckm(1,0)*ckm(0,0).conjugate(); // V_cd * V_ud^{*}
23  gslpp::complex lambdas_cu = ckm(1,1)*ckm(0,1).conjugate(); // V_cs * V_us^{*}
24  COEFF_pi.assign(0,0, co * lambdad_cu); COEFF_pi.assign(1,1, co * lambdad_cu);
25  COEFF_pi.assign(2,2, co * lambdab_cu); COEFF_pi.assign(3,3, co * lambdab_cu);
26  COEFF_pi.assign(4,4, co * lambdab_cu); COEFF_pi.assign(5,5, co * lambdab_cu);
27  COEFF_pi.assign(6,6, co * lambdab_cu); COEFF_pi.assign(7,7, co * lambdab_cu);
28  COEFF_pi.assign(8,8, 1.); COEFF_pi.assign(9,9, 1.);
29  COEFF_K.assign(0,0, co * lambdas_cu); COEFF_K.assign(1,1, co * lambdas_cu);
30  COEFF_K.assign(2,2, co * lambdab_cu); COEFF_K.assign(3,3, co * lambdab_cu);
31  COEFF_K.assign(4,4, co * lambdab_cu); COEFF_K.assign(5,5, co * lambdab_cu);
32  COEFF_K.assign(6,6, co * lambdab_cu); COEFF_K.assign(7,7, co * lambdab_cu);
33  COEFF_K.assign(8,8, 1.); COEFF_K.assign(9,9, 1.);
34 
35 }
36 
37 HeffDC1::~HeffDC1() {
38 }
39 
40  /******************************************************************************
41  * evolution Wilson Coefficien D-> pi pi, K K *
42  * Misiak basis *
43  ******************************************************************************/
44 gslpp::vector<gslpp::complex>** HeffDC1::ComputeCoeffDC1_pi(double mu, schemes scheme)
45 {
46 
47  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMd1();
48  coeffdc1.setMu(mu);
49  orders ordDF1 = coeffdc1.getOrder();
50  for (unsigned int i = 0; i < mc.size(); i++){
51  if(i != 1){
52  for (int j = LO; j <= ordDF1; j++){
53  for (int k = LO; k <= j; k++){
54  coeffdc1.setCoeff(*coeffdc1.getCoeff(orders(j)) +
55  ug->DC1Evol(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
56  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
57  }
58  }
59  }
60  }
61 
62  coeffdc1.setScheme(scheme);
63 
64  return coeffdc1.getCoeff();
65 }
66 
67 gslpp::vector<gslpp::complex>** HeffDC1::ComputeCoeffDC1_K(double mu, schemes scheme)
68 {
69 
70  const std::vector<WilsonCoefficient>& mc = model.getMatching().CMd1();
71  coeffdc1.setMu(mu);
72 
73  orders ordDF1 = coeffdc1.getOrder();
74  for (unsigned int i = 0; i < mc.size(); i++){
75  std::cout << " SIZE i " << i << std::endl << std::endl;
76  for (int j = LO; j <= ordDF1; j++){
77  for (int k = LO; k <= j; k++){
78  coeffdc1.setCoeff(*coeffdc1.getCoeff(orders(j)) +
79  ug->DC1Evol(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
80  (*(mc[i].getCoeff(orders(j - k)))), orders(j));
81  }
82  }
83  if(i == 0){
84  for (int j = LO; j <= ordDF1; j++){
85  coeffdc1.setCoeff(COEFF_K * (*coeffdc1.getCoeff(orders(j))), orders(j));
86  }
87  }
88  }
89 
90  coeffdc1.setScheme(scheme);
91 
92  return coeffdc1.getCoeff();
93 }
94 
95 /*
96 gslpp::vector<gslpp::complex>** HeffDC1::ComputeCoeffDC1g(double mu, schemes scheme)
97 {
98 
99  const std::vector<WilsonCoefficient>& mcg = model.getMyMatching()->CMd1();
100  gslpp::vector<gslpp::complex> vecdc1g(10,0.);
101  coeffdc1g.setMu(mu);
102 
103  orders ordDF1 = coeffdc1g.getOrder();
104  for (int i = 0; i < mcg.size(); i++){
105  for (int j = LO; j <= ordDF1; j++){
106  for (int k = LO; k <= j; k++) {
107  coeffdc1g.setCoeff(*coeffdc1g.getCoeff(orders(j)) +
108  ug->DC1Evol(mu, mcg[i].getMu(), orders(k), mcg[i].getScheme()) *
109  (*(mcg[i].getCoeff(orders(j - k)))), orders(j));
110  }
111  //STAMPA PROVE
112  vecdc1g = *coeffdc1g.getCoeff(orders(j));
113 
114  std::cout<< std::endl <<" CHROMOMAGNETIC "<< j <<" CHROMOMAGNETIC "<<std::endl;
115  std::cout<<" ++++++++++ "<< "C_8g_eff" <<" --> "<< vecdc1g(7) <<" ++++++++++++ "<<std::endl;
116  std::cout << std::endl << " \\\\\\\\\\\\\\\\\\\\ FINE STAMPE DI PROVA \\\\\\\\\\\\\\\\\\\\\\\\ " <<std::endl <<std::endl;
117  }
118  }
119 
120  coeffdc1g.setScheme(scheme);
121 
122  return coeffdc1g.getCoeff();
123 }*/
124 
125  /*
126 
127  gslpp::vector<gslpp::complex> a(6,0.);
128 
129  // a(0) = C_3 + C_4/3.;
130  // a(1) = C_4 + C_3/3.;
131  // a(2) = - 2./3./M_PI * C_8g;
132  // a(3) = C_5 + C_6/3.;
133  // a(4) = C_6 + C_5/3.;
134  // a(5) = - 2./9./M_PI * C_8g;
135 
136  vector<double> delta1(10,0.),delta2(10,0.),delta3(10,0.),delta4(10,0.),
137  delta5(10,0.),delta6(10,0.),delta7(10,0.),delta8(10,0.),
138  delta9(10,0.),delta10(10,0.);
139 
140  delta1(0) = 1.; delta2(1) = 1.; delta3(2) = 1.; delta4(3) = 1.;
141  delta5(4) = 1.; delta6(5) = 1.; delta7(6) = 1.; delta8(7) = 1.;
142  delta9(8) = 1.; delta10(9) = 1.;
143 
144  gslpp::vector<gslpp::complex> ** allcoeff = mySM.getMyFlavour()->ComputeCoeffDC1_K(
145  mySM.getBD().getMu(),
146  mySM.getBD().getScheme());
147 
148  std::cout << " Wilson coefficients SM+SUSY " << *allcoeff[LO] << std::endl;
149  std::cout << " Wilson coefficients SM+SUSY " << *allcoeff[NLO] << std::endl;
150 
151  a(0) = (*allcoeff[LO] + *allcoeff[NLO]) * delta3 + (*allcoeff[LO] + *allcoeff[NLO])
152  * delta4/3.;
153 
154  a(1) = (*allcoeff[LO] + *allcoeff[NLO]) * delta4 + (*allcoeff[LO] + *allcoeff[NLO])
155  * delta3/3.;
156 
157  a(2) = - 2./3./M_PI * (*allcoeff[LO] + *allcoeff[NLO]) * delta8 ;
158 
159  a(3) = (*allcoeff[LO] + *allcoeff[NLO]) * delta5 + (*allcoeff[LO] + *allcoeff[NLO])
160  * delta6/3.;
161 
162  a(4) = (*allcoeff[LO] + *allcoeff[NLO]) * delta6 + (*allcoeff[LO] + *allcoeff[NLO])
163  * delta5/3.;
164 
165  a(5) = - 2./9./M_PI *(*allcoeff[LO] + *allcoeff[NLO]) * delta8 ;
166 
167  std::cout << " a_3 -->" << a(0);
168  std::cout << " a_4 -->" << a(1);
169  std::cout << " a_4 cromo --> " << a(2);
170  std::cout << " a_5 --> " << a(3);
171  std::cout << " a_6 --> " << a(4);
172  std::cout << " a_6 cromo --> " << a(5);
173 
174  */
HeffDC1::HeffDC1
HeffDC1(const StandardModel &SM)
HeffDC1 constructor.
Definition: HeffDC1.cpp:13
WilsonTemplate::setScheme
void setScheme(schemes scheme)
Definition: WilsonTemplate.h:103
HeffDC1::ComputeCoeffDC1_pi
gslpp::vector< gslpp::complex > ** ComputeCoeffDC1_pi(double mu, schemes scheme=NDR)
a method returning the evolved Wilson related to
Definition: HeffDC1.cpp:43
EvolDC1Buras.h
EvolDC1
Evolutor Class
Definition: EvolDC1.h:24
LO
Definition: OrderScheme.h:33
HeffDC1::~HeffDC1
virtual ~HeffDC1()
HeffDC1 destructor.
Definition: HeffDC1.cpp:37
StandardModel.h
NDR
Definition: OrderScheme.h:21
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
HeffDC1::COEFF_K
gslpp::matrix< gslpp::complex > COEFF_K
Definition: HeffDC1.h:89
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:477
ModelMatching::CMd1
virtual std::vector< WilsonCoefficient > & CMd1()=0
WilsonTemplate::getOrder
orders getOrder() const
Definition: WilsonTemplate.h:65
HeffDC1::model
const StandardModel & model
Definition: HeffDC1.h:85
HeffDC1::ug
std::unique_ptr< EvolDC1 > ug
Definition: HeffDC1.h:87
WilsonCoefficient::setCoeff
void setCoeff(const gslpp::vector< gslpp::complex > &z, orders order_i)
Definition: WilsonCoefficient.h:34
schemes
schemes
An enum type for regularization schemes.
Definition: OrderScheme.h:19
StandardModel::getGF
double getGF() const
A get method to retrieve the Fermi constant .
Definition: StandardModel.h:739
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
WilsonTemplate::setMu
virtual void setMu(double mu)
Definition: WilsonTemplate.h:92
StandardModel::getVCKM
gslpp::matrix< gslpp::complex > getVCKM() const
A get method to retrieve the CKM matrix.
Definition: StandardModel.h:870
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
StandardModel::getMatching
virtual StandardModelMatching & getMatching() const
A get method to access the member reference of type StandardModelMatching.
Definition: StandardModel.h:952
HeffDC1::ComputeCoeffDC1_K
gslpp::vector< gslpp::complex > ** ComputeCoeffDC1_K(double mu, schemes scheme=NDR)
a method returning the evolved Wilson related to
Definition: HeffDC1.cpp:66
WilsonCoefficient::getCoeff
gslpp::vector< gslpp::complex > ** getCoeff() const
Definition: WilsonCoefficient.h:29
NLO
Definition: OrderScheme.h:34
HeffDC1::COEFF_pi
gslpp::matrix< gslpp::complex > COEFF_pi
Definition: HeffDC1.h:89
EvolDC1.h
EvolDC1Buras
Definition: EvolDC1Buras.h:15
HeffDC1::ckm
gslpp::matrix< gslpp::complex > ckm
Definition: HeffDC1.h:89
HeffDC1.h
gslpp::vector< gslpp::complex >
HeffDC1::coeffdc1
WilsonCoefficient coeffdc1
Definition: HeffDC1.h:86