\( |\Delta F = 1 | \) Evolutor Class More...

#include <EvolDF1nlep.h>

Inheritance diagram for EvolDF1nlep:

Detailed Description

\( |\Delta F = 1 | \) Evolutor Class

This evolutor is properly written to study \( |\Delta F = 1 | \) processes such as no leptonic weak decays of the B meson; it is implemented for the evolution of the 10 Wilson coefficients (related to the 2 current x current + 4 QCD penguins + 4 em penguins)in the standard basis at the NLO in \( \alpha_{strong} \) for QCD corrections and at the NLO in \( \alpha_{em} \) for QED ones; principal reference: hep-ph/9512380v1

Definition at line 16 of file EvolDF1nlep.h.

Public Member Functions
gslpp::matrix< double >	AnomalousDimension_nlep_EM (orders order, unsigned int n_u, unsigned int n_d) const
	a method returning the anomalous dimension matrix given in the standard basis More...

gslpp::matrix< double >	AnomalousDimension_nlep_S (orders order, unsigned int n_u, unsigned int n_d) const
	a method returning the anomalous dimension matrix given in the standard basis More...

gslpp::matrix< double > &	Df1Evolnlep (double mu, double M, orders order, orders_qed order_qed, schemes scheme=NDR)
	a method returning the evolutor related to the high scale \( M \) and the low scale \( \mu \) More...

gslpp::matrix< double > &	Df1Evolnlep3flav (double mu, double M, orders order, orders_qed order_qed, schemes scheme=NDR)

gslpp::matrix< double >	Df1threshold_deltareT (double nf) const
	a method returning the matrix threshold for the QED penguins at the NLO More...

gslpp::matrix< double >	Df1threshold_deltarsT (double nf) const
	a method returning the matrix threshold for the QCD penguins at the NLO More...

	EvolDF1nlep (unsigned int dim, schemes scheme, orders order, orders_qed order_qed, const StandardModel &model)
	EvolDF1nlep constructor. More...

virtual	~EvolDF1nlep ()
	EvolDF1nlep 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	Df1Evolnlep (double mu, double M, double nf, schemes scheme)
	a void type method storing properly the magic numbers for the implementation of the evolutor More...

void	Df1threshold_nlep (double M, double nf)
	a void type method for the implementation of the NLO threshold effects in the evolutor More...

Private Attributes
double	a [4][10]

double	Ale_cache

double	alsMZ_cache

double	b [4][10][10][10]

double	c [4][10][10][10]

double	d [4][10][10][10]

unsigned int	dim

gslpp::vector< gslpp::complex >	e

gslpp::matrix< gslpp::complex >	Gamma_eT

gslpp::matrix< gslpp::complex >	Gamma_s0T

gslpp::matrix< gslpp::complex >	Gamma_s1T

gslpp::matrix< gslpp::complex >	Gamma_seT

gslpp::matrix< gslpp::complex >	ge0

gslpp::matrix< gslpp::complex >	ge0sing

gslpp::matrix< gslpp::complex >	ge11

gslpp::matrix< gslpp::complex >	ge11sing

gslpp::matrix< gslpp::complex >	gs

gslpp::matrix< gslpp::complex >	Js

gslpp::matrix< gslpp::complex >	JsK0singV

gslpp::matrix< gslpp::complex >	JsK0V

gslpp::matrix< gslpp::complex >	JsV

gslpp::matrix< gslpp::complex >	K0

gslpp::matrix< gslpp::complex >	K0sing

gslpp::matrix< gslpp::complex >	K0singV

gslpp::matrix< gslpp::complex >	K0V

gslpp::matrix< gslpp::complex >	K11

gslpp::matrix< gslpp::complex >	K11sing

gslpp::matrix< gslpp::complex >	K11singV

gslpp::matrix< gslpp::complex >	K11V

double	m [4][10][10][10]

double	mn [4][10][10][10]

const StandardModel &	model

double	Mz_cache

double	n [4][10][10][10]

double	o [4][10][10][10]

double	op [4][10][10][10]

double	p [4][10][10][10]

double	q [4][10][10][10]

double	qq [4][10][10][10]

double	r [4][10][10][10]

double	rr [4][10][10][10]

double	s [4][10][10][10]

double	t [4][10][10][10]

gslpp::matrix< gslpp::complex >	V

gslpp::matrix< gslpp::complex >	Vi

gslpp::matrix< gslpp::complex >	ViJs

gslpp::matrix< gslpp::complex >	ViK0

gslpp::matrix< gslpp::complex >	ViK0Js

gslpp::matrix< gslpp::complex >	ViK11

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

◆ EvolDF1nlep()

EvolDF1nlep::EvolDF1nlep	(	unsigned int	dim,
		schemes	scheme,
		orders	order,
		orders_qed	order_qed,
		const StandardModel &	model
	)

EvolDF1nlep constructor.

Parameters

dim	an unsigned integer for the dimension of the evolutor
scheme	an enum "schemes" for the regularization scheme of the evolutor
order	an enum "orders" for the order of QCD perturbation theory of the evolutor
order_qed	an enum "orders_qed" for the order of QED perturbation theory of the evolutor
model	an object of StandardModel class

Definition at line 11 of file EvolDF1nlep.cpp.

: RGEvolutor(dim_i, scheme, order, order_qed), model(model), V(dim_i, 0.), Vi(dim_i, 0.),
gs(dim_i, 0.), Js(dim_i, 0.), ge0(dim_i, 0.), K0(dim_i, 0.), ge11(dim_i, 0.), K11(dim_i, 0.),
JsK0V(dim_i, 0.), ViK0Js(dim_i, 0.), Gamma_s0T(dim_i, 0.), Gamma_s1T(dim_i, 0.),
Gamma_eT(dim_i, 0.), Gamma_seT(dim_i, 0.), JsV(dim_i, 0.), ViJs(dim_i, 0.), K0V(dim_i, 0.),
ViK0(dim_i, 0.), ge0sing(dim_i, 0.), K0sing(dim_i, 0.), K0singV(dim_i, 0.), K11V(dim_i, 0.), 
ViK11(dim_i, 0.), ge11sing(dim_i, 0.), K11sing(dim_i, 0.),K11singV(dim_i, 0.), 
JsK0singV(dim_i, 0.), e(dim_i, 0.), dim(dim_i)
{
 
    int nu = 0, nd = 0;
    double b0 = 0., b1 = 0.;
 
    /* L=3 --> u,d,s,c (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)*/
    for (int L = 3; L>-1; L--) {
 
        b0 = model.Beta0(6 - L);
        b1 = model.Beta1(6 - L);
 
        if (L == 3) {
            nd = 2;
            nu = 1;
        }
        if (L == 2) {
            nd = 2;
            nu = 2;
        }
        if (L == 1) {
            nd = 3;
            nu = 2;
        }
        if (L == 0) {
            nd = 3;
            nu = 3;
        }
 
        Gamma_s0T = AnomalousDimension_nlep_S(LO, nu, nd).transpose();
        Gamma_s1T = AnomalousDimension_nlep_S(NLO, nu, nd).transpose();
        Gamma_eT = AnomalousDimension_nlep_EM(LO, nu, nd).transpose();
        Gamma_seT = AnomalousDimension_nlep_EM(NLO, nu, nd).transpose();
 
        AnomalousDimension_nlep_S(LO, nu, nd).transpose().eigensystem(V, e);
        Vi = V.inverse();
 
        /* magic numbers of U0 */
        for (unsigned int i = 0; i < dim; i++) {
            a[L][i] = e(i).real() / 2. / b0;
            for (unsigned int j = 0; j < dim; j++) {
                for (unsigned int k = 0; k < dim; k++) {
                    b[L][i][j][k] = V(i, k).real() * Vi(k, j).real();
                }
            }
        }
 
        gs = (b1 / 2. / b0 / b0) * Vi * Gamma_s0T * V - (1. / 2. / b0) * Vi * Gamma_s1T * V;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                gs.assign(i, j, gs(i, j) / (1. + a[L][i] - a[L][j]));
            }
        }
        Js = V * gs * Vi;
 
        /*magic numbers related to Js*/
        JsV = Js*V;
        ViJs = Vi*Js;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                for (unsigned int k = 0; k < dim; k++) {
                    c[L][i][j][k] = JsV(i, k).real() * Vi(k, j).real();
                    d[L][i][j][k] = -V(i, k).real() * ViJs(k, j).real();
                }
            }
        }
 
        ge0 = (1. / 2. / b0) * Vi * Gamma_eT * V;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                if (fabs(a[L][j] + 1. - a[L][i]) > 0.00000000001) {
                    ge0.assign(i, j, ge0(i, j) / (1. - a[L][i] + a[L][j]));
                } else {
                    ge0sing.assign(i, j, ge0(i, j) / 2. / b0);
                    ge0.assign(i, j, 0.);
                }
            }
        }
        K0 = V * ge0 * Vi;
        K0sing = V * ge0sing * Vi;
 
        /*magic numbers related to K0*/
        K0V = K0*V;
        ViK0 = Vi * K0;
        K0singV = K0sing*V;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                for (unsigned int k = 0; k < dim; k++) {
                    m[L][i][j][k] = K0V(i, k).real() * Vi(k, j).real();
                    n[L][i][j][k] = -V(i, k).real() * ViK0(k, j).real();
                    mn[L][i][j][k] = K0singV(i, k).real() * Vi(k, j).real();
                }
            }
        }
 
        ge11 = Gamma_seT - (b1 / b0) * Gamma_eT + Gamma_eT * Js - Js * Gamma_eT;
        ge11 = Vi * ge11;
        ge11 = ge11 * V;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                if (fabs(a[L][j] - a[L][i]) > 0.00000000001) {
                    ge11.assign(i, j, ge11(i, j) / (2. * b0 * (a[L][j] - a[L][i])));
                } else {
                    ge11sing.assign(i, j, ge11(i, j) / 2. / b0);
                    ge11.assign(i, j, 0.);
                }
            }
        }
        K11 = V * ge11 * Vi;
        K11sing = V * ge11sing * Vi;
        /*magic numbers related to K11*/
        K11V = K11 * V;
        ViK11 = Vi * K11;
        K11singV = K11sing * V;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                for (unsigned int k = 0; k < dim; k++) {
                    o[L][i][j][k] = K11V(i, k).real() * Vi(k, j).real();
                    p[L][i][j][k] = -V(i, k).real() * ViK11(k, j).real();
                    op[L][i][j][k] = K11singV(i, k).real() * Vi(k, j).real();
                }
            }
        }
 
        /*magic numbers related to K12 and K13*/
        JsK0V = Js * K0 * V;
        ViK0Js = Vi * K0 * Js;
        JsK0singV = Js * K0sing * V;
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
                for (unsigned int k = 0; k < dim; k++) {
                    q[L][i][j][k] = JsK0V(i, k).real() * Vi(k, j).real();
                    r[L][i][j][k] = V(i, k).real() * ViK0Js(k, j).real();
                    s[L][i][j][k] = -JsV(i, k).real() * ViK0(k, j).real();
                    t[L][i][j][k] = -K0V(i, k).real() * ViJs(k, j).real();
                    qq[L][i][j][k] = JsK0singV(i, k).real() * Vi(k, j).real();
                    rr[L][i][j][k] = -K0singV(i, k).real() * ViJs(k, j).real();
                }
            }
        }
    }
}

◆ ~EvolDF1nlep()

EvolDF1nlep::~EvolDF1nlep ( )

virtual

EvolDF1nlep destructor.

Definition at line 161 of file EvolDF1nlep.cpp.

162{

163}

Member Function Documentation

◆ AnomalousDimension_nlep_EM()

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

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

Parameters

order	an enum "orders" for the order of QED perturbation theory of the ADM
n_u	an unsigned integer for the up-type number of d.o.f.
n_d	an unsigned integer for the down-type number of d.o.f.

Returns: the ADM related to QED corrections at the order LO/NLO in the standard basis

Definition at line 320 of file EvolDF1nlep.cpp.

{
 
    /* anomalous dimension related to Buras operators hep-ph/9512380v1 */
    /*gamma(riga, colonna) leading order*/
    unsigned int nf = n_u + n_d; /*n_u\d = active type up/down flavor d.o.f.*/
    gslpp::matrix<double> gammaDF1(dim, 0.);
 
    switch (order) {
 
        case LO:
 
            gammaDF1(0, 0) = -8. / 3.;
            gammaDF1(0, 6) = 16. / 9.;
            gammaDF1(0, 8) = 16. / 9.;
 
            gammaDF1(1, 1) = -8. / 3.;
            gammaDF1(1, 6) = 16. / 27.;
            gammaDF1(1, 8) = 16. / 27.;
 
            gammaDF1(2, 6) = -16. / 27. + 16. / 9. * (n_u - n_d / 2.);
            gammaDF1(2, 8) = -88. / 27. + 16. / 9. * (n_u - n_d / 2.);
 
            gammaDF1(3, 6) = -16. / 9. + 16. / 27. * (n_u - n_d / 2.);
            gammaDF1(3, 8) = -16. / 9. + 16. / 27. * (n_u - n_d / 2.);
            gammaDF1(3, 9) = -8. / 3.;
 
            gammaDF1(4, 6) = 8. / 3. + 16. / 9. * (n_u - n_d / 2.);
            gammaDF1(4, 8) = 16. / 9. * (n_u - n_d / 2.);
 
            gammaDF1(5, 6) = 16. / 27. * (n_u - n_d / 2.);
            gammaDF1(5, 7) = 8. / 3.;
            gammaDF1(5, 8) = 16. / 27. * (n_u - n_d / 2.);
 
            gammaDF1(6, 4) = 4. / 3.;
            gammaDF1(6, 6) = 4. / 3. + 16. / 9. * (n_u + n_d / 4.);
            gammaDF1(6, 8) = 16. / 9. * (n_u + n_d / 4.);
 
            gammaDF1(7, 5) = 4. / 3.;
            gammaDF1(7, 6) = 16. / 27. * (n_u + n_d / 4.);
            gammaDF1(7, 7) = 4. / 3.;
            gammaDF1(7, 8) = 16. / 27. * (n_u + n_d / 4.);
 
            gammaDF1(8, 2) = -4. / 3.;
            gammaDF1(8, 6) = 8. / 27. + 16. / 9. * (n_u + n_d / 4.);
            gammaDF1(8, 8) = -28. / 27. + 16. / 9. * (n_u + n_d / 4.);
 
            gammaDF1(9, 3) = -4. / 3.;
            gammaDF1(9, 6) = 8. / 9. + 16. / 27. * (n_u + n_d / 4.);
            gammaDF1(9, 8) = 8. / 9. + 16. / 27. * (n_u + n_d / 4.);
            gammaDF1(9, 9) = -4. / 3.;
 
            break;
 
        case NLO:
 
            if (!(nf == 3 || nf == 4 || nf == 5 || nf == 6)) {
                throw std::runtime_error("EvolDF1nlep::AnomalousDimension_nlep_EM("
                        "orders order, unsigned int n_u, unsigned int n_d) " " wrong number of flavour");
            }
 
            /*gamma(riga, colonna) next to leading order*/
 
            gammaDF1(0, 0) = 194. / 9.;
            gammaDF1(0, 1) = -2. / 3.;
            gammaDF1(0, 2) = -88. / 243.;
            gammaDF1(0, 3) = 88. / 81.;
            gammaDF1(0, 4) = -88. / 243.;
            gammaDF1(0, 5) = 88. / 81.;
            gammaDF1(0, 6) = 152. / 27.;
            gammaDF1(0, 7) = 40. / 9.;
            gammaDF1(0, 8) = 136. / 27.;
            gammaDF1(0, 9) = 56. / 9.;
 
            gammaDF1(1, 0) = 25. / 3.;
            gammaDF1(1, 1) = -49. / 9.;
            gammaDF1(1, 2) = -556. / 729.;
            gammaDF1(1, 3) = 556. / 243.;
            gammaDF1(1, 4) = -556. / 729.;
            gammaDF1(1, 5) = 556. / 243.;
            gammaDF1(1, 6) = -484. / 729.;
            gammaDF1(1, 7) = -124. / 27.;
            gammaDF1(1, 8) = -3148. / 729.;
            gammaDF1(1, 9) = 172. / 27.;
 
            gammaDF1(2, 2) = 1690. / 729. - 136. / 243. * (n_u - n_d / 2.);
            gammaDF1(2, 3) = -1690. / 243. + 136. / 81. * (n_u - n_d / 2.);
            gammaDF1(2, 4) = 232. / 729. - 136. / 243. * (n_u - n_d / 2.);
            gammaDF1(2, 5) = -232. / 243. + 136. / 81. * (n_u - n_d / 2.);
            gammaDF1(2, 6) = 3136. / 729. + 104. / 27. * (n_u - n_d / 2.);
            gammaDF1(2, 7) = 64. / 27. + 88. / 9. * (n_u - n_d / 2.);
            gammaDF1(2, 8) = 20272. / 729. + 184. / 27. * (n_u - n_d / 2.);
            gammaDF1(2, 9) = -112. / 27. + 8. / 9. * (n_u - n_d / 2.);
 
            gammaDF1(3, 2) = -641. / 243. - 388. / 729. * n_u + 32. / 729. * n_d;
            gammaDF1(3, 3) = -655. / 81. + 388. / 243. * n_u - 32. / 243. * n_d;
            gammaDF1(3, 4) = 88. / 243. - 388. / 729 * n_u + 32. / 729. * n_d;
            gammaDF1(3, 5) = -88. / 81. + 388. / 243. * n_u - 32. / 243. * n_d;
            gammaDF1(3, 6) = -152. / 27. + 3140. / 729. * n_u + 656. / 729. * n_d;
            gammaDF1(3, 7) = -40. / 9. - 100. / 27. * n_u - 16. / 27. * n_d;
            gammaDF1(3, 8) = 170. / 27. + 908. / 729. * n_u + 1232. / 729. * n_d;
            gammaDF1(3, 9) = -14. / 3. + 148. / 27. * n_u - 80. / 27 * n_d;
 
            gammaDF1(4, 2) = -136. / 243. * (n_u - n_d / 2.);
            gammaDF1(4, 3) = 136. / 81. * (n_u - n_d / 2.);
            gammaDF1(4, 4) = -2. - 136. / 243. * (n_u - n_d / 2.);
            gammaDF1(4, 5) = 6. + 136. / 81. * (n_u - n_d / 2.);
            gammaDF1(4, 6) = -232. / 9. + 104. / 27. * (n_u - n_d / 2.);
            gammaDF1(4, 7) = 40. / 3. + 88. / 9. * (n_u - n_d / 2.);
            gammaDF1(4, 8) = 184. / 27. * (n_u - n_d / 2.);
            gammaDF1(4, 9) = 8. / 9. * (n_u - n_d / 2.);
 
            gammaDF1(5, 2) = -748. / 729. * n_u + 212. / 729. * n_d;
            gammaDF1(5, 3) = 748. / 243. * n_u - 212. / 243. * n_d;
            gammaDF1(5, 4) = 3. - 748. / 729. * n_u + 212. / 729. * n_d;
            gammaDF1(5, 5) = 7. + 748. / 243. * n_u - 212. / 243. * n_d;
            gammaDF1(5, 6) = -2. - 5212. / 729. * n_u + 4832. / 729. * n_d;
            gammaDF1(5, 7) = 182. / 9. + 188. / 27. * n_u - 160. / 27. * n_d;
            gammaDF1(5, 8) = -2260. / 729. * n_u + 2816. / 729. * n_d;
            gammaDF1(5, 9) = -140. / 27. * n_u + 64. / 27. * n_d;
 
            gammaDF1(6, 2) = -136. / 243. * (n_u + n_d / 4.);
            gammaDF1(6, 3) = 136. / 81. * (n_u + n_d / 4.);
            gammaDF1(6, 4) = -116. / 9. - 136. / 243. * (n_u + n_d / 4.);
            gammaDF1(6, 5) = 20. / 3. + 136. / 81. * (n_u + n_d / 4.);
            gammaDF1(6, 6) = -134. / 9. + 104. / 27. * (n_u + n_d / 4.);
            gammaDF1(6, 7) = 38. / 3. + 88. / 9. * (n_u + n_d / 4.);
            gammaDF1(6, 8) = 184. / 27. * (n_u + n_d / 4.);
            gammaDF1(6, 9) = 8. / 9. * (n_u + n_d / 4.);
 
            gammaDF1(7, 2) = -748. / 729. * n_u - 106. / 729. * n_d;
            gammaDF1(7, 3) = 748. / 243. * n_u + 106. / 243. * n_d;
            gammaDF1(7, 4) = -1. - 748. / 729. * n_u - 106. / 729. * n_d;
            gammaDF1(7, 5) = 91. / 9. + 748. / 243. * n_u + 106. / 243. * n_d;
            gammaDF1(7, 6) = 2. - 5212. / 729. * n_u - 2416. / 729. * n_d;
            gammaDF1(7, 7) = 154. / 9. + 188. / 27. * n_u + 80. / 27. * n_d;
            gammaDF1(7, 8) = -2260. / 729. * n_u - 1408. / 729. * n_d;
            gammaDF1(7, 9) = -140. / 27. * n_u - 32. / 27. * n_d;
 
            gammaDF1(8, 2) = 7012. / 729. - 136. / 243. * (n_u + n_d / 4.);
            gammaDF1(8, 3) = 764. / 243. + 136. / 81. * (n_u + n_d / 4.);
            gammaDF1(8, 4) = -116. / 729. - 136. / 243. * (n_u + n_d / 4.);
            gammaDF1(8, 5) = 116. / 243. + 136. / 81. * (n_u + n_d / 4.);
            gammaDF1(8, 6) = -1568. / 729. + 104. / 27. * (n_u + n_d / 4.);
            gammaDF1(8, 7) = -32. / 27. + 88. / 9. * (n_u + n_d / 4.);
            gammaDF1(8, 8) = 5578. / 729. + 184. / 27. * (n_u + n_d / 4.);
            gammaDF1(8, 9) = 38. / 27. + 8. / 9. * (n_u + n_d / 4.);
 
            gammaDF1(9, 2) = 1333. / 243. - 388. / 729. * n_u - 16. / 729. * n_d;
            gammaDF1(9, 3) = 107. / 81. + 388. / 243. * n_u + 16. / 243. * n_d;
            gammaDF1(9, 4) = -44. / 243. - 388. / 729. * n_u - 16. / 729. * n_d;
            gammaDF1(9, 5) = 44. / 81. + 388. / 243. * n_u + 16. / 243. * n_d;
            gammaDF1(9, 6) = 76. / 27. + 3140. / 729. * n_u - 328. / 729. * n_d;
            gammaDF1(9, 7) = 20. / 9. - 100. / 27. * n_u + 8. / 27. * n_d;
            gammaDF1(9, 8) = 140. / 27. + 908. / 729. * n_u - 616. / 729. * n_d;
            gammaDF1(9, 9) = -28. / 9. + 148. / 27. * n_u + 40. / 27. * n_d;
 
            break;
 
        default:
            std::stringstream out;
            out << order;
            throw std::runtime_error("EvolDF1nlep::AnomalousDimension_nlep_EM("
                    "orders order, unsigned int n_u, unsigned int n_d) "
                    + out.str() + " not implemented");
 
    }
 
    return (gammaDF1);
 
}

◆ AnomalousDimension_nlep_S()

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

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

Parameters

order	an enum "orders" for the order of QCD perturbation theory of the ADM
n_u	an unsigned integer for the up-type number of d.o.f.
n_d	an unsigned integer for the down-type number of d.o.f.

Returns: the ADM related to QCD corrections at the order LO/NLO in the standard basis

Definition at line 165 of file EvolDF1nlep.cpp.

{
 
    /* anomalous dimension related to Delta F = 1 operators in Buras basis, hep-ph/9512380v1 */
 
    /*gamma(row, column) leading order*/
 
    unsigned int nf = n_u + n_d; /*n_u/d = active type up/down flavor d.o.f.*/
    gslpp::matrix<double> gammaDF1(dim, 0.);
 
    switch (order) {
 
        case LO:
 
            gammaDF1(0, 0) = -2.;
            gammaDF1(0, 1) = 6.;
 
 
            gammaDF1(1, 0) = 6.;
            gammaDF1(1, 1) = -2.;
            gammaDF1(1, 2) = -2. / 9.;
            gammaDF1(1, 3) = 2. / 3.;
            gammaDF1(1, 4) = -2. / 9.;
            gammaDF1(1, 5) = 2. / 3.;
 
            gammaDF1(2, 2) = -22. / 9.;
            gammaDF1(2, 3) = 22. / 3.;
            gammaDF1(2, 4) = -4. / 9.;
            gammaDF1(2, 5) = 4. / 3.;
 
            gammaDF1(3, 2) = 6. - 2. / 9. * nf;
            gammaDF1(3, 3) = -2. + 2. / 3. * nf;
            gammaDF1(3, 4) = -2. / 9. * nf;
            gammaDF1(3, 5) = 2. / 3. * nf;
 
            gammaDF1(4, 4) = 2.;
            gammaDF1(4, 5) = -6.;
 
            gammaDF1(5, 2) = -2. / 9. * nf;
            gammaDF1(5, 3) = 2. / 3. * nf;
            gammaDF1(5, 4) = -2. / 9. * nf;
            gammaDF1(5, 5) = -16. + 2. / 3. * nf;
 
            gammaDF1(6, 6) = 2.;
            gammaDF1(6, 7) = -6.;
 
            gammaDF1(7, 2) = -2. / 9. * (n_u - n_d / 2.);
            gammaDF1(7, 3) = 2. / 3. * (n_u - n_d / 2.);
            gammaDF1(7, 4) = -2. / 9. * (n_u - n_d / 2.);
            gammaDF1(7, 5) = 2. / 3. * (n_u - n_d / 2.);
            gammaDF1(7, 7) = -16.;
 
            gammaDF1(8, 2) = 2. / 9.;
            gammaDF1(8, 3) = -2. / 3.;
            gammaDF1(8, 4) = 2. / 9.;
            gammaDF1(8, 5) = -2. / 3.;
            gammaDF1(8, 8) = -2.;
            gammaDF1(8, 9) = 6.;
 
            gammaDF1(9, 2) = -2. / 9. * (n_u - n_d / 2.);
            gammaDF1(9, 3) = 2. / 3. * (n_u - n_d / 2.);
            gammaDF1(9, 4) = -2. / 9. * (n_u - n_d / 2.);
            gammaDF1(9, 5) = 2. / 3. * (n_u - n_d / 2.);
            gammaDF1(9, 8) = 6.;
            gammaDF1(9, 9) = -2.;
 
            break;
 
        case NLO:
 
            if (!(nf == 3 || nf == 4 || nf == 5 || nf == 6)) {
                throw std::runtime_error("EvolDF1nlep::AnomalousDimension_nlep_S("
                        "orders order, unsigned int n_u, unsigned int n_d) " " wrong number of flavour");
            }
 
            /*gamma(riga, colonna) next to leading order*/
 
            gammaDF1(0, 0) = -21. / 2. - 2. / 9. * nf;
            gammaDF1(0, 1) = 7. / 2. + 2. / 3. * nf;
            gammaDF1(0, 2) = 79. / 9.;
            gammaDF1(0, 3) = -7. / 3.;
            gammaDF1(0, 4) = -65. / 9.;
            gammaDF1(0, 5) = -7. / 3.;
 
 
            gammaDF1(1, 0) = 7. / 2. + 2. / 3. * nf;
            gammaDF1(1, 1) = -21. / 2. - 2. / 9. * nf;
            gammaDF1(1, 2) = -202. / 243.;
            gammaDF1(1, 3) = 1354. / 81.;
            gammaDF1(1, 4) = -1192. / 243.;
            gammaDF1(1, 5) = 904. / 81.;
 
            gammaDF1(2, 2) = -5911. / 486. + 71. / 9. * nf;
            gammaDF1(2, 3) = 5983. / 162. + 1. / 3. * nf;
            gammaDF1(2, 4) = -2384. / 243. - 71. / 9. * nf;
            gammaDF1(2, 5) = 1808. / 81. - 1. / 3. * nf;
 
            gammaDF1(3, 2) = 379. / 18. + 56. / 243. * nf;
            gammaDF1(3, 3) = -91. / 6. + 808. / 81. * nf;
            gammaDF1(3, 4) = -130. / 9. - 502. / 243. * nf;
            gammaDF1(3, 5) = -14. / 3. + 646. / 81. * nf;
 
            gammaDF1(4, 2) = -61. / 9. * nf;
            gammaDF1(4, 3) = -11. / 3. * nf;
            gammaDF1(4, 4) = 71. / 3. + 61. / 9. * nf;
            gammaDF1(4, 5) = -99. + 11. / 3. * nf;
 
            gammaDF1(5, 2) = -682. / 243. * nf;
            gammaDF1(5, 3) = 106. / 81. * nf;
            gammaDF1(5, 4) = -225. / 2. + 1676. / 243. * nf;
            gammaDF1(5, 5) = -1343. / 6. + 1348. / 81. * nf;
 
            gammaDF1(6, 2) = -61. / 9. * (n_u - n_d / 2.);
            gammaDF1(6, 3) = -11. / 3. * (n_u - n_d / 2.);
            gammaDF1(6, 4) = 83. / 9. * (n_u - n_d / 2.);
            gammaDF1(6, 5) = -11. / 3. * (n_u - n_d / 2.);
            gammaDF1(6, 6) = 71. / 3. - 22. / 9. * nf;
            gammaDF1(6, 7) = -99. + 22. / 3. * nf;
 
            gammaDF1(7, 2) = -682. / 243. * (n_u - n_d / 2.);
            gammaDF1(7, 3) = 106. / 81. * (n_u - n_d / 2.);
            gammaDF1(7, 4) = 704. / 243. * (n_u - n_d / 2.);
            gammaDF1(7, 5) = 736. / 81. * (n_u - n_d / 2.);
            gammaDF1(7, 6) = -225. / 2. + 4 * nf;
            gammaDF1(7, 7) = -1343. / 6. + 68. / 9. * nf;
 
            gammaDF1(8, 2) = 202. / 243. + 73. / 9. * (n_u - n_d / 2.);
            gammaDF1(8, 3) = -1354. / 81. - 1. / 3. * (n_u - n_d / 2.);
            gammaDF1(8, 4) = 1192. / 243. - 71. / 9. * (n_u - n_d / 2.);
            gammaDF1(8, 5) = -904. / 81. - 1. / 3. * (n_u - n_d / 2.);
            gammaDF1(8, 8) = -21. / 2. - 2. / 9. * nf;
            gammaDF1(8, 9) = 7. / 2. + 2. / 3. * nf;
 
            gammaDF1(9, 2) = -79. / 9. - 106. / 243. * (n_u - n_d / 2.);
            gammaDF1(9, 3) = 7. / 3. + 826. / 81. * (n_u - n_d / 2.);
            gammaDF1(9, 4) = 65. / 9. - 502. / 243. * (n_u - n_d / 2.);
            gammaDF1(9, 5) = 7. / 3. + 646. / 81. * (n_u - n_d / 2.);
            gammaDF1(9, 8) = 7. / 2. + 2. / 3. * nf;
            gammaDF1(9, 9) = -21. / 2. - 2. / 9. * nf;
 
            break;
 
        default:
            std::stringstream out;
            out << order;
            throw std::runtime_error("EvolDF1nlep::AnomalousDimension_nlep_S("
                    "orders order, unsigned int n_u, unsigned int n_d) "
                    + out.str() + " not implemented");
 
    }
 
    return (gammaDF1);
 
}

◆ Df1Evolnlep() [1/2]

void EvolDF1nlep::Df1Evolnlep	(	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

mu	a double for the low scale of the evolution
M	a double for the high scale of the evolution
nf	a double for the active number of flavors
scheme	an enum "schemes" for the regularization scheme of the evolutor

Definition at line 647 of file EvolDF1nlep.cpp.

{
 
    gslpp::matrix<double> resLO(dim, 0.), resNLO(dim, 0.), resLO_ew(dim, 0.), resNLO_QED(dim, 0.);
 
    int L = 6 - (int) nf;
    double alsM = model.Als(M) / 4. / M_PI;
    double alsmu = model.Als(mu) / 4. / M_PI;
    double ale = model.getAle() / 4. / M_PI;
 
    double eta = alsM / alsmu;
 
    //The calculation of matrix entries for the various orders should be moved inside the switch to avoid wasting time on unnecessary calculations
    
    for (unsigned int k = 0; k < dim; k++) {
        double etap = pow(eta, a[L][k]);
        for (unsigned int i = 0; i < dim; i++) {
            for (unsigned int j = 0; j < dim; j++) {
 
                resLO(i, j) += b[L][i][j][k] * etap;
 
                resNLO(i, j) += c[L][i][j][k] * etap * alsmu;
                resNLO(i, j) += d[L][i][j][k] * etap * alsM;
 
                resLO_ew(i, j) += m[L][i][j][k] * etap * ale / alsmu;
                resLO_ew(i, j) += n[L][i][j][k] * etap * ale / alsM;
                resLO_ew(i, j) += mn[L][i][j][k] * etap * ale / alsM * log(eta);
 
                resNLO_QED(i, j) += o[L][i][j][k] * etap * ale;
                resNLO_QED(i, j) += p[L][i][j][k] * etap * ale;
                resNLO_QED(i, j) += op[L][i][j][k] * etap * ale * log(eta);
 
                resNLO_QED(i, j) += q[L][i][j][k] * etap * ale;
                resNLO_QED(i, j) += r[L][i][j][k] * etap * ale;
                resNLO_QED(i, j) += s[L][i][j][k] * etap * ale / eta;
                resNLO_QED(i, j) += t[L][i][j][k] * etap * ale * eta;
                resNLO_QED(i, j) += qq[L][i][j][k] * etap * ale * log(eta);
                resNLO_QED(i, j) += rr[L][i][j][k] * etap * ale * log(eta);
                
                // unreasonable large entries: this fixes the issue, weird numerical instability needs investigation
                if(L==3){
                    if((i==6) and (j==6)){
                    resNLO_QED(i, j) -= op[L][i][j][k] * etap * ale * log(eta);
                    resNLO_QED(i, j) -= qq[L][i][j][k] * etap * ale * log(eta);
                    resNLO_QED(i, j) -= rr[L][i][j][k] * etap * ale * log(eta);
                    }
                    if((i==7) and ((j==6) or (j==7))){
                    resNLO_QED(i, j) -= op[L][i][j][k] * etap * ale * log(eta);
                    resNLO_QED(i, j) -= qq[L][i][j][k] * etap * ale * log(eta);
                    resNLO_QED(i, j) -= rr[L][i][j][k] * etap * ale * log(eta);
                    }
                }
            }
        }
    }
    
    switch (order_qed) {
        case NLO_QED11:
            *elem[NLO_QED11] = (*elem[NLO]) * resLO_ew +
                    (*elem[NLO_QED11]) * resLO + (*elem[LO]) * resNLO_QED + 
                    (*elem[LO_QED]) * resNLO;
        case LO_QED:
            *elem[LO_QED] = (*elem[LO]) * resLO_ew + (*elem[LO_QED]) * resLO;
            break;
        default:
            throw std::runtime_error("Error in EvolDF1nlep::Df1Evolnlep()");
    }
 
    switch (order) {
        case NNLO:
            *elem[NNLO] = 0.;
        case NLO:
            *elem[NLO] = (*elem[LO]) * resNLO + (*elem[NLO]) * resLO;
        case LO:
            *elem[LO] = (*elem[LO]) * resLO;
            break;
        default:
            throw std::runtime_error("Error in EvolDF1nlep::Df1Evolnlep()");
    }
}

◆ Df1Evolnlep() [2/2]

gslpp::matrix< double > & EvolDF1nlep::Df1Evolnlep	(	double	mu,
		double	M,
		orders	order,
		orders_qed	order_qed,
		schemes	scheme = `NDR`
	)

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

Parameters

mu	a double for the low scale of the evolution
M	a double for the high scale of the evolution
order	an enum "orders" for the order of QCD perturbation theory of the evolutor
order_qed	an enum "orders_qed" for the order of QED perturbation theory of the evolutor
scheme	an enum "schemes" for the regularization scheme of the evolutor

Returns: the evolutor \( U (\mu , M) \)

Definition at line 588 of file EvolDF1nlep.cpp.

{
    switch (scheme) {
        case NDR:
            break;
        case LRI:
        case HV:
        default:
            std::stringstream out;
            out << scheme;
            throw std::runtime_error("EvolDF1nlep::Df1Evolnlep_EM(): scheme " + out.str()
                    + " not implemented ");
    }
 
    double alsMZ = model.getAlsMz();
    double Mz = model.getMz();
    double Ale = model.getAle();
    if (alsMZ == alsMZ_cache && Mz == Mz_cache && Ale == Ale_cache) {
        if (mu == this->mu && M == this->M && scheme == this->scheme && order_qed == NO_QED)
            return (*Evol(order));
 
        if (mu == this->mu && M == this->M && scheme == this->scheme && order_qed == NLO_QED11)
            return (*Evol(order_qed));
    }
    alsMZ_cache = alsMZ;
    Mz_cache = Mz;
    Ale_cache = Ale;
 
    if (M < mu) {
        std::stringstream out;
        out << "M = " << M << " < mu = " << mu;
        throw out.str();
    }
 
    setScales(mu, M); // also assign evol to identity
 
    double m_down = mu;
    double m_up = model.AboveTh(m_down);
    double nf = model.Nf(m_down);
 
    while (m_up < M) {
        Df1Evolnlep(m_down, m_up, nf, scheme);
        Df1threshold_nlep(m_up, nf + 1.);
        m_down = m_up;
        m_up = model.AboveTh(m_down);
        nf += 1.;
    }
 
    Df1Evolnlep(m_down, M, nf, scheme);
 
    if (order_qed != NO_QED) {
        return (*Evol(order_qed));
    }
    else {
        return (*Evol(order));
    }
 
}

◆ Df1Evolnlep3flav()

gslpp::matrix< double > & EvolDF1nlep::Df1Evolnlep3flav	(	double	mu,
		double	M,
		orders	order,
		orders_qed	order_qed,
		schemes	scheme = `NDR`
	)

Definition at line 760 of file EvolDF1nlep.cpp.

{
    switch (scheme) {
        case NDR:
            break;
        case LRI:
        case HV:
        default:
            std::stringstream out;
            out << scheme;
            throw std::runtime_error("EvolDF1nlep::Df1Evolnlep_EM(): scheme " + out.str()
                    + " not implemented ");
    }
    
    double alsMZ = model.getAlsMz();
    double Mz = model.getMz();
    double Ale = model.getAle();
    if (alsMZ == alsMZ_cache && Mz == Mz_cache && Ale == Ale_cache) {
        if (mu == this->mu && M == this->M && scheme == this->scheme && order_qed == NO_QED)
            return (*Evol(order));
 
        if (mu == this->mu && M == this->M && scheme == this->scheme && order_qed == NLO_QED11)
            return (*Evol(order_qed));
    }
    
    alsMZ_cache = alsMZ;
    Mz_cache = Mz;
    Ale_cache = Ale;
 
    setScales(mu, M); // also assign evol to identity
 
    Df1Evolnlep(mu, M, 3, scheme);
 
    if (order_qed != NO_QED) {
        return (*Evol(order_qed));
    }
    else {
        return (*Evol(order));
    }
 
}

◆ Df1threshold_deltareT()

gslpp::matrix< double > EvolDF1nlep::Df1threshold_deltareT ( double nf ) const

a method returning the matrix threshold for the QED penguins at the NLO

Parameters

nf	a double for the active number of flavors

Returns: QED matrix threshold for QED penguin operators

Definition at line 537 of file EvolDF1nlep.cpp.

{
 
    gslpp::matrix<double> delta_reT(dim, 0.);
 
    if (nf == 3. || nf == 5.) {
 
        delta_reT(6, 2) = 20. / 27.;
        delta_reT(6, 4) = 20. / 81.;
        delta_reT(6, 4) = 20. / 27.;
        delta_reT(6, 5) = 20. / 81.;
        delta_reT(6, 6) = -10. / 27.;
        delta_reT(6, 7) = -10. / 81.;
        delta_reT(6, 8) = -10. / 27.;
        delta_reT(6, 9) = -10. / 81.;
        delta_reT(8, 2) = 20. / 27.;
        delta_reT(8, 3) = 20. / 81.;
        delta_reT(8, 4) = 20. / 27.;
        delta_reT(8, 5) = 20. / 81.;
        delta_reT(8, 6) = -10. / 27.;
        delta_reT(8, 7) = -10. / 81.;
        delta_reT(8, 8) = -10. / 27.;
        delta_reT(8, 9) = -10. / 81.;
 
    }
    else {
 
        delta_reT(6, 2) = -40. / 27.;
        delta_reT(6, 3) = -40. / 81.;
        delta_reT(6, 4) = -40. / 27.;
        delta_reT(6, 5) = -40. / 81.;
        delta_reT(6, 5) = -40. / 27.;
        delta_reT(6, 6) = -40. / 81.;
        delta_reT(6, 7) = -40. / 27.;
        delta_reT(6, 8) = -40. / 81.;
        delta_reT(8, 2) = -40. / 27.;
        delta_reT(8, 3) = -40. / 81.;
        delta_reT(8, 4) = -40. / 27.;
        delta_reT(8, 5) = -40. / 81.;
        delta_reT(8, 6) = -40. / 27.;
        delta_reT(8, 7) = -40. / 81.;
        delta_reT(8, 8) = -40. / 27.;
        delta_reT(8, 9) = -40. / 81.;
 
    }
 
    return (delta_reT);
 
}

◆ Df1threshold_deltarsT()

gslpp::matrix< double > EvolDF1nlep::Df1threshold_deltarsT ( double nf ) const

a method returning the matrix threshold for the QCD penguins at the NLO

Parameters

nf	a double for the active number of flavors

Returns: matrix threshold for QCD penguin operators

Definition at line 492 of file EvolDF1nlep.cpp.

{
 
    gslpp::matrix <double> delta_rsT(dim, 0.);
 
    delta_rsT(2, 3) = 5. / 27.;
    delta_rsT(2, 5) = 5. / 27.;
    delta_rsT(3, 3) = -5. / 9.;
    delta_rsT(4, 5) = -5. / 9.;
    delta_rsT(4, 3) = 5. / 27.;
    delta_rsT(4, 5) = 5. / 27.;
    delta_rsT(5, 3) = -5. / 9.;
    delta_rsT(5, 5) = -5. / 9.;
 
    if (nf == 3. || nf == 5.) {
 
        delta_rsT(2, 7) = -5. / 54.;
        delta_rsT(2, 9) = -5. / 54.;
        delta_rsT(3, 7) = 5. / 18.;
        delta_rsT(3, 9) = 5. / 18.;
        delta_rsT(4, 7) = -5. / 54.;
        delta_rsT(4, 9) = -5. / 54.;
        delta_rsT(5, 7) = 5. / 18.;
        delta_rsT(5, 9) = 5. / 18.;
    }
 
 
 
    else {
 
        delta_rsT(2, 7) = 5. / 27.;
        delta_rsT(2, 9) = 5. / 27.;
        delta_rsT(3, 7) = -5. / 9.;
        delta_rsT(3, 9) = -5. / 9.;
        delta_rsT(4, 7) = 5. / 27.;
        delta_rsT(4, 9) = 5. / 27.;
        delta_rsT(5, 7) = -5. / 9.;
        delta_rsT(5, 9) = -5. / 9.;
 
    }
 
    return (delta_rsT);
 
}

◆ Df1threshold_nlep()

void EvolDF1nlep::Df1threshold_nlep	(	double	M,
		double	nf
	)

private

a void type method for the implementation of the NLO threshold effects in the evolutor

Parameters

M	a double for the high scale of the evolution
nf	a double for the active number of flavors

Definition at line 728 of file EvolDF1nlep.cpp.

{
 
    gslpp::matrix<double> drsT(dim, 0.), dreT(dim, 0.);
 
    double alsM = model.Als(M) / 4. / M_PI;
    double ale = model.getAle() / 4. / M_PI;
 
    drsT = alsM * Df1threshold_deltarsT(nf);
    dreT = ale * Df1threshold_deltareT(nf);
 
    switch (order_qed) {
        case NLO_QED11:
            *elem[NLO_QED11] += (*elem[LO]) * dreT + (*elem[LO_QED]) * drsT;
            break;
        default:
            throw std::runtime_error("Error in EvolDF1nlep::Df1threshold_nlep()");
    }
 
    switch (order) {
        case NNLO:
            *elem[NNLO] = 0.;
        case NLO:
            *elem[NLO] += (*elem[LO]) * drsT;
            break;
        default:
            throw std::runtime_error("Error in EvolDF1nlep::Df1threshold_nlep()");
    }
 
 
}

Member Data Documentation

◆ a

double EvolDF1nlep::a[4][10]

private

Parameters

nu	an unsigned integer for the up-type number of d.o.f.
nu	an unsigned integer for the down-type number of d.o.f.
a	array of double for the magic numbers of the evolutor ( LO evolution )
b	array of double for the magic numbers of the evolutor ( LO evolution )
c	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{em} / \alpha_{strong}(\mu) \) )
d	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{em} / \alpha_{strong}(M) \) )
m	array of double for the magic numbers of the evolutor ( NLO evolution, associated to \( \alpha_{strong}(\mu) \) )
n	array of double for the magic numbers of the evolutor ( NLO evolution, associated to \( \alpha_{strong}(M) \) )
o	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{em} \) )
p	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{em} \) )
q	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{strong}(M) / \alpha_{strong}(\mu) * \alpha_{em} \) )
r	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{em} \) )
s	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{em} \) )
t	array of double for the magic numbers of the evolutor ( QED corrections proportional to \( \alpha_{strong}(\mu) / \alpha_{strong}(M) * \alpha_{em} \) )

Definition at line 103 of file EvolDF1nlep.h.

◆ Ale_cache

double EvolDF1nlep::Ale_cache

private

Definition at line 130 of file EvolDF1nlep.h.

◆ alsMZ_cache

double EvolDF1nlep::alsMZ_cache

private

Definition at line 128 of file EvolDF1nlep.h.

◆ b

double EvolDF1nlep::b[4][10][10][10]

private

Definition at line 103 of file EvolDF1nlep.h.

◆ c

double EvolDF1nlep::c[4][10][10][10]

private

Definition at line 103 of file EvolDF1nlep.h.

◆ d

double EvolDF1nlep::d[4][10][10][10]

private

Definition at line 103 of file EvolDF1nlep.h.

◆ dim

unsigned int EvolDF1nlep::dim

private

Definition at line 127 of file EvolDF1nlep.h.

◆ e

gslpp::vector<gslpp::complex> EvolDF1nlep::e

private

Definition at line 126 of file EvolDF1nlep.h.

◆ Gamma_eT

gslpp::matrix<gslpp::complex> EvolDF1nlep::Gamma_eT

private

Definition at line 123 of file EvolDF1nlep.h.

◆ Gamma_s0T

gslpp::matrix<gslpp::complex> EvolDF1nlep::Gamma_s0T

private

Definition at line 123 of file EvolDF1nlep.h.

◆ Gamma_s1T

gslpp::matrix<gslpp::complex> EvolDF1nlep::Gamma_s1T

private

Definition at line 123 of file EvolDF1nlep.h.

◆ Gamma_seT

gslpp::matrix<gslpp::complex> EvolDF1nlep::Gamma_seT

private

Definition at line 123 of file EvolDF1nlep.h.

◆ ge0

gslpp::matrix<gslpp::complex> EvolDF1nlep::ge0

private

Definition at line 122 of file EvolDF1nlep.h.

◆ ge0sing

gslpp::matrix<gslpp::complex> EvolDF1nlep::ge0sing

private

Definition at line 124 of file EvolDF1nlep.h.

◆ ge11

gslpp::matrix<gslpp::complex> EvolDF1nlep::ge11

private

Definition at line 122 of file EvolDF1nlep.h.

◆ ge11sing

gslpp::matrix<gslpp::complex> EvolDF1nlep::ge11sing

private

Definition at line 124 of file EvolDF1nlep.h.

◆ gs

gslpp::matrix<gslpp::complex> EvolDF1nlep::gs

private

Definition at line 122 of file EvolDF1nlep.h.

◆ Js

gslpp::matrix<gslpp::complex> EvolDF1nlep::Js

private

Definition at line 122 of file EvolDF1nlep.h.

◆ JsK0singV

gslpp::matrix<gslpp::complex> EvolDF1nlep::JsK0singV

private

Definition at line 125 of file EvolDF1nlep.h.

◆ JsK0V

gslpp::matrix<gslpp::complex> EvolDF1nlep::JsK0V

private

Definition at line 122 of file EvolDF1nlep.h.

◆ JsV

gslpp::matrix<gslpp::complex> EvolDF1nlep::JsV

private

Definition at line 123 of file EvolDF1nlep.h.

◆ K0

gslpp::matrix<gslpp::complex> EvolDF1nlep::K0

private

Definition at line 122 of file EvolDF1nlep.h.

◆ K0sing

gslpp::matrix<gslpp::complex> EvolDF1nlep::K0sing

private

Definition at line 124 of file EvolDF1nlep.h.

◆ K0singV

gslpp::matrix<gslpp::complex> EvolDF1nlep::K0singV

private

Definition at line 124 of file EvolDF1nlep.h.

◆ K0V

gslpp::matrix<gslpp::complex> EvolDF1nlep::K0V

private

Definition at line 124 of file EvolDF1nlep.h.

◆ K11

gslpp::matrix<gslpp::complex> EvolDF1nlep::K11

private

Definition at line 122 of file EvolDF1nlep.h.

◆ K11sing

gslpp::matrix<gslpp::complex> EvolDF1nlep::K11sing

private

Definition at line 125 of file EvolDF1nlep.h.

◆ K11singV

gslpp::matrix<gslpp::complex> EvolDF1nlep::K11singV

private

Definition at line 125 of file EvolDF1nlep.h.

◆ K11V

gslpp::matrix<gslpp::complex> EvolDF1nlep::K11V

private

Definition at line 124 of file EvolDF1nlep.h.

◆ m

double EvolDF1nlep::m[4][10][10][10]

private

Definition at line 104 of file EvolDF1nlep.h.

◆ mn

double EvolDF1nlep::mn[4][10][10][10]

private

Definition at line 104 of file EvolDF1nlep.h.

◆ model

const StandardModel& EvolDF1nlep::model

private

Definition at line 107 of file EvolDF1nlep.h.

◆ Mz_cache

double EvolDF1nlep::Mz_cache

private

Definition at line 129 of file EvolDF1nlep.h.

◆ n

double EvolDF1nlep::n[4][10][10][10]

private

Definition at line 104 of file EvolDF1nlep.h.

◆ o

double EvolDF1nlep::o[4][10][10][10]

private

Definition at line 104 of file EvolDF1nlep.h.

◆ op

double EvolDF1nlep::op[4][10][10][10]

private

Definition at line 105 of file EvolDF1nlep.h.

◆ p

double EvolDF1nlep::p[4][10][10][10]

private

Definition at line 105 of file EvolDF1nlep.h.

◆ q

double EvolDF1nlep::q[4][10][10][10]

private

Definition at line 105 of file EvolDF1nlep.h.

◆ qq

double EvolDF1nlep::qq[4][10][10][10]

private

Definition at line 105 of file EvolDF1nlep.h.

◆ r

double EvolDF1nlep::r[4][10][10][10]

private

Definition at line 106 of file EvolDF1nlep.h.

◆ rr

double EvolDF1nlep::rr[4][10][10][10]

private

Definition at line 106 of file EvolDF1nlep.h.

◆ s

double EvolDF1nlep::s[4][10][10][10]

private

Definition at line 106 of file EvolDF1nlep.h.

◆ t

double EvolDF1nlep::t[4][10][10][10]

private

Definition at line 106 of file EvolDF1nlep.h.

◆ V

gslpp::matrix<gslpp::complex> EvolDF1nlep::V

private

Definition at line 122 of file EvolDF1nlep.h.

◆ Vi

gslpp::matrix<gslpp::complex> EvolDF1nlep::Vi

private

Definition at line 122 of file EvolDF1nlep.h.

◆ ViJs

gslpp::matrix<gslpp::complex> EvolDF1nlep::ViJs

private

Definition at line 123 of file EvolDF1nlep.h.

◆ ViK0

gslpp::matrix<gslpp::complex> EvolDF1nlep::ViK0

private

Definition at line 124 of file EvolDF1nlep.h.

◆ ViK0Js

gslpp::matrix<gslpp::complex> EvolDF1nlep::ViK0Js

private

Definition at line 122 of file EvolDF1nlep.h.

◆ ViK11

gslpp::matrix<gslpp::complex> EvolDF1nlep::ViK11

private

Definition at line 124 of file EvolDF1nlep.h.

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

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ EvolDF1nlep()

◆ ~EvolDF1nlep()

Member Function Documentation

◆ AnomalousDimension_nlep_EM()

◆ AnomalousDimension_nlep_S()

◆ Df1Evolnlep() [1/2]

◆ Df1Evolnlep() [2/2]

◆ Df1Evolnlep3flav()

◆ Df1threshold_deltareT()

◆ Df1threshold_deltarsT()

◆ Df1threshold_nlep()

Member Data Documentation

◆ a

◆ Ale_cache

◆ alsMZ_cache

◆ b

◆ c

◆ d

◆ dim

◆ e

◆ Gamma_eT

◆ Gamma_s0T

◆ Gamma_s1T

◆ Gamma_seT

◆ ge0

◆ ge0sing

◆ ge11

◆ ge11sing

◆ gs

◆ Js

◆ JsK0singV

◆ JsK0V

◆ JsV

◆ K0

◆ K0sing

◆ K0singV

◆ K0V

◆ K11

◆ K11sing

◆ K11singV

◆ K11V

◆ m

◆ mn

◆ model

◆ Mz_cache

◆ n

◆ o

◆ op

◆ p

◆ q

◆ qq

◆ r

◆ rr

◆ s

◆ t

◆ V

◆ Vi

◆ ViJs

◆ ViK0

◆ ViK0Js

◆ ViK11