EvolDB1Mll Class Reference

#include <EvolDB1Mll.h>

Inheritance diagram for EvolDB1Mll:
[legend]
Collaboration diagram for EvolDB1Mll:
[legend]

Detailed Description

Definition at line 15 of file EvolDB1Mll.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 > & Df1EvolMll (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...
 
 EvolDB1Mll (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 ~EvolDB1Mll ()
 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_ew order_ew)
 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_ew order_ew)
 constructor More...
 
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_ew order_ew)
 
void setEvol (const gslpp::matrix< double > &m, orders order_i)
 
void setEvol (const gslpp::matrix< double > &m, orders_ew order_ew_i)
 
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_ew getOrder_ew () 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_ew order_ew_i=NULL_ew)
 
virtual ~WilsonTemplate ()
 

Private Member Functions

void Df1EvolMll (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 [4][13]
 
double alsMZ_cache
 
double b [4][13][13][13]
 
double c [4][13][13][13]
 
double d [4][13][13][13]
 
unsigned int dim
 
gslpp::vector< gslpp::complexe
 
gslpp::matrix< gslpp::complexgg
 
gslpp::matrix< gslpp::complexh
 
gslpp::matrix< gslpp::complexjs
 
gslpp::matrix< gslpp::complexjss
 
gslpp::matrix< gslpp::complexjssv
 
gslpp::matrix< gslpp::complexjv
 
const StandardModelmodel
 
double Mz_cache
 
int nd
 
int nu
 
gslpp::matrix< gslpp::complexs_s
 
gslpp::matrix< gslpp::complexv
 
gslpp::matrix< gslpp::complexvi
 
gslpp::matrix< gslpp::complexvij
 

Additional Inherited Members

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

Constructor & Destructor Documentation

EvolDB1Mll::EvolDB1Mll ( 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 11 of file EvolDB1Mll.cpp.

12 : RGEvolutor(dim_i, scheme, order), model(model),
13  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.),
14  jssv(dim_i,0.), jss(dim_i,0.), jv(dim_i,0.), vij(dim_i,0.), e(dim_i,0.), dim(dim_i)
15 {
16  if (dim != 13 ) throw std::runtime_error("ERROR: EvolDB1Mll can only be of dimension 13");
17 
18  /* magic numbers a & b */
19 
20  for(int L=3; L>-1; L--){
21 
22  /* L=3 --> u,d,s (nf=3) 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) */
23 
24  nu = L; nd = L;
25  if(L == 3){nd = 2; nu = 1;}
26  if(L == 1){nd = 3; nu = 2;}
27  if(L == 0){nd = 3; nu = 3;}
28 
29  // LO evolutor of the effective Wilson coefficients in the Chetyrkin, Misiak and Munz basis
30 
31  (ToEffectiveBasis(ToRescaleBasis(LO,nu,nd))).transpose().eigensystem(v,e);
32  vi = v.inverse();
33  for(unsigned int i = 0; i < dim; i++){
34  a[L][i] = e(i).real();
35  for (unsigned int j = 0; j < dim; j++) {
36  for (unsigned int k = 0; k < dim; k++) {
37  b[L][i][j][k] = v(i, k).real() * vi(k, j).real();
38  }
39  }
40  }
41 
42  // NLO evolutor of the effective Wilson coefficients in the Chetyrkin, Misiak and Munz basis
43 
44  gg = vi * (ToEffectiveBasis(ToRescaleBasis(NLO,nu,nd))).transpose() * v;
45  double b0 = model.Beta0(nu+nd);
46  double b1 = model.Beta1(nu+nd);
47  for (unsigned int i = 0; i < dim; i++){
48  for (unsigned int j = 0; j < dim; j++){
49  s_s.assign( i, j, (b1 / b0) * (i==j) * e(i).real() - gg(i,j));
50  if(fabs(e(i).real() - e(j).real() + 2. * b0)>0.00000000001){
51  h.assign( i, j, s_s(i,j) / (2. * b0 + e(i) - e(j)));
52  }
53  }
54  }
55  js = v * h * vi;
56  jv = js * v;
57  vij = vi * js;
58  jss = v * s_s * vi;
59  jssv = jss * v;
60  for (unsigned int i = 0; i < dim; i++){
61  for (unsigned int j = 0; j < dim; j++){
62  if(fabs(e(i).real() - e(j).real() + 2. * b0) > 0.00000000001){
63  for(unsigned int k = 0; k < dim; k++){
64  c[L][i][j][k] = jv(i, k).real() * vi(k, j).real();
65  d[L][i][j][k] = -v(i, k).real() * vij(k, j).real();
66  }
67  }
68  else{
69  for(unsigned int k = 0; k < dim; k++){
70  c[L][i][j][k] = (1./(2. * b0)) * jssv(i, k).real() * vi(k, j).real();
71  d[L][i][j][k] = 0.;
72  }
73  }
74  }
75  }
76  }
77 }
gslpp::matrix< gslpp::complex > gg
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > vi
Definition: EvolDB1Mll.h:93
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
unsigned int dim
Definition: EvolDB1Mll.h:95
gslpp::matrix< gslpp::complex > jv
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > js
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > h
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > s_s
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > vij
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > jssv
Definition: EvolDB1Mll.h:93
double a[4][13]
Definition: EvolDB1Mll.h:83
gslpp::matrix< gslpp::complex > jss
Definition: EvolDB1Mll.h:93
gslpp::matrix< gslpp::complex > v
Definition: EvolDB1Mll.h:93
Definition: OrderScheme.h:33
gslpp::matrix< double > ToEffectiveBasis(gslpp::matrix< double > mat) const
a method returning the anomalous dimension for the evolution of the effective Wilson coefficients ...
Definition: EvolDB1Mll.cpp:306
double c[4][13][13][13]
Definition: EvolDB1Mll.h:83
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: EvolDB1Mll.cpp:227
double d[4][13][13][13]
Definition: EvolDB1Mll.h:83
gslpp::vector< gslpp::complex > e
Definition: EvolDB1Mll.h:94
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
double b[4][13][13][13]
Definition: EvolDB1Mll.h:83
const StandardModel & model
Definition: EvolDB1Mll.h:84
RGEvolutor(unsigned int dim, schemes scheme, orders order)
constructor
Definition: RGEvolutor.cpp:10
EvolDB1Mll::~EvolDB1Mll ( )
virtual

EvolDF1bsg destructor.

Definition at line 79 of file EvolDB1Mll.cpp.

80 {}

Member Function Documentation

gslpp::matrix< double > EvolDB1Mll::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 82 of file EvolDB1Mll.cpp.

83 {
84 
85  /* Delta F = 1 anomalous dimension in Misiak basis,
86  ref.: M. Misiak, Nucl. Phys. B393 (1993) 23, B439 (1995) 461 (E),
87  A.J. Buras and M. Munz, Phys. Rev. D52 (1995) 186. */
88 
89  /* gamma(row, coloumn) at the LO */
90 
91  unsigned int nf = n_u + n_d; /*n_u/d = active type up/down flavor d.o.f.*/
92 
93  gslpp::matrix<double> gammaDF1(dim, dim, 0.);
94 
95  switch(order){
96 
97  case LO:
98 
99  gammaDF1(0,0) = -4. ;
100  gammaDF1(0,1) = 8./3. ;
101  gammaDF1(0,3) = -2./9.;
102  gammaDF1(0,8) = -32./27.;
103 
104 
105  gammaDF1(1,0) = 12.;
106  gammaDF1(1,3) = 4./3.;
107  gammaDF1(1,8) = -8./9.;
108 
109  gammaDF1(2,3) = -52./3.;
110  gammaDF1(2,5) = 2.;
111  gammaDF1(2,8) = 8./9. + (8.*n_d)/3. - (16.*n_u)/3.;
112 
113  gammaDF1(3,2) = -40./9.;
114  gammaDF1(3,3) = -160./9. + 4./3.*nf;
115  gammaDF1(3,4) = 4./9.;
116  gammaDF1(3,5) = 5./6.;
117  gammaDF1(3,8) = 32./27.;
118 
119  gammaDF1(4,3) = -256./3.;
120  gammaDF1(4,5) = 20.;
121  gammaDF1(4,8) = 128./9.+(80.*n_d)/3. - (160.*n_u)/3.;
122 
123  gammaDF1(5,2) = -256./9.;
124  gammaDF1(5,3) = -544./9. + (40./3.)*nf;
125  gammaDF1(5,4) = 40./9.;
126  gammaDF1(5,5) = -2./3.;
127  gammaDF1(5,8) = 512./27.;
128 
129  gammaDF1(6,6) = 32./3. - 2.*model.Beta0(nf);
130 
131  gammaDF1(7,6) = -32./9.;
132  gammaDF1(7,7) = 28./3. - 2.*model.Beta0(nf);
133 
134  gammaDF1(8,8) = -2.*model.Beta0(nf);
135 
136  gammaDF1(9,9) = -2.*model.Beta0(nf);
137 
138  gammaDF1(10,10)= -2.*model.Beta0(nf);
139 
140  gammaDF1(11,11)= -2.*model.Beta0(nf);
141 
142  gammaDF1(12,12)= -2.*model.Beta0(nf);
143 
144  break;
145  case NLO:
146 
147  if (!(nf == 3 || nf == 4 || nf == 5 || nf == 6)){
148  throw std::runtime_error("EvolDF1::AnomalousDimension_M(): wrong number of flavours");
149  }
150 
151  /* gamma(row, coloumn) at the NLO */
152 
153  gammaDF1(0,0) = -145./3. + (16./9.)*nf;
154  gammaDF1(0,1) = -26. + (40./27.)*nf;
155  gammaDF1(0,2) = -1412./243.;
156  gammaDF1(0,3) = -1369./243.;
157  gammaDF1(0,4) = 134./243.;
158  gammaDF1(0,5) = -35./162.;
159  gammaDF1(0,6) = -232./243.;
160  gammaDF1(0,7) = +167./162.;
161  gammaDF1(0,8) = -2272./729.;
162 
163  gammaDF1(1,0) = -45. + (20./3.)*nf;
164  gammaDF1(1,1) = -28./3.;
165  gammaDF1(1,2) = -416./81.;
166  gammaDF1(1,3) = 1280./81.;
167  gammaDF1(1,4) = 56./81.;
168  gammaDF1(1,5) = 35./27.;
169  gammaDF1(1,6) = 464./81.;
170  gammaDF1(1,7) = 76./27.;
171  gammaDF1(1,8) = 1952./243.;
172 
173  gammaDF1(2,2) = -4468./81.;
174  gammaDF1(2,3) = -29129./81. - (52./9.)*nf;
175  gammaDF1(2,4) = 400./81.;
176  gammaDF1(2,5) = 3493./108. - (2./9.)*nf;
177  gammaDF1(2,6) = 64./81.;
178  gammaDF1(2,7) = 368./27.;
179  gammaDF1(2,8) = -4160./243. + (32.*n_d)/3. - (64.*n_u)/3.;
180 
181  gammaDF1(3,2) = -13678./243. + (368.*nf)/81.;
182  gammaDF1(3,3) = -79409./243. + (1334.*nf)/81.;
183  gammaDF1(3,4) = 509./486. - (8.*nf)/81.;
184  gammaDF1(3,5) = 13499./648. - (5.*nf)/27.;
185  gammaDF1(3,6) = -680./243. + (32.*nf)/81;
186  gammaDF1(3,7) = -427./81. - (37.*nf)/54.;
187  gammaDF1(3,8) = 784./729. - (2272.*n_d)/243. + (2912.*n_u)/243.;
188 
189  gammaDF1(4,2) = -244480./81. - (160./9.)*nf;
190  gammaDF1(4,3) = -29648./81. - (2200./9.)*nf;
191  gammaDF1(4,4) = 23116./81. + (16./9.)*nf;
192  gammaDF1(4,5) = 3886./27. + (148./9.)*nf;
193  gammaDF1(4,6) = -6464./81.;
194  gammaDF1(4,7) = 8192./27. + 36.*nf;
195  gammaDF1(4,8) = -58112./243. + (320.*n_d)/3. - (640.*n_u)/3.;
196 
197  gammaDF1(5,2) = 77600./243. - (1264./81.)*nf;
198  gammaDF1(5,3) = -28808./243. + (164./81.)*nf;
199  gammaDF1(5,4) = -20324./243. + (400./81.)*nf;
200  gammaDF1(5,5) = -21211./162.+ (622./27.)*nf;
201  gammaDF1(5,6) = -20096./243. - (976.*n_d)/81. + (2912.*n_u)/81.;
202  gammaDF1(5,7) = -6040./81. + (220./27.)*nf;
203  gammaDF1(5,8) = -22784./729. - (20704.*n_d)/243. + (28544.*n_u)/243.;
204 
205  gammaDF1(6,6) = 1936./9.-224./27.*nf-2*model.Beta1(nf);
206 
207  gammaDF1(7,6) = -368./9.+224./81.*nf;
208  gammaDF1(7,7) = 1456./9.-61./27.*nf-2*model.Beta1(nf);
209 
210  gammaDF1(8,8) = -2.*model.Beta1(nf);
211 
212  gammaDF1(9,9) = -2.*model.Beta1(nf);
213 
214  gammaDF1(10,10)= -2.*model.Beta1(nf);
215 
216  gammaDF1(11,11)= -2.*model.Beta1(nf);
217 
218  gammaDF1(12,12)= -2.*model.Beta1(nf);
219 
220  break;
221  default:
222  throw std::runtime_error("EvolDF1bsg::AnomalousDimension_M(): order not implemented");
223  }
224  return (gammaDF1);
225 }
A class for constructing and defining operations on real matrices.
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
unsigned int dim
Definition: EvolDB1Mll.h:95
Definition: OrderScheme.h:33
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
const StandardModel & model
Definition: EvolDB1Mll.h:84
gslpp::matrix< double > & EvolDB1Mll::Df1EvolMll ( 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 343 of file EvolDB1Mll.cpp.

344 {
345 
346  switch (scheme) {
347  case NDR:
348  break;
349  case LRI:
350  case HV:
351  default:
352  std::stringstream out;
353  out << scheme;
354  throw std::runtime_error("EvolDF1bsg::Df1Evolbsg(): scheme " + out.str() + " not implemented ");
355  }
356 
357  double alsMZ = model.getAlsMz();
358  double Mz = model.getMz();
359  if(alsMZ == alsMZ_cache && Mz == Mz_cache) {
360  if (mu == this->mu && M == this->M && scheme == this->scheme)
361  return (*Evol(order));
362  }
363  alsMZ_cache = alsMZ;
364  Mz_cache = Mz;
365 
366  if (M < mu) {
367  std::stringstream out;
368  out << "M = " << M << " < mu = " << mu;
369  throw out.str();
370  }
371 
372  setScales(mu, M); // also assign evol to identity
373 
374  double m_down = mu;
375  double m_up = model.AboveTh(m_down);
376  double nf = model.Nf(m_down);
377 
378  while (m_up < M) {
379  Df1EvolMll(m_down, m_up, nf, scheme);
380  m_down = m_up;
381  m_up = model.AboveTh(m_down);
382  nf += 1.;
383  }
384  Df1EvolMll(m_down, M, nf, scheme);
385 
386  return (*Evol(order));
387 
388  }
gslpp::matrix< double > & Df1EvolMll(double mu, double M, orders order, schemes scheme=NDR)
a method returning the evolutor related to the high scale and the low scale
Definition: EvolDB1Mll.cpp:343
void setScales(double mu, double M)
Sets the upper and lower scale for the running of the Wilson Coefficients.
Definition: RGEvolutor.cpp:85
double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:849
gslpp::matrix< double > * Evol(orders order)
Evolution matrix set at a fixed order of QCD coupling.
Definition: RGEvolutor.cpp:125
double M
Definition: RGEvolutor.h:142
Definition: OrderScheme.h:22
double Mz_cache
Definition: EvolDB1Mll.h:97
double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:867
const StandardModel & model
Definition: EvolDB1Mll.h:84
double getMz() const
A get method to access the mass of the boson .
double alsMZ_cache
Definition: EvolDB1Mll.h:96
double getAlsMz() const
A get method to access the value of .
void EvolDB1Mll::Df1EvolMll ( 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 390 of file EvolDB1Mll.cpp.

391  {
392 
393  gslpp::matrix<double> resLO(dim, 0.), resNLO(dim, 0.), resNNLO(dim, 0.);
394 
395  int L = 6 - (int) nf;
396  double alsM = model.Als(M) / 4. / M_PI;
397  double alsmu = model.Als(mu) / 4. / M_PI;
398 
399  double eta = alsM / alsmu;
400 
401  for (unsigned int k = 0; k < dim; k++) {
402  double etap = pow(eta, a[L][k] / 2. / model.Beta0(nf));
403  for (unsigned int i = 0; i < dim; i++){
404  for (unsigned int j = 0; j < dim; j++) {
405  resNNLO(i, j) += 0.;
406 
407  if(fabs(e(i).real() - e(j).real() + 2. * model.Beta0(nf))>0.000000000001) {
408  resNLO(i, j) += c[L][i][j][k] * etap * alsmu;
409  resNLO(i, j) += d[L][i][j][k] * etap * alsM;
410  }
411  else{
412  resNLO(i, j) += - c[L][i][j][k] * etap * alsmu * log(eta);
413  }
414  resLO(i, j) += b[L][i][j][k] * etap;
415  if (fabs(resLO(i, j)) < 1.e-12) {resLO(i, j) = 0.;}
416  if (fabs(resNLO(i, j)) < 1.e-12) {resNLO(i, j) = 0.;}
417  }
418  }
419  }
420 
421  switch(order) {
422  case NNLO:
423  *elem[NNLO] = 0.;
424  case NLO:
425  *elem[NLO] = (*elem[LO]) * resNLO + (*elem[NLO]) * resLO;
426  case LO:
427  *elem[LO] = (*elem[LO]) * resLO;
428  break;
429  case FULLNNLO:
430  case FULLNLO:
431  default:
432  throw std::runtime_error("Error in EvolDF1bsg::Df1Evolbsg()");
433  }
434 
435  }
A class for constructing and defining operations on real matrices.
unsigned int dim
Definition: EvolDB1Mll.h:95
complex pow(const complex &z1, const complex &z2)
double Als(const double mu, const orders order=FULLNLO) const
Computes the running strong coupling in the scheme. In the cases of LO, NLO and FULLNNLO...
Definition: QCD.cpp:1004
double a[4][13]
Definition: EvolDB1Mll.h:83
Definition: OrderScheme.h:33
double c[4][13][13][13]
Definition: EvolDB1Mll.h:83
double M
Definition: RGEvolutor.h:142
double d[4][13][13][13]
Definition: EvolDB1Mll.h:83
gslpp::matrix< double > * elem[MAXORDER_EW+1]
complex log(const complex &z)
gslpp::vector< gslpp::complex > e
Definition: EvolDB1Mll.h:94
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
double b[4][13][13][13]
Definition: EvolDB1Mll.h:83
const StandardModel & model
Definition: EvolDB1Mll.h:84
gslpp::matrix< double > EvolDB1Mll::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 306 of file EvolDB1Mll.cpp.

307 {
308 
309  gslpp::matrix<double> y(dim, 0.);
310 
311  y(0,0) = 1.;
312  y(1,1) = 1.;
313  y(2,2) = 1.;
314  y(3,3) = 1.;
315  y(4,4) = 1.;
316  y(5,5) = 1.;
317  y(6,6) = 1.;
318  y(7,7) = 1.;
319  y(8,8) = 1.;
320  y(9,9) = 1.;
321  y(10,10) = 1.;
322  y(11,11) = 1.;
323  y(12,12) = 1.;
324 
325  y(6,2) = -1./3.;
326  y(6,3) = -4./9.;
327  y(6,4) = -20./3.;
328  y(6,5) = -80./9.;
329 
330  y(7,2) = 1.;
331  y(7,3) = -1./6.;
332  y(7,4) = 20.;
333  y(7,5) = -10./3.;
334 
335  y(8,2) = 4./3.;
336  y(8,4) = 64./9.;
337  y(8,5) = 64./27.; // Add terms proportional to Log(mb/mub))
338 
339  return( (y.inverse()).transpose() * mat * y.transpose() );
340 
341 }
A class for constructing and defining operations on real matrices.
unsigned int dim
Definition: EvolDB1Mll.h:95
gslpp::matrix< double > EvolDB1Mll::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 227 of file EvolDB1Mll.cpp.

228 {
229 
230  /* matrix entries for the anomalous dimension in the Chetyrkin, Misiak and Munz basis,
231  ref. hep-ph/9711280v1, hep-ph/0504194 */
232 
233  gslpp::matrix<double> mat(dim, 0.);
234  gslpp::matrix<double> mat1(dim, 0.);
235  unsigned int nf = n_u + n_d;
236  double z3 = gsl_sf_zeta_int(3);
237 
238  mat1(0,6) = - 13454./2187. + 44./2187.*nf;
239  mat1(1,6) = 20644./729. - 88./729.*nf;
240  mat1(2,6) = 119456./729. + 5440./729.*n_d -21776./729.*n_u;
241  mat1(3,6) = - 202990./2187. + 32./729.*n_d*n_d + n_d*(16888./2187. + 64./729.*n_u)
242  - 17132./2187.*n_u + 32./729.*n_u*n_u;
243  mat1(4,6) = 530240./243. + 300928./729.*n_d - 461120./729.*n_u;
244  mat1(5,6) = - 1112344./729. + 5432./729.*n_d*n_d + n_d*(419440./2187. -
245  2744./729.*n_u) + 143392./2187.*n_u - 8176./729.*n_u*n_u;
246 
247  mat1(0,7) = 25759./5832. + 431./5832.*nf;
248  mat1(1,7) = 9733./486. - 917./972.*nf;
249  mat1(2,7) = 82873./243. - 3361./243.*nf;
250  mat1(3,7) = - 570773./2916. - 253./486.*n_d*n_d +n_d*(-40091./5832. -
251  253./243.*n_u) - 40091./5832.*n_u - 253./486.*n_u*n_u;
252  mat1(4,7) = 838684./81. - 14.*n_d*n_d + n_d*(129074./243. - 28.*n_u) +
253  129074./243.*n_u - 14.*n_u*n_u;
254  mat1(5,7) = - 923522./243. - 6031./486.*n_d*n_d + n_d*(-13247./1458. - 6031./243.*n_u)
255  -13247./1458.*n_u - 6031./486.*n_u*n_u;
256 
257  mat1(0,8) = - 2357278./19683. + 14440./6561.*n_d + 144688./6561.*n_u + 6976./243.*z3;
258  mat1(1,8) = - 200848./6561. - 23696./2187.*n_d + 30736./2187.*n_u - 3584./81.*z3;
259  mat1(2,8) = - 1524104./6561. - 176./27.*n_d*n_d + 352./27.*n_u*n_u +
260  n_d*(257564./2187. + 176./27.*n_u - 128./3.*z3) - 256./81.*z3 +
261  n_u*(-382984./2187. + 256./3.*z3);
262  mat1(3,8) = 1535926./19683. + 1984./2187.*n_d*n_d - 5792./2187.*n_u*n_u +
263  n_d*(-256901./6561. - 3808./2187.*n_u - 2720./81.*z3) -
264  5056./243.*z3 + n_u*(34942./6561. + 1600./81.*z3);
265  mat1(4,8) = - 31433600./6561. - 2912./27.*n_d*n_d + 5824./27.*n_u*n_u +
266  n_d*(- 3786616./2187. + 2912./27.*n_u - 1280./3.*z3) -
267  4096./81.*z3 + n_u*(7525520./2187. + 2560./3.*z3);
268  mat1(5,8) = 48510784./19683. -51296./2187.*n_d*n_d + 54976./2187.*n_u*n_u +
269  n_u*(-11231648./6561. - 22016./81.*z3) + n_d*(340984./6561. +
270  3680./2187.*n_u - 8192./81.*z3) - 80896./243.*z3;
271 
272 
273  switch(order){
274  case(NLO):
275  mat = AnomalousDimension_M(NLO, n_u, n_d);
276  for (unsigned int i=0; i<6; i++){
277  for (unsigned int j=6; j<dim; j++){
278  mat(i,j) = mat1(i,j);
279  }
280  }
281  for (unsigned int i=6; i<dim; i++){
282  for (unsigned int j=6; j<dim; j++){
283  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta1(nf);
284  }
285  }
286  return (mat);
287  case(LO):
288  mat = AnomalousDimension_M(LO, n_u, n_d);
289  for (unsigned int i=0; i<6; i++){
290  for (unsigned int j=6; j<dim; j++){
291  mat(i,j) = AnomalousDimension_M(NLO, n_u, n_d)(i,j);
292  }
293  }
294  for (unsigned int i=6; i<dim; i++){
295  for (unsigned int j=6; j<dim; j++){
296  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta0(nf);
297  }
298  }
299  return (mat);
300  default:
301  throw std::runtime_error("change to rescaled operator basis: order not implemented");
302  }
303 
304 }
A class for constructing and defining operations on real matrices.
double Beta1(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:892
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: EvolDB1Mll.cpp:82
unsigned int dim
Definition: EvolDB1Mll.h:95
Definition: OrderScheme.h:33
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
const StandardModel & model
Definition: EvolDB1Mll.h:84

Member Data Documentation

double EvolDB1Mll::a[4][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 83 of file EvolDB1Mll.h.

double EvolDB1Mll::alsMZ_cache
private

Definition at line 96 of file EvolDB1Mll.h.

double EvolDB1Mll::b[4][13][13][13]
private

Definition at line 83 of file EvolDB1Mll.h.

double EvolDB1Mll::c[4][13][13][13]
private

Definition at line 83 of file EvolDB1Mll.h.

double EvolDB1Mll::d[4][13][13][13]
private

Definition at line 83 of file EvolDB1Mll.h.

unsigned int EvolDB1Mll::dim
private

Definition at line 95 of file EvolDB1Mll.h.

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

Definition at line 94 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

const StandardModel& EvolDB1Mll::model
private

Definition at line 84 of file EvolDB1Mll.h.

double EvolDB1Mll::Mz_cache
private

Definition at line 97 of file EvolDB1Mll.h.

int EvolDB1Mll::nd
private

Definition at line 76 of file EvolDB1Mll.h.

int EvolDB1Mll::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 76 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.

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

Definition at line 93 of file EvolDB1Mll.h.


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