EvolDB1bsg Class Reference

#include <EvolDB1bsg.h>

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

Detailed Description

Definition at line 15 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_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 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 d [3][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

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

EvolDF1bsg destructor.

Definition at line 78 of file EvolDB1bsg.cpp.

79 {}

Member Function Documentation

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 81 of file EvolDB1bsg.cpp.

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

286 {
287 
288  switch (scheme) {
289  case NDR:
290  break;
291  case LRI:
292  case HV:
293  default:
294  std::stringstream out;
295  out << scheme;
296  throw std::runtime_error("EvolDF1bsg::Df1Evolbsg(): scheme " + out.str() + " not implemented ");
297  }
298 
299  double alsMZ = model.getAlsMz();
300  double Mz = model.getMz();
301  if(alsMZ == alsMZ_cache && Mz == Mz_cache) {
302  if (mu == this->mu && M == this->M && scheme == this->scheme)
303  return (*Evol(order));
304  }
305  alsMZ_cache = alsMZ;
306  Mz_cache = Mz;
307 
308  if (M < mu) {
309  std::stringstream out;
310  out << "M = " << M << " < mu = " << mu;
311  throw out.str();
312  }
313 
314  setScales(mu, M); // also assign evol to identity
315 
316  double m_down = mu;
317  double m_up = model.AboveTh(m_down);
318  double nf = model.Nf(m_down);
319 
320  while (m_up < M) {
321  Df1Evolbsg(m_down, m_up, nf, scheme);
322  m_down = m_up;
323  m_up = model.AboveTh(m_down);
324  nf += 1.;
325  }
326  Df1Evolbsg(m_down, M, nf, scheme);
327 
328  return (*Evol(order));
329 
330  }
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:285
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 Mz_cache
Definition: EvolDB1bsg.h:97
double alsMZ_cache
Definition: EvolDB1bsg.h:96
double M
Definition: RGEvolutor.h:142
const StandardModel & model
Definition: EvolDB1bsg.h:84
Definition: OrderScheme.h:22
double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:867
double getMz() const
A get method to access the mass of the boson .
double getAlsMz() const
A get method to access the value of .
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 332 of file EvolDB1bsg.cpp.

333  {
334 
335  gslpp::matrix<double> resLO(dim, 0.), resNLO(dim, 0.), resNNLO(dim, 0.);
336 
337  int L = 6 - (int) nf;
338  double alsM = model.Alstilde5(M);
339  double alsmu = model.Alstilde5(mu);
340 
341  double eta = alsM / alsmu;
342 
343  for (unsigned int k = 0; k < dim; k++) {
344  double etap = pow(eta, a[L][k] / 2. / model.Beta0(nf));
345  for (unsigned int i = 0; i < dim; i++){
346  for (unsigned int j = 0; j < dim; j++) {
347  resNNLO(i, j) += 0.;
348 
349  if(fabs(e(i).real() - e(j).real() + 2. * model.Beta0(nf))>0.000000000001) {
350  resNLO(i, j) += c[L][i][j][k] * etap * alsmu;
351  resNLO(i, j) += d[L][i][j][k] * etap * alsM;
352  }
353  else{
354  resNLO(i, j) += - c[L][i][j][k] * etap * alsmu * log(eta);
355  }
356  resLO(i, j) += b[L][i][j][k] * etap;
357  if (fabs(resLO(i, j)) < 1.e-12) {resLO(i, j) = 0.;}
358  if (fabs(resNLO(i, j)) < 1.e-12) {resNLO(i, j) = 0.;}
359  }
360  }
361  }
362 
363  switch(order) {
364  case NNLO:
365  *elem[NNLO] = 0.;
366  case NLO:
367  *elem[NLO] = (*elem[LO]) * resNLO + (*elem[NLO]) * resLO;
368  case LO:
369  *elem[LO] = (*elem[LO]) * resLO;
370  break;
371  case FULLNNLO:
372  case FULLNLO:
373  default:
374  throw std::runtime_error("Error in EvolDF1bsg::Df1Evolbsg()");
375  }
376 
377  }
unsigned int dim
Definition: EvolDB1bsg.h:95
double d[3][13][13][13]
Definition: EvolDB1bsg.h:83
A class for constructing and defining operations on real matrices.
complex pow(const complex &z1, const complex &z2)
double c[3][13][13][13]
Definition: EvolDB1bsg.h:83
gslpp::vector< gslpp::complex > e
Definition: EvolDB1bsg.h:94
Definition: OrderScheme.h:33
double M
Definition: RGEvolutor.h:142
const StandardModel & model
Definition: EvolDB1bsg.h:84
gslpp::matrix< double > * elem[MAXORDER_EW+1]
complex log(const complex &z)
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887
double a[3][13]
Definition: EvolDB1bsg.h:83
double b[3][13][13][13]
Definition: EvolDB1bsg.h:83
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 257 of file EvolDB1bsg.cpp.

258 {
259 
260  gslpp::matrix<double> y(dim, 0.);
261 
262  y(0,0) = 1.;
263  y(1,1) = 1.;
264  y(2,2) = 1.;
265  y(3,3) = 1.;
266  y(4,4) = 1.;
267  y(5,5) = 1.;
268  y(6,6) = 1.;
269  y(7,7) = 1.;
270 
271  y(6,2) = -1./3.;
272  y(6,3) = -4./9.;
273  y(6,4) = -20./3.;
274  y(6,5) = -80./9.;
275 
276  y(7,2) = 1.;
277  y(7,3) = -1./6.;
278  y(7,4) = 20.;
279  y(7,5) = -10./3.;
280 
281  return( (y.inverse()).transpose() * mat * y.transpose() );
282 
283 }
unsigned int dim
Definition: EvolDB1bsg.h:95
A class for constructing and defining operations on real matrices.
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 193 of file EvolDB1bsg.cpp.

194 {
195 
196  /* matrix entries for the anomalous dimension in the Chetyrkin, Misiak and Munz basis,
197  ref. hep-ph/9711280v1, hep-ph/0504194 */
198 
199  gslpp::matrix<double> mat(dim, 0.);
200  gslpp::matrix<double> mat1(dim, 0.);
201  unsigned int nf = n_u + n_d;
202  //double z3 = gsl_sf_zeta_int(3);
203 
204  mat1(0,6) = - 13454./2187. + 44./2187.*nf;
205  mat1(1,6) = 20644./729. - 88./729.*nf;
206  mat1(2,6) = 119456./729. + 5440./729.*n_d -21776./729.*n_u;
207  mat1(3,6) = - 202990./2187. + 32./729.*n_d*n_d + n_d*(16888./2187. + 64./729.*n_u)
208  - 17132./2187.*n_u + 32./729.*n_u*n_u;
209  mat1(4,6) = 530240./243. + 300928./729.*n_d - 461120./729.*n_u;
210  mat1(5,6) = - 1112344./729. + 5432./729.*n_d*n_d + n_d*(419440./2187. -
211  2744./729.*n_u) + 143392./2187.*n_u - 8176./729.*n_u*n_u;
212 
213  mat1(0,7) = 25759./5832. + 431./5832.*nf;
214  mat1(1,7) = 9733./486. - 917./972.*nf;
215  mat1(2,7) = 82873./243. - 3361./243.*nf;
216  mat1(3,7) = - 570773./2916. - 253./486.*n_d*n_d +n_d*(-40091./5832. -
217  253./243.*n_u) - 40091./5832.*n_u - 253./486.*n_u*n_u;
218  mat1(4,7) = 838684./81. - 14.*n_d*n_d + n_d*(129074./243. - 28.*n_u) +
219  129074./243.*n_u - 14.*n_u*n_u;
220  mat1(5,7) = - 923522./243. - 6031./486.*n_d*n_d + n_d*(-13247./1458. - 6031./243.*n_u)
221  -13247./1458.*n_u - 6031./486.*n_u*n_u;
222 
223 
224  switch(order){
225  case(NLO):
226  mat = AnomalousDimension_M(NLO, n_u, n_d);
227  for (int i=0; i<6; i++){
228  for (unsigned int j=6; j<dim; j++){
229  mat(i,j) = mat1(i,j);
230  }
231  }
232  for (unsigned int i=6; i<dim; i++){
233  for (unsigned int j=6; j<dim; j++){
234  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta1(nf);
235  }
236  }
237  return (mat);
238  case(LO):
239  mat = AnomalousDimension_M(LO, n_u, n_d);
240  for (int i=0; i<6; i++){
241  for (unsigned int j=6; j<dim; j++){
242  mat(i,j) = AnomalousDimension_M(NLO, n_u, n_d)(i,j);
243  }
244  }
245  for (unsigned int i=6; i<dim; i++){
246  for (unsigned int j=6; j<dim; j++){
247  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta0(nf);
248  }
249  }
250  return (mat);
251  default:
252  throw std::runtime_error("change to rescaled operator basis: order not implemented");
253  }
254 
255 }
unsigned int dim
Definition: EvolDB1bsg.h:95
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
Definition: OrderScheme.h:33
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:81
const StandardModel & model
Definition: EvolDB1bsg.h:84
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:887

Member Data Documentation

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 83 of file EvolDB1bsg.h.

double EvolDB1bsg::alsMZ_cache
private

Definition at line 96 of file EvolDB1bsg.h.

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

Definition at line 83 of file EvolDB1bsg.h.

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

Definition at line 83 of file EvolDB1bsg.h.

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

Definition at line 83 of file EvolDB1bsg.h.

unsigned int EvolDB1bsg::dim
private

Definition at line 95 of file EvolDB1bsg.h.

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

Definition at line 94 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

const StandardModel& EvolDB1bsg::model
private

Definition at line 84 of file EvolDB1bsg.h.

double EvolDB1bsg::Mz_cache
private

Definition at line 97 of file EvolDB1bsg.h.

int EvolDB1bsg::nd
private

Definition at line 76 of file EvolDB1bsg.h.

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 76 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.

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

Definition at line 93 of file EvolDB1bsg.h.


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