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
EvolDB1bsg Class Reference

#include <EvolDB1bsg.h>

+ Inheritance diagram for EvolDB1bsg:

Detailed Description

Definition at line 14 of file EvolDB1bsg.h.

Public Member Functions

gslpp::matrix< double > AnomalousDimension_M (orders order, unsigned int n_u, unsigned int n_d) const
 a method returning the anomalous dimension matrix given in the Misiak basis More...
 
gslpp::matrix< double > & Df1Evolbsg (double mu, double M, orders order, schemes scheme=NDR)
 a method returning the evolutor related to the high scale \( M \) and the low scale \( \mu \) More...
 
 EvolDB1bsg (unsigned int dim, schemes scheme, orders order, const StandardModel &model)
 EvolDF1bsg constructor. More...
 
gslpp::matrix< double > ToEffectiveBasis (gslpp::matrix< double > mat) const
 a method returning the anomalous dimension for the evolution of the effective Wilson coefficients More...
 
gslpp::matrix< double > ToRescaleBasis (orders order, unsigned int n_u, unsigned int n_d) const
 a method returning the anomalous dimension in the Chetyrkin, Misiak and Munz operator basis More...
 
virtual ~EvolDB1bsg ()
 EvolDF1bsg destructor. More...
 
- Public Member Functions inherited from RGEvolutor
gslpp::matrix< double > * Evol (orders order)
 Evolution matrix set at a fixed order of QCD coupling. More...
 
gslpp::matrix< double > * Evol (orders_qed order_qed)
 Evolution matrix set at a fixed order of Electroweak coupling. More...
 
gslpp::matrix< double > ** getEvol () const
 
double getM () const
 Retrieve the upper scale of the Wilson Coefficients. More...
 
 RGEvolutor (unsigned int dim, schemes scheme, orders order)
 constructor More...
 
 RGEvolutor (unsigned int dim, schemes scheme, orders order, orders_qed order_qed)
 constructor More...
 
void setEvol (const gslpp::matrix< double > &m, orders order_i)
 
void setEvol (const gslpp::matrix< double > &m, orders_qed order_qed_i)
 
void setEvol (unsigned int i, unsigned int j, double x, orders order_i)
 
void setEvol (unsigned int i, unsigned int j, double x, orders order_i, orders_qed order_qed)
 
void setM (double M)
 Sets the upper scale for the running of the Wilson Coefficients. More...
 
void setMu (double mu)
 Sets the lower scale for the running of the Wilson Coefficients. More...
 
void setScales (double mu, double M)
 Sets the upper and lower scale for the running of the Wilson Coefficients. More...
 
virtual ~RGEvolutor ()
 destructor More...
 
- Public Member Functions inherited from WilsonTemplate< gslpp::matrix< double > >
double getMu () const
 
orders getOrder () const
 
orders_qed getOrder_qed () const
 
schemes getScheme () const
 
unsigned int getSize () const
 
virtual void resetCoefficient ()
 
void setScheme (schemes scheme)
 
 WilsonTemplate (const WilsonTemplate< gslpp::matrix< double > > &orig)
 
 WilsonTemplate (unsigned int dim, schemes scheme_i, orders order_i, orders_qed order_qed_i=NO_QED)
 
virtual ~WilsonTemplate ()
 

Private Member Functions

void Df1Evolbsg (double mu, double M, double nf, schemes scheme)
 a void type method storing properly the magic numbers for the implementation of the evolutor More...
 

Private Attributes

double a [3][13]
 
double alsMZ_cache
 
double b [3][13][13][13]
 
double c [3][13][13][13]
 
double c2 [3][13][13][13]
 
double d [3][13][13][13]
 
double d2 [3][13][13][13]
 
unsigned int dim
 
gslpp::vector< gslpp::complex > e
 
double e2 [3][13][13][13]
 
double f2 [3][13][13][13]
 
gslpp::matrix< gslpp::complex > gg
 
gslpp::matrix< gslpp::complex > gg2
 
gslpp::matrix< gslpp::complex > h
 
gslpp::matrix< gslpp::complex > h2
 
gslpp::matrix< gslpp::complex > j2v
 
gslpp::matrix< gslpp::complex > js
 
gslpp::matrix< gslpp::complex > js2
 
gslpp::matrix< gslpp::complex > jss
 
gslpp::matrix< gslpp::complex > jssv
 
gslpp::matrix< gslpp::complex > jv
 
const StandardModel & model
 
double Mz_cache
 
int nd
 
int nu
 
gslpp::matrix< gslpp::complex > s_s
 
gslpp::matrix< gslpp::complex > s_s2
 
gslpp::matrix< gslpp::complex > v
 
gslpp::matrix< gslpp::complex > vi
 
gslpp::matrix< gslpp::complex > vij
 
gslpp::matrix< gslpp::complex > vij2
 
gslpp::matrix< gslpp::complex > vijj
 

Additional Inherited Members

- Protected Member Functions inherited from WilsonTemplate< gslpp::matrix< double > >
gslpp::matrix< double > * Elem (orders order) const
 
gslpp::matrix< double > * Elem (orders_qed order_qed) const
 
void setElem (const gslpp::matrix< double > &v, orders order_i)
 
void setElem (const gslpp::matrix< double > &v, orders_qed order_qed_i)
 
- Protected Attributes inherited from RGEvolutor
double M
 
- Protected Attributes inherited from WilsonTemplate< gslpp::matrix< double > >
gslpp::matrix< double > * elem [MAXORDER_QED+1]
 
double mu
 
orders order
 
orders_qed order_qed
 
schemes scheme
 
unsigned int size
 

Constructor & Destructor Documentation

◆ EvolDB1bsg()

EvolDB1bsg::EvolDB1bsg ( unsigned int  dim,
schemes  scheme,
orders  order,
const StandardModel &  model 
)

EvolDF1bsg constructor.

Parameters
diman unsigned integer for the dimension of the evolutor
schemean enum "schemes" for the regularization scheme of the evolutor
orderan enum "orders" for the order of perturbation theory of the evolutor
modelan object of StandardModel class

Definition at line 12 of file EvolDB1bsg.cpp.

13 : RGEvolutor(dim_i, scheme, order), model(model),
14  v(dim_i,0.), vi(dim_i,0.), js(dim_i,0.), h(dim_i,0.), gg(dim_i,0.), s_s(dim_i,0.),
15  jssv(dim_i,0.), jss(dim_i,0.), jv(dim_i,0.), vij(dim_i,0.), gg2(dim_i,0.),
16  s_s2(dim_i,0.),h2(dim_i,0.),js2(dim_i,0.), j2v(dim_i,0.), vijj(dim_i,0.),
17  vij2(dim_i,0.), e(dim_i,0.), dim(dim_i)
18 {
19  if (dim != 8 ) throw std::runtime_error("ERROR: EvolDB1bsg can only be of dimension 8");
20 
21  /* magic numbers a & b */
22 
23  for(int L=2; L>-1; L--){
24 
25  /* L=2 --> u,d,s,c (nf=4) L=1 --> u,d,s,c,b (nf=5) L=0 --> u,d,s,c,b,t (nf=6) */
26 
27  nu = L; nd = L;
28  if(L == 1){nd = 3; nu = 2;}
29  if(L == 0){nd = 3; nu = 3;}
30 
31  // LO evolutor of the effective Wilson coefficients in the Chetyrkin, Misiak and Munz basis
32 
33  (ToEffectiveBasis(ToRescaleBasis(LO,nu,nd))).transpose().eigensystem(v,e);
34  vi = v.inverse();
35  for(unsigned int i = 0; i < dim; i++){
36  a[L][i] = e(i).real();
37  for (unsigned int j = 0; j < dim; j++) {
38  for (unsigned int k = 0; k < dim; k++) {
39  b[L][i][j][k] = v(i, k).real() * vi(k, j).real();
40  }
41  }
42  }
43 
44  // NLO evolutor of the effective Wilson coefficients in the Chetyrkin, Misiak and Munz basis
45 
46  gg = vi * (ToEffectiveBasis(ToRescaleBasis(NLO,nu,nd))).transpose() * v;
47  double b0 = model.Beta0(6-L);
48  double b1 = model.Beta1(6-L);
49  for (unsigned int i = 0; i < dim; i++){
50  for (unsigned int j = 0; j < dim; j++){
51  s_s.assign( i, j, (b1 / b0) * (i==j) * e(i).real() - gg(i,j));
52  if(fabs(e(i).real() - e(j).real() + 2. * b0)>0.00000000001){
53  h.assign( i, j, s_s(i,j) / (2. * b0 + e(i) - e(j)));
54  }
55  }
56  }
57  js = v * h * vi;
58  jv = js * v;
59  vij = vi * js;
60  jss = v * s_s * vi;
61  jssv = jss * v;
62  for (unsigned int i = 0; i < dim; i++){
63  for (unsigned int j = 0; j < dim; j++){
64  if(fabs(e(i).real() - e(j).real() + 2. * b0) > 0.00000000001){
65  for(unsigned int k = 0; k < dim; k++){
66  c[L][i][j][k] = jv(i, k).real() * vi(k, j).real();
67  d[L][i][j][k] = -v(i, k).real() * vij(k, j).real();
68  }
69  }
70  else{
71  for(unsigned int k = 0; k < dim; k++){
72  c[L][i][j][k] = (1./(2. * b0)) * jssv(i, k).real() * vi(k, j).real();
73  d[L][i][j][k] = 0.;
74  }
75  }
76  }
77  }
78  gg2 = vi * ( AnomalousDimension_M(NNLO,nu,nd).transpose() ) * v ;
79  double b2 = model.Beta2(nu+nd);
80  for (unsigned int i = 0; i < dim; i++){
81  for (unsigned int j = 0; j < dim; j++){
82  gslpp::complex s_s2_temp = 0.;
83  for (unsigned int k = 0; k < dim; k++){
84  s_s2_temp += (2. * b0 + e(i).real() - e(k).real()) *
85  ( h(i,k) * h(k,j) - b1/b0 * h(i,j) * (j==k) );
86  }
87  s_s2.assign( i, j, s_s2_temp + b2/b0 * (i==j) * e(i).real() - gg2(i,j));
88  if(fabs(e(i).real() - e(j).real() + 4. * b0)>0.00000000001){
89  h2.assign( i, j, s_s2(i,j) / (4. * b0 + e(i) - e(j)));
90  }
91  else{
92  throw std::runtime_error("EvolDF1bsg::EvolDF1bsg(): singular case at NNLO not yet implemented!");
93  }
94  }
95  }
96  js2 = v * h2 * vi;
97  j2v = js2 * v;
98  vijj = vij * js;
99  vij2 = vi * js2;
100  for (unsigned int i = 0; i < dim; i++){
101  for (unsigned int j = 0; j < dim; j++){
102  for(unsigned int k = 0; k < dim; k++){
103  c2[L][i][j][k] = j2v(i, k).real() * vi(k, j).real();
104  d2[L][i][j][k] = -jv(i, k).real() * vij(k, j).real();
105  e2[L][i][j][k] = +v(i, k).real() * vijj(k, j).real();
106  f2[L][i][j][k] = - v(i, k).real() * vij2(k, j).real();
107  }
108  }
109  }
110  }
111 }

◆ ~EvolDB1bsg()

EvolDB1bsg::~EvolDB1bsg ( )
virtual

EvolDF1bsg destructor.

Definition at line 113 of file EvolDB1bsg.cpp.

114 {}

Member Function Documentation

◆ AnomalousDimension_M()

gslpp::matrix< double > EvolDB1bsg::AnomalousDimension_M ( orders  order,
unsigned int  n_u,
unsigned int  n_d 
) const

a method returning the anomalous dimension matrix given in the Misiak basis

Parameters
orderan enum "orders" for the order of perturbation theory of the ADM
n_uan unsigned integer for the up-type number of d.o.f.
n_dan unsigned integer for the down-type number of d.o.f.
Returns
the ADM at the order LO/NLO in the Misiak basis

Definition at line 116 of file EvolDB1bsg.cpp.

117 {
118 
119  /* Delta F = 1 anomalous dimension in Misiak basis,
120  ref.: M. Misiak, Nucl. Phys. B393 (1993) 23, B439 (1995) 461 (E),
121  A.J. Buras and M. Munz, Phys. Rev. D52 (1995) 186. */
122 
123  /* gamma(row, coloumn) at the LO */
124 
125  unsigned int nf = n_u + n_d; /*n_u/d = active type up/down flavor d.o.f.*/
126  double z3 = gsl_sf_zeta_int(3);
127 
128  gslpp::matrix<double> gammaDF1(dim, dim, 0.);
129 
130  switch(order){
131 
132  case LO:
133 
134  gammaDF1(0,0) = -4. ;
135  gammaDF1(0,1) = 8./3. ;
136  gammaDF1(0,3) = -2./9.;
137 
138  gammaDF1(1,0) = 12.;
139  gammaDF1(1,3) = 4./3.;
140 
141  gammaDF1(2,3) = -52./3.;
142  gammaDF1(2,5) = 2.;
143 
144  gammaDF1(3,2) = -40./9.;
145  gammaDF1(3,3) = -160./9. + 4./3.*nf;
146  gammaDF1(3,4) = 4./9.;
147  gammaDF1(3,5) = 5./6.;
148 
149  gammaDF1(4,3) = -256./3.;
150  gammaDF1(4,5) = 20.;
151 
152  gammaDF1(5,2) = -256./9.;
153  gammaDF1(5,3) = -544./9. + (40./3.)*nf;
154  gammaDF1(5,4) = 40./9.;
155  gammaDF1(5,5) = -2./3.;
156 
157  gammaDF1(6,6) = 32./3. - 2.*model.Beta0(nf);
158 
159  gammaDF1(7,6) = -32./9.;
160  gammaDF1(7,7) = 28./3. - 2.*model.Beta0(nf);
161 
162  break;
163  case NLO:
164 
165  if (!(nf == 3 || nf == 4 || nf == 5 || nf == 6)){
166  throw std::runtime_error("EvolDF1::AnomalousDimension_M(): wrong number of flavours");
167  }
168 
169  /* gamma(row, coloumn) at the NLO */
170 
171  gammaDF1(0,0) = -145./3. + (16./9.)*nf;
172  gammaDF1(0,1) = -26. + (40./27.)*nf;
173  gammaDF1(0,2) = -1412./243.;
174  gammaDF1(0,3) = -1369./243.;
175  gammaDF1(0,4) = 134./243.;
176  gammaDF1(0,5) = -35./162.;
177  gammaDF1(0,6) = -232./243.;
178  gammaDF1(0,7) = 167./162.;
179 
180  gammaDF1(1,0) = -45. + (20./3.)*nf;
181  gammaDF1(1,1) = -28./3.;
182  gammaDF1(1,2) = -416./81.;
183  gammaDF1(1,3) = 1280./81.;
184  gammaDF1(1,4) = 56./81.;
185  gammaDF1(1,5) = 35./27.;
186  gammaDF1(1,6) = 464./81.;
187  gammaDF1(1,7) = 76./27.;
188 
189  gammaDF1(2,2) = -4468./81.;
190  gammaDF1(2,3) = -29129./81. - (52./9.)*nf;
191  gammaDF1(2,4) = 400./81.;
192  gammaDF1(2,5) = 3493./108. - (2./9.)*nf;
193  gammaDF1(2,6) = 64./81.;
194  gammaDF1(2,7) = 368./27.;
195 
196  gammaDF1(3,2) = -13678./243. + (368.*nf)/81.;
197  gammaDF1(3,3) = -79409./243. + (1334.*nf)/81.;
198  gammaDF1(3,4) = 509./486. - (8.*nf)/81.;
199  gammaDF1(3,5) = 13499./648. - (5.*nf)/27.;
200  gammaDF1(3,6) = -680./243. + (32.*nf)/81;
201  gammaDF1(3,7) = -427./81. - (37.*nf)/54.;
202 
203  gammaDF1(4,2) = -244480./81. - (160./9.)*nf;
204  gammaDF1(4,3) = -29648./81. - (2200./9.)*nf;
205  gammaDF1(4,4) = 23116./81. + (16./9.)*nf;
206  gammaDF1(4,5) = 3886./27. + (148./9.)*nf;
207  gammaDF1(4,6) = -6464./81.;
208  gammaDF1(4,7) = 8192./27. + 36.*nf;
209 
210  gammaDF1(5,2) = 77600./243. - (1264./81.)*nf;
211  gammaDF1(5,3) = -28808./243. + (164./81.)*nf;
212  gammaDF1(5,4) = -20324./243. + (400./81.)*nf;
213  gammaDF1(5,5) = -21211./162.+ (622./27.)*nf;
214  gammaDF1(5,6) = -20096./243. - (976.*n_d)/81. + (2912.*n_u)/81.;
215  gammaDF1(5,7) = -6040./81. + (220./27.)*nf;
216 
217  gammaDF1(6,6) = 1936./9.-224./27.*nf-2*model.Beta1(nf);
218 
219  gammaDF1(7,6) = -368./9.+224./81.*nf;
220  gammaDF1(7,7) = 1456./9.-61./27.*nf-2*model.Beta1(nf);
221 
222  break;
223  case NNLO:
224 
225  if (!(nf == 3 || nf == 4 || nf == 5 || nf == 6)){
226  throw std::runtime_error("EvolDF1::AnomalousDimension_M(): wrong number of flavours");
227  }
228 
229  // ADM -- already given in the effective and rescaled basis -- @ NNLO
230 
231  // See hep-ph/0411071 for the mixing among Q1-Q6 @ NNLO hep-ph/0504194
232 
233  gammaDF1(0,0) = -1927./2.+40./9.*(n_d*n_d+n_u*n_u)+224.*z3+(257./9.+160./3.*z3)*n_u+(257./9.+80./9.*n_u+160./3.*z3)*n_d;
234  gammaDF1(0,1) = 475./9.-40./27.*n_d*n_d-40./27.*n_u*n_u+(362./27.-320./9.*z3)*n_u+(362./27.-80./27.*n_u-320./9.*z3)*n_d-896./3.*z3;
235  gammaDF1(0,2) = 269107./13122.-2288./729.*nf-1360./81.*z3;
236  gammaDF1(0,3) = -2425817./13122.+30815./4374.*nf-776./81.*z3;
237  gammaDF1(0,4) = -343783./52488.+392./729.*nf+124./81.*z3;
238  gammaDF1(0,5) = -37573./69984.+35./972.*nf+100./27.*z3;
239 
240  gammaDF1(1,0) = 307./2.-20./3.*(n_d*n_d+n_u*n_u)+(361./3.-160.*z3)*n_u+(361./3.-40./3.*n_u-160.*z3)*n_d-1344*z3;
241  gammaDF1(1,1) = 1298./3.-76./3.*nf-224.*z3;
242  gammaDF1(1,2) = 69797./2187.+904./243.*nf+2720./27.*z3;
243  gammaDF1(1,3) = 1457549./8748.-22067./729.*nf-2768./27.*z3;
244  gammaDF1(1,4) = -37889./8748.-28./243.*nf-248./27.*z3;
245  gammaDF1(1,5) = 366919./11664.-35./162.*nf-110./9.*z3;
246 
247  gammaDF1(2,2) = -4203068./2187.+14012./243.*nf-608./27.*z3;
248  gammaDF1(2,3) = -18422762./2187.+888605./2916. *nf+272./27.*nf*nf+(39824./27. + 160.*nf)*z3;
249  gammaDF1(2,4) = 674281./4374.-1352./243.*nf-496./27.*z3;
250  gammaDF1(2,5) = 9284531./11664.-26./27.*(n_d*n_d+n_u*n_u)+(-2798./81.-20.*z3)*n_u+(-2798./81.-52./27.*n_u-20.*z3)*n_d-1921./9.*z3;
251 
252  gammaDF1(3,2) = -5875184./6561.+217892./2187.*nf+472./81.*nf*nf+(27520./81.+1360./9.*nf)*z3;
253  gammaDF1(3,3) = -70274587./13122.+8860733./17496.*nf-4010./729.*nf*nf+(16592./81.+2512./27.*nf)*z3;
254  gammaDF1(3,4) = 2951809./52488.-52./81.*(n_d*n_d+n_u*n_u)+(-31175./8748.-136./9.*z3)*n_u+(-31175./8748.-104./81.*n_u-136./9.*z3)*n_d-3154./81.*z3;
255  gammaDF1(3,5) = 3227801./8748.-65./54.*(n_d*n_d+n_u*n_u)+(-105293./11664.-220./9.*z3)*n_u+(-105293./11664.-65./27.*n_u-220./9.*z3)*n_d+200./27.*z3;
256 
257  gammaDF1(4,2) = -194951552./2187.+358672./81.*nf-2144./81.*nf*nf+87040./27.*z3;
258  gammaDF1(4,3) = -130500332./2187.+3088/27.*(n_d*n_d+n_u*n_u)+238016./27.*z3+(-2949616./729.+640.*z3)*n_u+(-2949616./729.+6176./27.*n_u+640.*z3)*n_d;
259  gammaDF1(4,4) = 14732222./2187.+272./81.*(n_d*n_d+n_u*n_u)-27428./81.*n_u+(-27428./81.+544./81.*n_u)*n_d-13984./27.*z3;
260  gammaDF1(4,5) = 16521659./2916.-316./27.*(n_d*n_d+n_u*n_u)+(8081./54.-200.*z3)*n_u+(8081./54.-632./27.*n_u-200.*z3)*n_d-22420./9.*z3;
261 
262  gammaDF1(5,2) = 162733912./6561.+17920./243.*(n_d*n_d+n_u*n_u)+174208./81.*z3+(-2535466./2187.+12160./9.*z3)*n_u+(-2535466./2187.+35840./243.*n_u+12160./9.*z3)*n_d;
263  gammaDF1(5,3) = 13286236./6561.-159548./729.*(n_d*n_d+n_u*n_u)+(-1826023./4374.-9440./27.*z3)*n_u+(-1826023./4374.-319096./729.*n_u-9440./27.*z3)*n_d-24832./81.*z3;
264  gammaDF1(5,4) = -22191107./13122.+395783./4374.*nf-1720./243.*nf*nf-(33832./81.+1360./9.*nf)*z3;
265  gammaDF1(5,5) = -32043361./8748.+3353393./5832.*nf-533./81.*nf*nf+(9248./27.-1120./9.*nf)*z3;
266 
267  // See hep-ph/0612329 for the mixing of Q1-Q6 into Q7-Q8 @ NNLO
268 
269  gammaDF1(0,6) = 77506102./531441. - 875374./177147.*nf + 560./19683.*nf*nf - 9731./162.*(2./3.) + 11045./729.*nf*(2./3.) + 316./729.*nf*nf*(2./3.) + 3695./486.*(1./3.);
270  gammaDF1(0,6) += z3*(-112216./6561. + 728./729.*nf + 25508./81.*(2./3.) - 64./81.*nf*(2./3.)-100./27.*(1./3.));
271  gammaDF1(1,6) = -15463055./177147. + 242204./59049.*nf - 1120./6561.*nf*nf + 55748./27.*(2./3.) - 33970./243.*nf*(2./3.) - 632./243.*nf*nf*(2./3.) - 3695./81.*(1./3.);
272  gammaDF1(1,6) += z3*(365696./2187. - 1168./243.*nf - 51232./27.*(2./3.) - 1024./27.*nf*(2./3.) + 200./9.*(1./3.));
273  gammaDF1(2,6) = 102439553./177147. - 12273398./59049.*nf + 5824./6561.*nf*nf + 26639./81.*(1./3.) - 8./27.*nf*(1./3.) ;
274  gammaDF1(2,6) += z3*(3508864./2187. - 1904./243.*nf - 1984./9.*(1./3.) -64./9.*nf*(1./3.));
275  gammaDF1(3,6) = -2493414077./1062882. - 9901031./354294.*nf + 243872./59049.*nf*nf - 1184./6561.*nf*nf*nf - 49993./972.*(1./3.) + 305./27.*nf*(1./3.);
276  gammaDF1(3,6) += z3*(-1922264./6561. + 308648./2187.*nf - 1280./243.*nf*nf + 1010./9.*(1./3.) - 200./27.*nf*(1./3.));
277  gammaDF1(4,6) = 8808397748./177147. - 174839456./59049.*nf + 1600./729.*nf*nf - 669694./81.*(1./3.) + 10672./27.*nf*(1./3.);
278  gammaDF1(4,6) += z3*(123543040./2187. - 207712./243.*nf + 128./27.*nf*nf - 24880./9.*(1./3.) - 640./9.*nf*(1./3.));
279  gammaDF1(5,6) = 7684242746./531441. - 351775414./177147.*nf - 479776./59049.*nf*nf - 11456./6561.*nf*nf*nf + 3950201./243.*(1./3.) - 130538./81.*nf*(1./3.) - 592./81.*nf*nf*(1./3.);
280  gammaDF1(5,6) += z3*(7699264./6561. + 2854976./2187.*nf - 12320./243.*nf*nf - 108584./9.*(1./3.) - 1136./27.*nf*(1./3.));
281 
282  gammaDF1(0,7) = -421272953./1417176. - 8210077./472392.*nf - 1955./6561.*nf*nf + z3*(-953042./2187. - 10381./486.*nf);
283  gammaDF1(1,7) = 98548513./472392 - 5615165./78732.*nf - 2489./2187.*nf*nf + z3*(-607103./729. - 1679./81.*nf);
284  gammaDF1(2,7) = 3205172129./472392. - 108963529./314928.*nf+58903./4374.*nf*nf + z3*(-1597588./729. + 13028./81.*nf - 20./9.*nf*nf);
285  gammaDF1(3,7) = -6678822461./2834352. + 127999025./1889568.*nf + 1699073./157464.*nf*nf + 505./4374.*nf*nf*nf + z3*(2312684./2187. + 128347./729.*nf + 920./81.*nf*nf) ;
286  gammaDF1(4,7) = 29013624461./118098. - 64260772./19683.*nf - 230962./243.*nf*nf - 148./27.*nf*nf*nf + z3*(-69359224./729. - 885356./81.*nf -5080./9.*nf*nf);
287  gammaDF1(5,7) = -72810260309./708588. + 2545824851./472392.*nf - 33778271./78732.*nf*nf - 3988./2187.*nf*nf*nf + z3*(-61384768./2187. - 685472./729.*nf +350./81.*nf*nf);
288 
289  // See hep-ph/0504194 for the mixing among Q7-Q8 @ NNLO
290 
291  gammaDF1(6,6) = 307448./81.-23776./81.*nf-352./81.*nf*nf+(-1856./27.-1280./9.*nf)*z3;
292  gammaDF1(7,6) = -164672./243.+17108./243.*nf+352./243.*nf*nf+(3776./81.+1280./27.*nf)*z3;
293  gammaDF1(7,7) = 268807./81.-4343./27.*nf-461./81.*nf*nf+(-28624./27.-1312./9.*nf)*z3;
294 
295  break;
296  default:
297  throw std::runtime_error("EvolDF1bsg::AnomalousDimension_M(): order not implemented");
298  }
299  return (gammaDF1);
300 }

◆ Df1Evolbsg() [1/2]

void EvolDB1bsg::Df1Evolbsg ( double  mu,
double  M,
double  nf,
schemes  scheme 
)
private

a void type method storing properly the magic numbers for the implementation of the evolutor

Parameters
mua double for the low scale of the evolution
Ma double for the high scale of the evolution
nfa double for the active number of flavors
schemean enum "schemes" for the regularization scheme of the evolutor

Definition at line 436 of file EvolDB1bsg.cpp.

437  {
438 
439  gslpp::matrix<double> resLO(dim, 0.), resNLO(dim, 0.), resNNLO(dim, 0.);
440 
441  int L = 6 - (int) nf;
442  double alsM = model.Alstilde5(M);
443  double alsmu = model.Alstilde5(mu);
444 
445  double eta = alsM / alsmu;
446 
447  for (unsigned int k = 0; k < dim; k++) {
448  double etap = pow(eta, a[L][k] / 2. / model.Beta0(nf));
449  for (unsigned int i = 0; i < dim; i++){
450  for (unsigned int j = 0; j < dim; j++) {
451  resNNLO(i, j) += c2[L][i][j][k] * etap * alsmu * alsmu;
452  resNNLO(i, j) += d2[L][i][j][k] * etap * alsmu * alsM;
453  resNNLO(i, j) += e2[L][i][j][k] * etap * alsM * alsM;
454  resNNLO(i, j) += f2[L][i][j][k] * etap * alsM * alsM;
455  if(fabs(e(i).real() - e(j).real() + 2. * model.Beta0(nf))>0.000000000001) {
456  resNLO(i, j) += c[L][i][j][k] * etap * alsmu;
457  resNLO(i, j) += d[L][i][j][k] * etap * alsM;
458  }
459  else{
460  resNLO(i, j) += - c[L][i][j][k] * etap * alsmu * log(eta);
461  }
462  resLO(i, j) += b[L][i][j][k] * etap;
463  if (fabs(resLO(i, j)) <= 1.e-12) {resLO(i, j) = 0.;}
464  if (fabs(resNLO(i, j)) <= 1.e-12) {resNLO(i, j) = 0.;}
465  if (fabs(resNNLO(i, j)) <= 1.e-12) {resNNLO(i, j) = 0.;}
466  }
467  }
468  }
469 
470  switch(order) {
471  case NNLO:
472  *elem[NNLO] = (*elem[LO]) * resNNLO + (*elem[NLO]) * resNLO + (*elem[NNLO]) * resLO;
473  case NLO:
474  *elem[NLO] = (*elem[LO]) * resNLO + (*elem[NLO]) * resLO;
475  case LO:
476  *elem[LO] = (*elem[LO]) * resLO;
477  break;
478  case FULLNNLO:
479  case FULLNLO:
480  default:
481  throw std::runtime_error("Error in EvolDF1bsg::Df1Evolbsg()");
482  }
483 
484  }

◆ Df1Evolbsg() [2/2]

gslpp::matrix< double > & EvolDB1bsg::Df1Evolbsg ( double  mu,
double  M,
orders  order,
schemes  scheme = NDR 
)

a method returning the evolutor related to the high scale \( M \) and the low scale \( \mu \)

Parameters
mua double for the low scale of the evolution
Ma double for the high scale of the evolution
orderan enum "orders" for the order of perturbation theory of the evolutor
schemean enum "schemes" for the regularization scheme of the evolutor
Returns
the evolutor \( U (\mu , M) \)

Definition at line 388 of file EvolDB1bsg.cpp.

389 {
390 
391  switch (scheme) {
392  case NDR:
393  break;
394  case LRI:
395  case HV:
396  default:
397  std::stringstream out;
398  out << scheme;
399  throw std::runtime_error("EvolDF1bsg::Df1Evolbsg(): scheme " + out.str() + " not implemented ");
400  }
401 
402  double alsMZ = model.getAlsMz();
403  double Mz = model.getMz();
404  if(alsMZ == alsMZ_cache && Mz == Mz_cache) {
405  if (mu == this->mu && M == this->M && scheme == this->scheme)
406  return (*Evol(order));
407  }
408  alsMZ_cache = alsMZ;
409  Mz_cache = Mz;
410 
411  if (M < mu) {
412  std::stringstream out;
413  out << "M = " << M << " < mu = " << mu;
414  throw out.str();
415  }
416 
417  setScales(mu, M); // also assign evol to identity
418  if (M != mu) {
419  double m_down = mu;
420 // double m_up = model.AboveTh(m_down);
421  double nf = 5;//model.Nf(m_down); b to s gamma is always 5 flavour. This erroneously makes the evolutor cross thresholds.
422 
423 // while (m_up < M) {
424 // Df1Evolbsg(m_down, m_up, nf, scheme);
425 // m_down = m_up;
426 // m_up = model.AboveTh(m_down);
427 // nf += 1.;
428 // } This code is commented out since it is not necessary unless thresholds are crossed.
429  Df1Evolbsg(m_down, M, nf, scheme);
430  }
431 
432  return (*Evol(order));
433 
434 }

◆ ToEffectiveBasis()

gslpp::matrix< double > EvolDB1bsg::ToEffectiveBasis ( gslpp::matrix< double >  mat) const

a method returning the anomalous dimension for the evolution of the effective Wilson coefficients

Parameters
mata temporary variable of gslpp::matrix type
Returns
the ADM at the order LO/NLO for the effective Wilson coefficients

Definition at line 360 of file EvolDB1bsg.cpp.

361 {
362 
363  gslpp::matrix<double> y(dim, 0.);
364 
365  y(0,0) = 1.;
366  y(1,1) = 1.;
367  y(2,2) = 1.;
368  y(3,3) = 1.;
369  y(4,4) = 1.;
370  y(5,5) = 1.;
371  y(6,6) = 1.;
372  y(7,7) = 1.;
373 
374  y(6,2) = -1./3.;
375  y(6,3) = -4./9.;
376  y(6,4) = -20./3.;
377  y(6,5) = -80./9.;
378 
379  y(7,2) = 1.;
380  y(7,3) = -1./6.;
381  y(7,4) = 20.;
382  y(7,5) = -10./3.;
383 
384  return( (y.inverse()).transpose() * mat * y.transpose() );
385 
386 }

◆ ToRescaleBasis()

gslpp::matrix< double > EvolDB1bsg::ToRescaleBasis ( orders  order,
unsigned int  n_u,
unsigned int  n_d 
) const

a method returning the anomalous dimension in the Chetyrkin, Misiak and Munz operator basis

Parameters
orderan enum "orders" for the order of perturbation theory of the evolutor
n_uan unsigned integer for the up-type number of d.o.f.
n_dan unsigned integer for the down-type number of d.o.f.
Returns
the ADM at the order LO/NLO in the Chetyrkin, Misiak and Munz basis

Definition at line 302 of file EvolDB1bsg.cpp.

303 {
304 
305  /* matrix entries for the anomalous dimension in the Chetyrkin, Misiak and Munz basis,
306  ref. hep-ph/9711280v1, hep-ph/0306079 */
307 
308  gslpp::matrix<double> mat(dim, 0.);
309  gslpp::matrix<double> mat1(dim, 0.);
310  unsigned int nf = n_u + n_d;
311 
312  mat1(0,6) = - 13454./2187. + 44./2187.*nf;
313  mat1(1,6) = 20644./729. - 88./729.*nf;
314  mat1(2,6) = 119456./729. + 5440./729.*n_d -21776./729.*n_u;
315  mat1(3,6) = - 202990./2187. + 32./729.*n_d*n_d + n_d*(16888./2187. + 64./729.*n_u) - 17132./2187.*n_u + 32./729.*n_u*n_u;
316  mat1(4,6) = 530240./243. + 300928./729.*n_d - 461120./729.*n_u;
317  mat1(5,6) = - 1112344./729. + 5432./729.*n_d*n_d + n_d*(419440./2187. - 2744./729.*n_u) + 143392./2187.*n_u - 8176./729.*n_u*n_u;
318 
319  mat1(0,7) = 25759./5832. + 431./5832.*nf;
320  mat1(1,7) = 9733./486. - 917./972.*nf;
321  mat1(2,7) = 82873./243. - 3361./243.*nf;
322  mat1(3,7) = - 570773./2916. - 253./486.*n_d*n_d +n_d*(-40091./5832. - 253./243.*n_u) - 40091./5832.*n_u - 253./486.*n_u*n_u;
323  mat1(4,7) = 838684./81. - 14.*n_d*n_d + n_d*(129074./243. - 28.*n_u) + 129074./243.*n_u - 14.*n_u*n_u;
324  mat1(5,7) = - 923522./243. - 6031./486.*n_d*n_d + n_d*(-13247./1458. - 6031./243.*n_u) - 13247./1458.*n_u - 6031./486.*n_u*n_u;
325 
326 
327  switch(order){
328  case(NLO):
329  mat = AnomalousDimension_M(NLO, n_u, n_d);
330  for (int i=0; i<6; i++){
331  for (unsigned int j=6; j<dim; j++){
332  mat(i,j) = mat1(i,j);
333  }
334  }
335  for (unsigned int i=6; i<dim; i++){
336  for (unsigned int j=6; j<dim; j++){
337  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta1(nf);
338  }
339  }
340  return (mat);
341  case(LO):
342  mat = AnomalousDimension_M(LO, n_u, n_d);
343  for (int i=0; i<6; i++){
344  for (unsigned int j=6; j<dim; j++){
345  mat(i,j) = AnomalousDimension_M(NLO, n_u, n_d)(i,j);
346  }
347  }
348  for (unsigned int i=6; i<dim; i++){
349  for (unsigned int j=6; j<dim; j++){
350  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta0(nf);
351  }
352  }
353  return (mat);
354  default:
355  throw std::runtime_error("change to rescaled operator basis: order not implemented");
356  }
357 
358 }

Member Data Documentation

◆ a

double EvolDB1bsg::a[3][13]
private
Parameters
aarray of double for the magic numbers of the evolutor ( LO evolution )
barray of double for the magic numbers of the evolutor ( LO evolution )
carray of double for the magic numbers of the evolutor ( NLO evolution, associated to \( \alpha_{strong}(\mu) \) )
darray of double for the magic numbers of the evolutor ( NLO evolution, associated to \( \alpha_{strong}(M) \) )

Definition at line 82 of file EvolDB1bsg.h.

◆ alsMZ_cache

double EvolDB1bsg::alsMZ_cache
private

Definition at line 95 of file EvolDB1bsg.h.

◆ b

double EvolDB1bsg::b[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ c

double EvolDB1bsg::c[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ c2

double EvolDB1bsg::c2[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ d

double EvolDB1bsg::d[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ d2

double EvolDB1bsg::d2[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ dim

unsigned int EvolDB1bsg::dim
private

Definition at line 94 of file EvolDB1bsg.h.

◆ e

gslpp::vector<gslpp::complex> EvolDB1bsg::e
private

Definition at line 93 of file EvolDB1bsg.h.

◆ e2

double EvolDB1bsg::e2[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ f2

double EvolDB1bsg::f2[3][13][13][13]
private

Definition at line 82 of file EvolDB1bsg.h.

◆ gg

gslpp::matrix<gslpp::complex> EvolDB1bsg::gg
private

Definition at line 92 of file EvolDB1bsg.h.

◆ gg2

gslpp::matrix<gslpp::complex> EvolDB1bsg::gg2
private

Definition at line 92 of file EvolDB1bsg.h.

◆ h

gslpp::matrix<gslpp::complex> EvolDB1bsg::h
private

Definition at line 92 of file EvolDB1bsg.h.

◆ h2

gslpp::matrix<gslpp::complex> EvolDB1bsg::h2
private

Definition at line 92 of file EvolDB1bsg.h.

◆ j2v

gslpp::matrix<gslpp::complex> EvolDB1bsg::j2v
private

Definition at line 92 of file EvolDB1bsg.h.

◆ js

gslpp::matrix<gslpp::complex> EvolDB1bsg::js
private

Definition at line 92 of file EvolDB1bsg.h.

◆ js2

gslpp::matrix<gslpp::complex> EvolDB1bsg::js2
private

Definition at line 92 of file EvolDB1bsg.h.

◆ jss

gslpp::matrix<gslpp::complex> EvolDB1bsg::jss
private

Definition at line 92 of file EvolDB1bsg.h.

◆ jssv

gslpp::matrix<gslpp::complex> EvolDB1bsg::jssv
private

Definition at line 92 of file EvolDB1bsg.h.

◆ jv

gslpp::matrix<gslpp::complex> EvolDB1bsg::jv
private

Definition at line 92 of file EvolDB1bsg.h.

◆ model

const StandardModel& EvolDB1bsg::model
private

Definition at line 83 of file EvolDB1bsg.h.

◆ Mz_cache

double EvolDB1bsg::Mz_cache
private

Definition at line 96 of file EvolDB1bsg.h.

◆ nd

int EvolDB1bsg::nd
private

Definition at line 75 of file EvolDB1bsg.h.

◆ nu

int EvolDB1bsg::nu
private
Parameters
nuan unsigned integer for the up-type number of d.o.f.
nuan unsigned integer for the down-type number of d.o.f.

Definition at line 75 of file EvolDB1bsg.h.

◆ s_s

gslpp::matrix<gslpp::complex> EvolDB1bsg::s_s
private

Definition at line 92 of file EvolDB1bsg.h.

◆ s_s2

gslpp::matrix<gslpp::complex> EvolDB1bsg::s_s2
private

Definition at line 92 of file EvolDB1bsg.h.

◆ v

gslpp::matrix<gslpp::complex> EvolDB1bsg::v
private

Definition at line 92 of file EvolDB1bsg.h.

◆ vi

gslpp::matrix<gslpp::complex> EvolDB1bsg::vi
private

Definition at line 92 of file EvolDB1bsg.h.

◆ vij

gslpp::matrix<gslpp::complex> EvolDB1bsg::vij
private

Definition at line 92 of file EvolDB1bsg.h.

◆ vij2

gslpp::matrix<gslpp::complex> EvolDB1bsg::vij2
private

Definition at line 92 of file EvolDB1bsg.h.

◆ vijj

gslpp::matrix<gslpp::complex> EvolDB1bsg::vijj
private

Definition at line 92 of file EvolDB1bsg.h.

The documentation for this class was generated from the following files:
WilsonTemplate< gslpp::matrix< double > >::scheme
schemes scheme
Definition: WilsonTemplate.h:117
EvolDB1bsg::h2
gslpp::matrix< gslpp::complex > h2
Definition: EvolDB1bsg.h:92
EvolDB1bsg::d
double d[3][13][13][13]
Definition: EvolDB1bsg.h:82
EvolDB1bsg::Mz_cache
double Mz_cache
Definition: EvolDB1bsg.h:96
EvolDB1bsg::vijj
gslpp::matrix< gslpp::complex > vijj
Definition: EvolDB1bsg.h:92
gslpp::matrix< double >
A class for constructing and defining operations on real matrices.
Definition: gslpp_matrix_double.h:48
QCD::Beta1
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:471
WilsonTemplate< gslpp::matrix< double > >::mu
double mu
Definition: WilsonTemplate.h:116
EvolDB1bsg::vij2
gslpp::matrix< gslpp::complex > vij2
Definition: EvolDB1bsg.h:92
RGEvolutor::M
double M
Definition: RGEvolutor.h:142
StandardModel::getAlsMz
double getAlsMz() const
A get method to access the value of .
Definition: StandardModel.h:730
WilsonTemplate< gslpp::matrix< double > >::order
orders order
Definition: WilsonTemplate.h:118
EvolDB1bsg::d2
double d2[3][13][13][13]
Definition: EvolDB1bsg.h:82
LO
Definition: OrderScheme.h:33
EvolDB1bsg::jv
gslpp::matrix< gslpp::complex > jv
Definition: EvolDB1bsg.h:92
NDR
Definition: OrderScheme.h:21
gslpp::matrix< double >::transpose
matrix< double > transpose() const
Definition: gslpp_matrix_double.cpp:166
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
EvolDB1bsg::model
const StandardModel & model
Definition: EvolDB1bsg.h:83
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
EvolDB1bsg::js2
gslpp::matrix< gslpp::complex > js2
Definition: EvolDB1bsg.h:92
EvolDB1bsg::s_s
gslpp::matrix< gslpp::complex > s_s
Definition: EvolDB1bsg.h:92
EvolDB1bsg::vi
gslpp::matrix< gslpp::complex > vi
Definition: EvolDB1bsg.h:92
StandardModel::Alstilde5
double Alstilde5(const double mu) const
The value of at any scale with the number of flavours and full EW corrections.
Definition: StandardModel.cpp:899
EvolDB1bsg::vij
gslpp::matrix< gslpp::complex > vij
Definition: EvolDB1bsg.h:92
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:466
QCD::Beta2
double Beta2(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:476
EvolDB1bsg::b
double b[3][13][13][13]
Definition: EvolDB1bsg.h:82
EvolDB1bsg::AnomalousDimension_M
gslpp::matrix< double > AnomalousDimension_M(orders order, unsigned int n_u, unsigned int n_d) const
a method returning the anomalous dimension matrix given in the Misiak basis
Definition: EvolDB1bsg.cpp:116
EvolDB1bsg::e2
double e2[3][13][13][13]
Definition: EvolDB1bsg.h:82
EvolDB1bsg::js
gslpp::matrix< gslpp::complex > js
Definition: EvolDB1bsg.h:92
EvolDB1bsg::dim
unsigned int dim
Definition: EvolDB1bsg.h:94
EvolDB1bsg::j2v
gslpp::matrix< gslpp::complex > j2v
Definition: EvolDB1bsg.h:92
EvolDB1bsg::a
double a[3][13]
Definition: EvolDB1bsg.h:82
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
EvolDB1bsg::c
double c[3][13][13][13]
Definition: EvolDB1bsg.h:82
EvolDB1bsg::c2
double c2[3][13][13][13]
Definition: EvolDB1bsg.h:82
NNLO
Definition: OrderScheme.h:35
EvolDB1bsg::jssv
gslpp::matrix< gslpp::complex > jssv
Definition: EvolDB1bsg.h:92
EvolDB1bsg::alsMZ_cache
double alsMZ_cache
Definition: EvolDB1bsg.h:95
EvolDB1bsg::s_s2
gslpp::matrix< gslpp::complex > s_s2
Definition: EvolDB1bsg.h:92
EvolDB1bsg::gg
gslpp::matrix< gslpp::complex > gg
Definition: EvolDB1bsg.h:92
LRI
Definition: OrderScheme.h:23
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:721
EvolDB1bsg::ToRescaleBasis
gslpp::matrix< double > ToRescaleBasis(orders order, unsigned int n_u, unsigned int n_d) const
a method returning the anomalous dimension in the Chetyrkin, Misiak and Munz operator basis
Definition: EvolDB1bsg.cpp:302
RGEvolutor::Evol
gslpp::matrix< double > * Evol(orders order)
Evolution matrix set at a fixed order of QCD coupling.
Definition: RGEvolutor.cpp:103
EvolDB1bsg::Df1Evolbsg
gslpp::matrix< double > & Df1Evolbsg(double mu, double M, orders order, schemes scheme=NDR)
a method returning the evolutor related to the high scale and the low scale
Definition: EvolDB1bsg.cpp:388
EvolDB1bsg::ToEffectiveBasis
gslpp::matrix< double > ToEffectiveBasis(gslpp::matrix< double > mat) const
a method returning the anomalous dimension for the evolution of the effective Wilson coefficients
Definition: EvolDB1bsg.cpp:360
HV
Definition: OrderScheme.h:22
RGEvolutor::setScales
void setScales(double mu, double M)
Sets the upper and lower scale for the running of the Wilson Coefficients.
Definition: RGEvolutor.cpp:85
EvolDB1bsg::jss
gslpp::matrix< gslpp::complex > jss
Definition: EvolDB1bsg.h:92
RGEvolutor::RGEvolutor
RGEvolutor(unsigned int dim, schemes scheme, orders order)
constructor
Definition: RGEvolutor.cpp:10
NLO
Definition: OrderScheme.h:34
FULLNNLO
Definition: OrderScheme.h:38
FULLNLO
Definition: OrderScheme.h:37
EvolDB1bsg::f2
double f2[3][13][13][13]
Definition: EvolDB1bsg.h:82
WilsonTemplate< gslpp::matrix< double > >::elem
gslpp::matrix< double > * elem[MAXORDER_QED+1]
Definition: WilsonTemplate.h:114
EvolDB1bsg::nd
int nd
Definition: EvolDB1bsg.h:75
EvolDB1bsg::nu
int nu
Definition: EvolDB1bsg.h:75
EvolDB1bsg::v
gslpp::matrix< gslpp::complex > v
Definition: EvolDB1bsg.h:92
EvolDB1bsg::e
gslpp::vector< gslpp::complex > e
Definition: EvolDB1bsg.h:93
EvolDB1bsg::gg2
gslpp::matrix< gslpp::complex > gg2
Definition: EvolDB1bsg.h:92
EvolDB1bsg::h
gslpp::matrix< gslpp::complex > h
Definition: EvolDB1bsg.h:92