a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
EvolDC1.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 <gsl/gsl_sf_zeta.h>
9 #include "EvolDC1.h"
10 #include <stdexcept>
11 #include "StandardModel.h"
12 
13 
14 EvolDC1::EvolDC1(unsigned int dim_i, schemes scheme, orders order, const StandardModel& model)
15 : RGEvolutor(dim_i, scheme, order), model(model),
16  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.),
17  jssv(dim_i,0.), jss(dim_i,0.), jv(dim_i,0.), vij(dim_i,0.), e(dim_i,0.), dim(dim_i)
18 {
19 
20  /* magic numbers a & b */
21 
22  for(int L=2; L>-1; L--){
23 
24  /* 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) */
25 
26  nu = L; nd = L;
27  if(L == 1){nd = 3; nu = 2;}
28  if(L == 0){nd = 3; nu = 3;}
29 
30  // LO evolutor of the effective Wilson coefficients in the Chetyrkin, Misiak and Munz basis
31 
32  (ToEffectiveBasis(ToRescaledBasis(LO,nu,nd))).transpose().eigensystem(v,e);
33  vi = v.inverse();
34  for(unsigned int i = 0; i < dim; i++){
35  a[L][i] = e(i).real();
36  for (unsigned int j = 0; j < dim; j++) {
37  for (unsigned int k = 0; k < dim; k++) {
38  b[L][i][j][k] = v(i, k).real() * vi(k, j).real();
39  }
40  }
41  }
42 
43  // NLO evolutor of the effective Wilson coefficients in the Chetyrkin, Misiak and Munz basis
44 
45  gg = vi * (ToEffectiveBasis(ToRescaledBasis(NLO,nu,nd))).transpose() * v;
46  double b0 = model.Beta0(6-L);
47  double b1 = model.Beta1(6-L);
48  for (unsigned int i = 0; i < dim; i++){
49  for (unsigned int j = 0; j < dim; j++){
50  s_s.assign( i, j, (b1 / b0) * (i==j) * e(i).real() - gg(i,j));
51  if(fabs(e(i).real() - e(j).real() + 2. * b0)>0.00000000001){
52  h.assign( i, j, s_s(i,j) / (2. * b0 + e(i) - e(j)));
53  }
54  }
55  }
56  js = v * h * vi;
57  jv = js * v;
58  vij = vi * js;
59  jss = v * s_s * vi;
60  jssv = jss * v;
61  for (unsigned int i = 0; i < dim; i++){
62  for (unsigned int j = 0; j < dim; j++){
63  if(fabs(e(i).real() - e(j).real() + 2. * b0) > 0.00000000001){
64  for(unsigned int k = 0; k < dim; k++){
65  c[L][i][j][k] = jv(i, k).real() * vi(k, j).real();
66  d[L][i][j][k] = -v(i, k).real() * vij(k, j).real();
67  }
68  }
69  else{
70  for(unsigned int k = 0; k < dim; k++){
71  c[L][i][j][k] = (1./(2. * b0)) * jssv(i, k).real() * vi(k, j).real();
72  d[L][i][j][k] = 0.;
73  }
74  }
75  }
76  }
77  }
78 }
79 
80 EvolDC1::~EvolDC1()
81 {}
82 
83 gslpp::matrix<double> EvolDC1::AnomalousDimension_M(orders order, unsigned int n_u, unsigned int n_d) const
84 {
85 
86  /* Delta F = 1 anomalous dimension in Misiak basis,
87  ref.: M. Misiak, Nucl. Phys. B393 (1993) 23, B439 (1995) 461 (E),
88  A.J. Buras and M. Munz, Phys. Rev. D52 (1995) 186. */
89 
90  /* gamma(row, coloumn) at the LO */
91 
92  unsigned int nf = n_u + n_d; /*n_u/d = active type up/down flavor d.o.f.*/
93 
94  gslpp::matrix<double> gammaDF1(dim, dim, 0.);
95 
96  switch(order){
97 
98  case LO:
99 
100  gammaDF1(0,0) = -4. ;
101  gammaDF1(0,1) = 8./3. ;
102 
103  gammaDF1(1,0) = 12.;
104 
105  if(nf < 5){
106  gammaDF1(1,3) = 4./3.;
107  gammaDF1(1,8) = -8./9.;
108  gammaDF1(0,3) = -2./9.;
109  gammaDF1(0,8) = -32./27.;
110  }
111 
112  gammaDF1(2,3) = -52./3.;
113  gammaDF1(2,5) = 2.;
114  gammaDF1(2,8) = 8./9. + (8.*n_d)/3. - (16.*n_u)/3.;
115 
116  gammaDF1(3,2) = -40./9.;
117  gammaDF1(3,3) = -160./9. + 4./3.*nf;
118  gammaDF1(3,4) = 4./9.;
119  gammaDF1(3,5) = 5./6.;
120  gammaDF1(3,8) = 32./27.;
121 
122  gammaDF1(4,3) = -256./3.;
123  gammaDF1(4,5) = 20.;
124  gammaDF1(4,8) = 128./9.+(80.*n_d)/3. - (160.*n_u)/3.;
125 
126  gammaDF1(5,2) = -256./9.;
127  gammaDF1(5,3) = -544./9. + (40./3.)*nf;
128  gammaDF1(5,4) = 40./9.;
129  gammaDF1(5,5) = -2./3.;
130  gammaDF1(5,8) = 512./27.;
131 
132  gammaDF1(6,6) = 32./3. - 2.*model.Beta0(nf);
133 
134  gammaDF1(7,6) = -32./9.;
135  gammaDF1(7,7) = 28./3. - 2.*model.Beta0(nf);
136 
137  gammaDF1(8,8) = -2.*model.Beta0(nf);
138 
139  gammaDF1(9,9) = -2.*model.Beta0(nf);
140 
141 
142  break;
143 
144  case NLO:
145 
146  if (!(nf == 3 || nf == 4 || nf == 5 || nf == 6)){
147  throw std::runtime_error("EvolDF1::AnomalousDimension_M(): wrong number of flavours");
148  }
149 
150  /*gamma(row, coloumn) at the NLO */
151 
152  gammaDF1(0,0) = -145./3. + (16./9.)*nf;
153  gammaDF1(0,1) = -26. + (40./27.)*nf;
154  gammaDF1(1,0) = -45. + (20./3.)*nf;
155  gammaDF1(1,1) = -28./3.;
156 
157  if(nf < 5){
158  gammaDF1(0,2) = -1412./243.;
159  gammaDF1(0,3) = -1369./243.;
160  gammaDF1(0,4) = 134./243.;
161  gammaDF1(0,5) = -35./162.;
162  gammaDF1(0,6) = -232./243.;
163  gammaDF1(0,7) = +167./162.;
164  gammaDF1(0,8) = -2272./729.;
165 
166  gammaDF1(1,2) = -416./81.;
167  gammaDF1(1,3) = 1280./81.;
168  gammaDF1(1,4) = 56./81.;
169  gammaDF1(1,5) = 35./27.;
170  gammaDF1(1,6) = 464./81.;
171  gammaDF1(1,7) = 76./27.;
172  gammaDF1(1,8) = 1952./243.;
173  }
174 
175  gammaDF1(2,2) = -4468./81.;
176  gammaDF1(2,3) = -29129./81. - (52./9.)*nf;
177  gammaDF1(2,4) = 400./81.;
178  gammaDF1(2,5) = 3493./108. - (2./9.)*nf;
179  gammaDF1(2,6) = 64./81.;
180  gammaDF1(2,7) = 368./27.;
181  gammaDF1(2,8) = -4160./243. + (32.*n_d)/3. - (64.*n_u)/3.;
182 
183  gammaDF1(3,2) = -13678./243. + (368.*nf)/81.;
184  gammaDF1(3,3) = -79409./243. + (1334.*nf)/81.;
185  gammaDF1(3,4) = 509./486. - (8.*nf)/81.;
186  gammaDF1(3,5) = 13499./648. - (5.*nf)/27.;
187  gammaDF1(3,6) = -680./243. + (32.*nf)/81;
188  gammaDF1(3,7) = -427./81. - (37.*nf)/54.;
189  gammaDF1(3,8) = 784./729. - (2272.*n_d)/243. + (2912.*n_u)/243.;
190 
191  gammaDF1(4,2) = -244480./81. - (160./9.)*nf;
192  gammaDF1(4,3) = -29648./81. - (2200./9.)*nf;
193  gammaDF1(4,4) = 23116./81. + (16./9.)*nf;
194  gammaDF1(4,5) = 3886./27. + (148./9.)*nf;
195  gammaDF1(4,6) = -6464./81.;
196  gammaDF1(4,7) = 8192./27. + 36.*nf;
197  gammaDF1(4,8) = -58112./243. + (320.*n_d)/3. - (640.*n_u)/3.;
198 
199  gammaDF1(5,2) = 77600./243. - (1264./81.)*nf;
200  gammaDF1(5,3) = -28808./243. + (164./81.)*nf;
201  gammaDF1(5,4) = -20324./243. + (400./81.)*nf;
202  gammaDF1(5,5) = -21211./162.+ (622./27.)*nf;
203  gammaDF1(5,6) = -20096./243. - (976.*n_d)/81. + (2912.*n_u)/81.;
204  gammaDF1(5,7) = -6040./81. + (220./27.)*nf;
205  gammaDF1(5,8) = -22784./729. - (20704.*n_d)/243. + (28544.*n_u)/243.;
206 
207  gammaDF1(6,6) = 1936./9.-224./27.*nf-2.*model.Beta1(nf);
208 
209  gammaDF1(7,6) = -368./9.+224./81.*nf;
210  gammaDF1(7,7) = 1456./9.-61./27.*nf-2.*model.Beta1(nf);
211 
212  gammaDF1(8,8) = -2.*model.Beta1(nf);
213 
214  gammaDF1(9,9) = -2.*model.Beta1(nf);
215 
216  break;
217 
218  default:
219  throw std::runtime_error("EvolDF1bsg::AnomalousDimension_M(): order not implemented");
220  }
221  return (gammaDF1);
222 }
223 
224 
225 gslpp::matrix<double> EvolDC1::ToRescaledBasis(orders order, unsigned int n_u, unsigned int n_d) const
226 {
227 
228  /* matrix entries for the anomalous dimension in the Chetyrkin, Misiak and Munz basis,
229  ref. hep-ph/9711280v1, hep-ph/0504194 */
230 
231  gslpp::matrix<double> mat(dim, 0.);
232  gslpp::matrix<double> mat1(dim, 0.);
233  unsigned int nf = n_u + n_d;
234  double z3 = gsl_sf_zeta_int(3);
235 
236  mat1(0,6) = - 13454./2187. + 44./2187.*nf;
237  mat1(1,6) = 20644./729. - 88./729.*nf;
238  mat1(2,6) = 119456./729. + 5440./729.*n_d -21776./729.*n_u;
239  mat1(3,6) = - 202990./2187. + 32./729.*n_d*n_d + n_d*(16888./2187. + 64./729.*n_u)
240  - 17132./2187.*n_u + 32./729.*n_u*n_u;
241  mat1(4,6) = 530240./243. + 300928./729.*n_d - 461120./729.*n_u;
242  mat1(5,6) = - 1112344./729. + 5432./729.*n_d*n_d + n_d*(419440./2187. -
243  2744./729.*n_u) + 143392./2187.*n_u - 8176./729.*n_u*n_u;
244 
245  mat1(0,7) = 25759./5832. + 431./5832.*nf;
246  mat1(1,7) = 9733./486. - 917./972.*nf;
247  mat1(2,7) = 82873./243. - 3361./243.*nf;
248  mat1(3,7) = - 570773./2916. - 253./486.*n_d*n_d +n_d*(-40091./5832. -
249  253./243.*n_u) - 40091./5832.*n_u - 253./486.*n_u*n_u;
250  mat1(4,7) = 838684./81. - 14.*n_d*n_d + n_d*(129074./243. - 28.*n_u) +
251  129074./243.*n_u - 14.*n_u*n_u;
252  mat1(5,7) = - 923522./243. - 6031./486.*n_d*n_d + n_d*(-13247./1458. - 6031./243.*n_u)
253  -13247./1458.*n_u - 6031./486.*n_u*n_u;
254 
255  mat1(0,8) = - 22357278./19683. + 14440./6561.*n_d + 144688./6561.*n_u + 6976./243.*z3;
256  mat1(1,8) = - 200848./6561. - 23696./2187.*n_d + 30736./2187.*n_u - 3584./81.*z3;
257  mat1(2,8) = - 1524104./6561. - 176./27.*n_d*n_d + 352./27.*n_u*n_u +
258  n_d*(257564./2187. + 176./27.*n_u - 128./3.*z3) - 256./81.*z3 +
259  n_u*(-382984./2187. + 256./3.*z3);
260  mat1(3,8) = 1535926./19683. + 1984./2187.*n_d*n_d - 5792./2187.*n_u*n_u +
261  n_d*(-256901./6561. - 3808./2187.*n_u - 2720./81.*z3) -
262  5056./243.*z3 + n_u*(34942./6561. + 1600./81.*z3);
263  mat1(4,8) = - 31433600./6561. - 2912./27.*n_d*n_d + 5824./27.*n_u*n_u +
264  n_d*(- 3786616./2187. + 2912./27.*n_u - 1280./3.*z3) -
265  4096./81.*z3 + n_u*(7525520./2187. + 2560./3.*z3);
266  mat1(5,8) = - 48510784./19683. -51296./2187.*n_d*n_d + 54976./2187.*n_u*n_u +
267  n_u*(-11231648./6561. - 22016./81.*z3) + n_d*(340984./6561. +
268  3680./2187.*n_u - 8192./81.*z3) - 80896./243.*z3;
269 
270 
271  switch(order){
272  case(NLO):
273  mat = AnomalousDimension_M(NLO, n_u, n_d);
274  for (int i=0; i<6; i++){
275  for (unsigned int j=6; j<dim; j++){
276  mat(i,j) = mat1(i,j);
277  }
278  }
279  for (unsigned int i=6; i<dim; i++){
280  for (unsigned int j=6; j<dim; j++){
281  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta1(nf);
282  }
283  }
284  return (mat);
285  case(LO):
286  mat = AnomalousDimension_M(LO, n_u, n_d);
287  for (int i=0; i<6; i++){
288  for (unsigned int j=6; j<dim; j++){
289  mat(i,j) = AnomalousDimension_M(NLO, n_u, n_d)(i,j);
290  }
291  }
292  for (unsigned int i=6; i<dim; i++){
293  for (unsigned int j=6; j<dim; j++){
294  mat(i,j) = mat(i,j) + 2. * (i==j) * model.Beta0(nf);
295  }
296  }
297  return (mat);
298  default:
299  throw std::runtime_error("change to rescaled operator basis: order not implemented");
300  }
301 
302 }
303 
304 gslpp::matrix<double> EvolDC1::ToEffectiveBasis(gslpp::matrix<double> mat) const
305 {
306 
307  gslpp::matrix<double> y(dim, 0.);
308 
309  y(0,0) = 1.;
310  y(1,1) = 1.;
311  y(2,2) = 1.;
312  y(3,3) = 1.;
313  y(4,4) = 1.;
314  y(5,5) = 1.;
315  y(6,6) = 1.;
316  y(7,7) = 1.;
317  y(8,8) = 1.;
318  y(9,9) = 1.;
319 
320  y(6,2) = -1./3.;
321  y(6,3) = -4./9.;
322  y(6,4) = -20./3.;
323  y(6,5) = -80./9.;
324 
325  y(7,2) = 1.;
326  y(7,3) = -1./6.;
327  y(7,4) = 20.;
328  y(7,5) = -10./3.;
329 
330  return( (y.inverse()).transpose() * mat * y.transpose() );
331 
332 }
333 
334 gslpp::matrix<double>& EvolDC1::DC1Evol(double mu, double M, orders order, schemes scheme)
335 {
336  switch (scheme) {
337  case NDR:
338  break;
339  case LRI:
340  case HV:
341  default:
342  std::stringstream out;
343  out << scheme;
344  throw std::runtime_error("EvolDC1::Df1EvolDC1(): scheme " + out.str() + " not implemented ");
345  }
346 
347  double alsMZ = model.getAlsMz();
348  double Mz = model.getMz();
349  if(alsMZ == alsMZ_cache && Mz == Mz_cache) {
350  if (mu == this->mu && M == this->M && scheme == this->scheme)
351  return (*Evol(order));
352  }
353  alsMZ_cache = alsMZ;
354  Mz_cache = Mz;
355 
356  if (M < mu) {
357  std::stringstream out;
358  out << "M = " << M << " < mu = " << mu;
359  throw out.str();
360  }
361 
362  setScales(mu, M); // also assign evol to identity
363 
364  double m_down = mu;
365  double m_up = model.AboveTh(m_down);
366  double nf = model.Nf(m_down);
367 
368  while (m_up < M) {
369  DC1Evol(m_down, m_up, nf, scheme);
370  m_down = m_up;
371  m_up = model.AboveTh(m_down);
372  nf += 1.;
373  }
374  DC1Evol(m_down, M, nf, scheme);
375  return (*Evol(order));
376 
377  }
378 
379  void EvolDC1::DC1Evol(double mu, double M, double nf, schemes scheme)
380  {
381 
382  gslpp::matrix<double> resLO(dim, 0.), resNLO(dim, 0.), resNNLO(dim, 0.);
383 
384  int L = 6 - (int) nf;
385  double alsM = model.Als(M) / 4. / M_PI;
386  double alsmu = model.Als(mu) / 4. / M_PI;
387 
388  double eta = alsM / alsmu;
389 
390  for (unsigned int k = 0; k < dim; k++) {
391  double etap = pow(eta, a[L][k] / 2. / model.Beta0(nf));
392  for (unsigned int i = 0; i < dim; i++){
393  for (unsigned int j = 0; j < dim; j++) {
394  resNNLO(i, j) += 0.;
395 
396  if(fabs(e(i).real() - e(j).real() + 2. * model.Beta0(nf))>0.000000000001) {
397  resNLO(i, j) += c[L][i][j][k] * etap * alsmu;
398  resNLO(i, j) += d[L][i][j][k] * etap * alsM;
399  }
400  else{
401  resNLO(i, j) += - c[L][i][j][k] * etap * alsmu * log(eta);
402  }
403  resLO(i, j) += b[L][i][j][k] * etap;
404  }
405  }
406  }
407 
408  switch(order) {
409  case NNLO:
410  *elem[NNLO] = 0.;
411  case NLO:
412  *elem[NLO] = (*elem[LO]) * resNLO + (*elem[NLO]) * resLO;
413  case LO:
414  *elem[LO] = (*elem[LO]) * resLO;
415  break;
416  case FULLNNLO:
417  case FULLNLO:
418  default:
419  throw std::runtime_error("Error in EvolDC1::DC1Evol()");
420  }
421 
422  }
423 
WilsonTemplate< gslpp::matrix< double > >::scheme
schemes scheme
Definition: WilsonTemplate.h:117
EvolDC1::c
double c[3][10][10][10]
Definition: EvolDC1.h:82
EvolDC1::b
double b[3][10][10][10]
Definition: EvolDC1.h:82
EvolDC1::model
const StandardModel & model
Definition: EvolDC1.h:83
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
RGEvolutor
A class for the RG evolutor of the Wilson coefficients.
Definition: RGEvolutor.h:24
WilsonTemplate< gslpp::matrix< double > >::mu
double mu
Definition: WilsonTemplate.h:116
EvolDC1::jssv
gslpp::matrix< gslpp::complex > jssv
Definition: EvolDC1.h:92
RGEvolutor::M
double M
Definition: RGEvolutor.h:142
QCD::Nf
double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:438
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
LO
Definition: OrderScheme.h:33
StandardModel.h
EvolDC1::s_s
gslpp::matrix< gslpp::complex > s_s
Definition: EvolDC1.h:92
NDR
Definition: OrderScheme.h:21
gslpp::matrix< double >::transpose
matrix< double > transpose() const
Definition: gslpp_matrix_double.cpp:166
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:477
EvolDC1::~EvolDC1
virtual ~EvolDC1()
EvolDC1 destructor.
Definition: EvolDC1.cpp:80
QCD::Beta0
double Beta0(const double nf) const
The coefficient for a certain number of flavours .
Definition: QCD.cpp:466
EvolDC1::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: EvolDC1.cpp:304
EvolDC1::Mz_cache
double Mz_cache
Definition: EvolDC1.h:96
schemes
schemes
An enum type for regularization schemes.
Definition: OrderScheme.h:19
gslpp::matrix< double >::inverse
matrix< double > inverse()
Definition: gslpp_matrix_double.cpp:178
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
EvolDC1::nu
int nu
Definition: EvolDC1.h:75
EvolDC1::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: EvolDC1.cpp:83
EvolDC1::DC1Evol
gslpp::matrix< double > & DC1Evol(double mu, double M, orders order, schemes scheme=NDR)
a method returning the evolutor related to the high scale and the low scale
Definition: EvolDC1.cpp:334
EvolDC1::h
gslpp::matrix< gslpp::complex > h
Definition: EvolDC1.h:92
NNLO
Definition: OrderScheme.h:35
StandardModel::Als
double Als(double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
The running QCD coupling in the scheme including QED corrections.
Definition: StandardModel.cpp:602
EvolDC1::EvolDC1
EvolDC1(unsigned int dim, schemes scheme, orders order, const StandardModel &model)
EvolDC1 constructor.
Definition: EvolDC1.cpp:14
EvolDC1::ToRescaledBasis
gslpp::matrix< double > ToRescaledBasis(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: EvolDC1.cpp:225
EvolDC1::vij
gslpp::matrix< gslpp::complex > vij
Definition: EvolDC1.h:92
orders
orders
An enum type for orders in QCD.
Definition: OrderScheme.h:31
EvolDC1::e
gslpp::vector< gslpp::complex > e
Definition: EvolDC1.h:93
LRI
Definition: OrderScheme.h:23
StandardModel::getMz
double getMz() const
A get method to access the mass of the boson .
Definition: StandardModel.h:721
EvolDC1::nd
int nd
Definition: EvolDC1.h:75
EvolDC1::jss
gslpp::matrix< gslpp::complex > jss
Definition: EvolDC1.h:92
EvolDC1::gg
gslpp::matrix< gslpp::complex > gg
Definition: EvolDC1.h:92
RGEvolutor::Evol
gslpp::matrix< double > * Evol(orders order)
Evolution matrix set at a fixed order of QCD coupling.
Definition: RGEvolutor.cpp:103
EvolDC1::js
gslpp::matrix< gslpp::complex > js
Definition: EvolDC1.h:92
EvolDC1::alsMZ_cache
double alsMZ_cache
Definition: EvolDC1.h:95
EvolDC1::dim
unsigned int dim
Definition: EvolDC1.h:94
EvolDC1::d
double d[3][10][10][10]
Definition: EvolDC1.h:82
HV
Definition: OrderScheme.h:22
EvolDC1::a
double a[3][10]
Definition: EvolDC1.h:82
EvolDC1::vi
gslpp::matrix< gslpp::complex > vi
Definition: EvolDC1.h:92
EvolDC1::jv
gslpp::matrix< gslpp::complex > jv
Definition: EvolDC1.h:92
QCD::AboveTh
double AboveTh(const double mu) const
The active flavour threshold above the scale as defined in QCD::Thresholds().
Definition: QCD.cpp:420
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
NLO
Definition: OrderScheme.h:34
EvolDC1::v
gslpp::matrix< gslpp::complex > v
Definition: EvolDC1.h:92
EvolDC1.h
FULLNNLO
Definition: OrderScheme.h:38
FULLNLO
Definition: OrderScheme.h:37
WilsonTemplate< gslpp::matrix< double > >::elem
gslpp::matrix< double > * elem[MAXORDER_QED+1]
Definition: WilsonTemplate.h:114