HeffDB1 Class Reference

#include <HeffDB1.h>

Collaboration diagram for HeffDB1:

Detailed Description

Definition at line 18 of file HeffDB1.h.

Public Member Functions
gslpp::vector< gslpp::complex > **	ComputeCoeffBMll (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffBnlep00 (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffBnlep01 (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffBnlep10 (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffBnlep11 (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffbtaunu ()
gslpp::vector< gslpp::complex > **	ComputeCoeffdmumu (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffdnunu ()
gslpp::vector< gslpp::complex > **	ComputeCoeffprimeBMll (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffprimesgamma (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffsgamma (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffsmumu (double mu, schemes scheme=NDR)
gslpp::vector< gslpp::complex > **	ComputeCoeffsnunu ()
WilsonCoefficient	getCoeffbtaunu () const
WilsonCoefficient	getCoeffdmumu () const
WilsonCoefficient	getCoeffdnunu () const
WilsonCoefficient	getCoeffnlep00 () const
WilsonCoefficient	getCoeffnlep01 () const
WilsonCoefficient	getCoeffnlep10 () const
WilsonCoefficient	getCoeffnlep11 () const
WilsonCoefficient	getCoeffprimesgamma () const
WilsonCoefficient	getCoeffsgamma () const
WilsonCoefficient	getCoeffsmumu () const
WilsonCoefficient	getCoeffsnunu () const
const StandardModel &	GetModel () const
EvolBsmm	getUBdmm () const
EvolBsmm	getUBsmm () const
EvolDB1bsg	getUDB1bsg () const
EvolDB1Mll	getUDF1BMll () const
	HeffDB1 (const StandardModel &SM)
	constructor More...
virtual	~HeffDB1 ()
	destructor More...

Private Attributes
double	Bdmumu_mu_cache
std::vector< double >	Bdmumu_Mu_cache
schemes	Bdmumu_scheme_cache
std::vector< WilsonCoefficient >	Bdmumu_WC_cache
double	BMll_mu_cache
std::vector< double >	BMll_Mu_cache
schemes	BMll_scheme_cache
std::vector< WilsonCoefficient >	BMll_WC_cache
double	BMllprime_mu_cache
std::vector< double >	BMllprime_Mu_cache
schemes	BMllprime_scheme_cache
std::vector< WilsonCoefficient >	BMllprime_WC_cache
std::vector< double >	Bpsgamma_Mu_cache
std::vector< WilsonCoefficient >	Bpsgamma_WC_cache
double	Bsgamma_mu_cache
std::vector< double >	Bsgamma_Mu_cache
schemes	Bsgamma_scheme_cache
std::vector< WilsonCoefficient >	Bsgamma_WC_cache
double	Bsmumu_mu_cache
std::vector< double >	Bsmumu_Mu_cache
schemes	Bsmumu_scheme_cache
std::vector< WilsonCoefficient >	Bsmumu_WC_cache
WilsonCoefficient	coeffBMll
WilsonCoefficient	coeffbtaunu
WilsonCoefficient	coeffdmumu
WilsonCoefficient	coeffdnunu
WilsonCoefficient	coeffnlep00
WilsonCoefficient	coeffnlep00CC
WilsonCoefficient	coeffnlep00qcd
WilsonCoefficient	coeffnlep01
WilsonCoefficient	coeffnlep01A
WilsonCoefficient	coeffnlep01B
WilsonCoefficient	coeffnlep10
WilsonCoefficient	coeffnlep10CC
WilsonCoefficient	coeffnlep10qcd
WilsonCoefficient	coeffnlep11
WilsonCoefficient	coeffnlep11A
WilsonCoefficient	coeffnlep11B
WilsonCoefficient	coeffprimeBMll
WilsonCoefficient	coeffprimesgamma
WilsonCoefficient	coeffsgamma
WilsonCoefficient	coeffsmumu
WilsonCoefficient	coeffsnunu
EvolBsmm	evolbd
EvolBsmm	evolbs
EvolDB1bsg	evolDB1bsg
EvolDB1Mll	evolDF1BMll
const StandardModel &	model
gslpp::vector< gslpp::complex >	nlep
gslpp::vector< gslpp::complex >	nlep2
gslpp::vector< gslpp::complex >	nlepCC

Constructor & Destructor Documentation

HeffDB1::HeffDB1

(

const StandardModel &

SM

)

constructor

Parameters

SM
modelmatching

Definition at line 11 of file HeffDB1.cpp.

:       model(SM), 
        coeffnlep00qcd (10, NDR, NLO, NLO_ew), coeffnlep00 (12, NDR, NLO, NLO_ew),
        coeffnlep10qcd (10, NDR, NLO, NLO_ew), coeffnlep10 (12, NDR, NLO, NLO_ew),
        coeffnlep01 (10, NDR, NLO), coeffnlep01A(10, NDR, NLO), coeffnlep01B(4, NDR, NLO), coeffnlep00CC(10, NDR, NLO),
        coeffnlep11 (10, NDR, NLO), coeffnlep11A(10, NDR, NLO), coeffnlep11B(4, NDR, NLO), coeffnlep10CC(10, NDR, NLO),
        coeffsmumu (8, NDR, NNLO, NLO_ewt4), coeffdmumu (8, NDR, NNLO, NLO_ewt4),
        coeffbtaunu (3, NDR, LO),
        coeffsnunu (1, NDR, NLO), coeffdnunu (1, NDR, NLO),
        coeffsgamma(8,NDR, NLO),
        coeffprimesgamma(8,NDR, NLO),
        coeffBMll (13,NDR, NLO),
        coeffprimeBMll (13, NDR, NLO),
        evolDF1BMll(13, NDR, NLO, SM),
        evolDB1bsg(8, NDR, NLO, SM),
        evolbs(8, NDR, NNLO, NLO_ewt4, SM), evolbd(8, NDR, NNLO, NLO_ewt4, SM),
        nlep (12, 0.), nlep2(10, 0.),        
        nlepCC(4, 0.)
{
    
    for (unsigned int i = 0; i < 6; i++) {
        BMll_WC_cache.push_back(coeffBMll);
        BMll_Mu_cache.push_back(0.);
    }
    BMll_mu_cache = 0.;
    
    for (unsigned int i = 0; i < 6; i++) {
        BMllprime_WC_cache.push_back(coeffprimeBMll);
        BMllprime_Mu_cache.push_back(0.);
    }
    BMllprime_mu_cache = 0.;
    
    for (unsigned int i = 0; i < 6; i++) {
        Bsgamma_WC_cache.push_back(coeffsgamma);
        Bsgamma_Mu_cache.push_back(0.);
    }
    Bsgamma_mu_cache = 0.;
    
    for (unsigned int i = 0; i < 6; i++) {
        Bpsgamma_WC_cache.push_back(coeffsgamma);
        Bpsgamma_Mu_cache.push_back(0.);
    }
    
    for (unsigned int i = 0; i < 6; i++) {
        Bsmumu_WC_cache.push_back(coeffsmumu);
        Bsmumu_Mu_cache.push_back(0.);
    }
    Bsmumu_mu_cache = 0.;
    
    for (unsigned int i = 0; i < 6; i++) {
        Bdmumu_WC_cache.push_back(coeffdmumu);
        Bdmumu_Mu_cache.push_back(0.);
    }
    Bdmumu_mu_cache = 0.;
}

HeffDB1::~HeffDB1 ( )

virtual

destructor

Definition at line 67 of file HeffDB1.cpp.

{}

Member Function Documentation

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffBMll	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

the effective hamiltonian at the scale mu B -> K^*ll decay, Misiak basis, Chetyrkin et al hep-ph/9612313

Definition at line 589 of file HeffDB1.cpp.

{
    
    coeffBMll.setScheme(scheme);
    orders ordDF1 = coeffBMll.getOrder();   
    
    const std::vector<WilsonCoefficient>& mc = model.getMyMatching() -> CMBMll();

    if (mu == BMll_mu_cache && scheme == BMll_scheme_cache) {
        int check = 1;
        for (unsigned int i = 0; i < mc.size(); i++) {
            if (mc[i].getMu() == BMll_Mu_cache[i]){
                for (int j = LO; j <= ordDF1; j++) {
                    for (int k = LO; k <= j; k++) {
                        for (int l = 0; l < 13; l++) {
                            check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMll_WC_cache[i].getCoeff(orders(j - k))))(l));
                        }
                    }
                }
            } else check = 0;
        }
        if (check == 1) return coeffBMll.getCoeff();
    } 
    
    BMll_mu_cache = mu;
    BMll_scheme_cache = scheme;
    BMll_WC_cache.clear();
    BMll_WC_cache = mc;
    
    coeffBMll.setMu(mu); 
    
    for (unsigned int i = 0; i < mc.size(); i++){
        BMll_Mu_cache[i] = mc[i].getMu();
        for (int j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++){
                coeffBMll.setCoeff(*coeffBMll.getCoeff(orders(j)) +
                    evolDF1BMll.Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
                    (*(mc[i].getCoeff(orders(j - k)))), orders(j));
            }
        }
    }
    
    return coeffBMll.getCoeff();
}

gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep00	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the reonrmalization scheme

Returns

the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 0 | \), \( |\Delta S = 0 | \)

gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep01	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 0 | \), \( |\Delta S = 1 | \)

gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep10	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 1 | \), \( |\Delta S = 0 | \)

gslpp::vector<gslpp::complex>** HeffDB1::ComputeCoeffBnlep11	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

the effective hamiltonian at the scale mu for B decays, \( |\Delta C = 1 | \), \( |\Delta S = 1 | \)

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffbtaunu

(

)

Parameters

scheme

Returns

short distance contribution to the rare decay \( B \rightarrow \tau \nu \)

Definition at line 451 of file HeffDB1.cpp.

{
    std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMbtaunu();
    coeffbtaunu.resetCoefficient();
    orders ordDF1 = coeffbtaunu.getOrder();
    for (unsigned int i = 0; i < mcb.size(); i++){
        for (int j = LO; j <= ordDF1; j++){
            coeffbtaunu.setCoeff(*coeffbtaunu.getCoeff(orders(j))
                                     + *mcb[i].getCoeff(orders(j)), orders(j));
        }
    }
     return coeffbtaunu.getCoeff(); 
}

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffdmumu	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

scheme

Returns

short distance contribution to the rare decay \( B_{d} \rightarrow \mu \bar{\mu} \)

Definition at line 262 of file HeffDB1.cpp.

{   
    
    coeffdmumu.setScheme(scheme);
    orders ordDF1 = coeffdmumu.getOrder(); 
    orders_ew ordDF1ew = coeffdmumu.getOrder_ew();
    
    const std::vector<WilsonCoefficient>& mcbdm = model.getMyMatching() -> CMbdmm();

    if (mu == Bdmumu_mu_cache && scheme == Bdmumu_scheme_cache) {
        int check = 1;
        for (unsigned int i = 0; i < mcbdm.size(); i++) {
            if (mcbdm[i].getMu() == Bdmumu_Mu_cache[i]) {
                for (int j = LO; j <= ordDF1; j++) {
                    for (int k = LO; k <= j; k++) {
                        for (int l = 0; l < 8; l++) {
                            check *= ((*(mcbdm[i].getCoeff(orders(j - k))))(l) == (*(Bdmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
                        }
                    }
                }
            } else check = 0;
        }
        if (check == 1) return coeffdmumu.getCoeff();
    } 
       
    double nf = 5; //al the process has nf = 5, also the evolutor
    
    //int L = 6 - (int) nf;
    int j = 0;
    double alsM = evolbd.alphatilde_s(mcbdm[0].getMu());
    double alsmu = evolbd.alphatilde_s(mu);
    double eta = alsM / alsmu;
      
    double B00S = model.Beta0(nf), B10S = model.Beta1(nf); 

    double B00E = 80./9., B01E = 176./9.; 
    
    double logeta = log(eta);
    double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
    double app = B00E * (1. - eta)/ B00S;
    
    Bdmumu_mu_cache = mu;
    Bdmumu_scheme_cache = scheme;
    Bdmumu_WC_cache.clear();
    Bdmumu_WC_cache = mcbdm;
   
    coeffdmumu.setMu(mu); 
           
    for (unsigned int i = 0; i < mcbdm.size(); i++){
        Bdmumu_Mu_cache[i] = mcbdm[i].getMu();
        for (j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++){
                if ((k <= NNLO) && (j <= NNLO)){                        
               coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders(j)) + pow(eta,j) *
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(k), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(j - k)))), orders(j));
                }     
            }    
        }       
            
            for (j = LO_ew; j <= ordDF1ew; j++){
                
            switch(j) {   
            
            case(NLO_ewt4):
                
               coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) +
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(NLO_ewt4)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(NLO_ew)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(NLO_ewt2)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NNLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ewt3), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NNLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) )+ logeta * fatt 
                    *  app * 
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
                             
               break; 
            
            case(NLO_ewt3):
                
               coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + (1./ eta) *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(NLO_ew)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO))))) +  ((logeta/eta) * fatt) 
                    * app *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO))))) +  ( app * app/( eta) ) *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NLO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
               
               break;
               
            case(NLO_ewt2):
                
               coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + eta *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(j)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(NLO_ew)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NNLO)))))-
                    eta * logeta * fatt * 
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))))
                    - eta *  app *
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NNLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NNLO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) +
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) ), orders_ew(j));
               
               break;
            
            case(NLO_ewt1):
                
               coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,2)) *
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) +  ( app 
                    * app/(eta * eta ) ) * 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))), orders_ew(j));  
               
               break;
            
            case(NLO_ew):
                
               coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders_ew(j)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(LO_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) - logeta * fatt * 
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(LO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO))))) -  app * 
                    (evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(NLO)))) + 
                    evolbd.Df1Evol(mu, mcbdm[i].getMu(), orders(NLO), NULL_ew, mcbdm[i].getScheme()) *
                    (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
             
               
               break;
               
            case(LO_ew):
             
                coeffdmumu.setCoeff(*coeffdmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,1)) *
                evolbd.Df1Evol(mu, mcbdm[i].getMu(), NNLO, orders_ew(j), mcbdm[i].getScheme()) *
                (*(mcbdm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
                ( evolbd.Df1Evol(mu, mcbdm[i].getMu(), LO, orders_ew(NULL_ew), mcbdm[i].getScheme()) *
                (*(mcbdm[i].getCoeff(orders(LO))))), orders_ew(j));
                
                
                
                break;
            }                        
        }
    }   
    return coeffdmumu.getCoeff();
}

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffdnunu

(

)

Parameters

scheme

Returns

short distance contribution to the rare decay \( B_{d} \rightarrow \nu \bar{\nu} \)

Definition at line 482 of file HeffDB1.cpp.

{
    
     std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMBXdnn();
    
    orders ordDF1 = coeffdnunu.getOrder();
    
    for (unsigned int i = 0; i < mcb.size(); i++){
        for (int j = LO; j <= ordDF1; j++){
            coeffdnunu.setCoeff(*coeffdnunu.getCoeff(orders(j))
                                    + *mcb[i].getCoeff(orders(j)), orders(j));
        }
    }
    
    return coeffdnunu.getCoeff(); 
} 

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffprimeBMll	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

the effective hamiltonian at the scale mu B -> K^*ll decay, Misiak basis, Chetyrkin et al hep-ph/9612313

Definition at line 635 of file HeffDB1.cpp.

{
    
    coeffprimeBMll.setScheme(scheme);
    orders ordDF1 = coeffprimeBMll.getOrder();  
    
    const std::vector<WilsonCoefficient>& mc = model.getMyMatching() -> CMprimeBMll();

    if (mu == BMllprime_mu_cache && scheme == BMllprime_scheme_cache) {
        int check = 1;
        for (unsigned int i = 0; i < mc.size(); i++) {
            if (mc[i].getMu() == BMllprime_Mu_cache[i]) {
                for (int j = LO; j <= ordDF1; j++) {
                    for (int k = LO; k <= j; k++) {
                        for (int l = 0; l < 13; l++) {
                            check *= ((*(mc[i].getCoeff(orders(j - k))))(l) == (*(BMllprime_WC_cache[i].getCoeff(orders(j - k))))(l));
                        }
                    }
                }
            } else check = 0;
        }
        if (check == 1) return coeffprimeBMll.getCoeff();
    }
    
    BMllprime_mu_cache = mu;
    BMllprime_scheme_cache = scheme;
    BMllprime_WC_cache.clear();
    BMllprime_WC_cache = mc;
    
    coeffprimeBMll.setMu(mu); 
    
    for (unsigned int i = 0; i < mc.size(); i++){
        BMllprime_Mu_cache[i] = mc[i].getMu();
        for (int j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++){
                coeffprimeBMll.setCoeff(*coeffprimeBMll.getCoeff(orders(j)) +
                    evolDF1BMll.Df1EvolMll(mu, mc[i].getMu(), orders(k), mc[i].getScheme()) *
                    (*(mc[i].getCoeff(orders(j - k)))), orders(j));
            }
        }
    }
    
   
    return coeffprimeBMll.getCoeff();
}

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffprimesgamma	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

short distance contribution to the rare decay \( b \rightarrow s \gamma \)

Definition at line 544 of file HeffDB1.cpp.

{
    
    coeffprimesgamma.setScheme(scheme);
    orders ordDF1 = coeffprimesgamma.getOrder();   
    
    const std::vector<WilsonCoefficient>& mcbsgp = model.getMyMatching() -> CMprimebsg();

    if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
        int check = 1;
        for (unsigned int i = 0; i < mcbsgp.size(); i++) {
            if (mcbsgp[i].getMu() == Bpsgamma_Mu_cache[i]) {
                for (int j = LO; j <= ordDF1; j++) {
                    for (int k = LO; k <= j; k++) {
                        for (int l = 0; l < 8; l++) {
                            check *= ((*(mcbsgp[i].getCoeff(orders(j - k))))(l) == (*(Bpsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
                        }
                    }
                }
            } else check = 0;
        }
        if (check == 1) return coeffprimesgamma.getCoeff();
    } 
    
    Bsgamma_mu_cache = mu;
    Bsgamma_scheme_cache = scheme;
    Bpsgamma_WC_cache.clear();
    Bpsgamma_WC_cache = mcbsgp;
    
    coeffprimesgamma.setMu(mu); 
    
    for (unsigned int i = 0; i < mcbsgp.size(); i++){
        Bpsgamma_Mu_cache[i] = mcbsgp[i].getMu();
        for (int j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++){
                coeffprimesgamma.setCoeff(*coeffprimesgamma.getCoeff(orders(j)) +
                    evolDB1bsg.Df1Evolbsg(mu, mcbsgp[i].getMu(), orders(k), mcbsgp[i].getScheme()) *
                    (*(mcbsgp[i].getCoeff(orders(j - k)))), orders(j));
            }
        }
    }
    
    return coeffprimesgamma.getCoeff(); 
}

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsgamma	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

mu	is the low energy scale
scheme	indicates the renormalization scheme

Returns

short distance contribution to the rare decay \( b \rightarrow s \gamma \)

Definition at line 499 of file HeffDB1.cpp.

{
    
    coeffsgamma.setScheme(scheme);
    orders ordDF1 = coeffsgamma.getOrder();   
    
    const std::vector<WilsonCoefficient>& mcbsg = model.getMyMatching() -> CMbsg();

    if (mu == Bsgamma_mu_cache && scheme == Bsgamma_scheme_cache) {
        int check = 1;
        for (unsigned int i = 0; i < mcbsg.size(); i++) {
            if (mcbsg[i].getMu() == Bsgamma_Mu_cache[i]) {
                for (int j = LO; j <= ordDF1; j++) {
                    for (int k = LO; k <= j; k++) {
                        for (int l = 0; l < 8; l++) {
                            check *= ((*(mcbsg[i].getCoeff(orders(j - k))))(l) == (*(Bsgamma_WC_cache[i].getCoeff(orders(j - k))))(l));
                        }
                    }
                }
            } else check = 0;
        }
        if (check == 1) return coeffsgamma.getCoeff();
    } 
    
    Bsgamma_mu_cache = mu;
    Bsgamma_scheme_cache = scheme;
    Bsgamma_WC_cache.clear();
    Bsgamma_WC_cache = mcbsg;
    
    coeffsgamma.setMu(mu); 
    
    for (unsigned int i = 0; i < mcbsg.size(); i++){
        Bsgamma_Mu_cache[i] = mcbsg[i].getMu();
        for (int j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++){
                coeffsgamma.setCoeff(*coeffsgamma.getCoeff(orders(j)) +
                    evolDB1bsg.Df1Evolbsg(mu, mcbsg[i].getMu(), orders(k), mcbsg[i].getScheme()) *
                    (*(mcbsg[i].getCoeff(orders(j - k)))), orders(j));
            }
        }
    }
    
    return coeffsgamma.getCoeff(); 
}

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsmumu	(	double	mu,
		schemes	scheme = NDR
	)

Parameters

scheme

Returns

short distance contribution to the rare decay \( B_{s} \rightarrow \mu \bar{\mu} \)

Definition at line 71 of file HeffDB1.cpp.

{   
    
    
    coeffsmumu.setScheme(scheme);
    orders ordDF1 = coeffsmumu.getOrder(); 
    orders_ew ordDF1ew = coeffsmumu.getOrder_ew();
    
    const std::vector<WilsonCoefficient>& mcbsm = model.getMyMatching() -> CMbsmm();

    if (mu == Bsmumu_mu_cache && scheme == Bsmumu_scheme_cache) {
        int check = 1;
        for (unsigned int i = 0; i < mcbsm.size(); i++) {
            if (mcbsm[i].getMu() == Bsmumu_Mu_cache[i]) {
                for (int j = LO; j <= ordDF1; j++) {
                    for (int k = LO; k <= j; k++) {
                        for (int l = 0; l < 8; l++) {
                            check *= ((*(mcbsm[i].getCoeff(orders(j - k))))(l) == (*(Bsmumu_WC_cache[i].getCoeff(orders(j - k))))(l));
                        }
                    }
                }
            } else check = 0;
        } 
        if (check == 1) return coeffsmumu.getCoeff();
    } 
       
    double nf = 5; //al the process has nf = 5, also the evolutor
    
    //int L = 6 - (int) nf;
    int j = 0;
    double alsM = evolbs.alphatilde_s(mcbsm[0].getMu());
    double alsmu = evolbs.alphatilde_s(mu);
    double eta = alsM / alsmu;
      
    double B00S = model.Beta0(nf), B10S = model.Beta1(nf); 

    double B00E = 80./9., B01E = 176./9.; 
    
    double logeta = log(eta);
    double fatt = (B00E * B10S /B00S /B00S - B01E /B00S);
    double app = B00E * (1. - eta)/ B00S;
    
    Bsmumu_mu_cache = mu;
    Bsmumu_scheme_cache = scheme;
    Bsmumu_WC_cache.clear();
    Bsmumu_WC_cache = mcbsm;
   
    coeffsmumu.setMu(mu); 
           
    for (unsigned int i = 0; i < mcbsm.size(); i++){
        Bsmumu_Mu_cache[i] = mcbsm[i].getMu();
        for (j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++){  
                if ((k <= NNLO) && (j <= NNLO)){
               coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders(j)) + pow(eta,j) *
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(k), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(j - k)))), orders(j));
                }     
            }    
        }       
            
            for (j = LO_ew; j <= ordDF1ew; j++){
                
            switch(j) {   
            
            case(NLO_ewt4):
                
               coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) +
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(NLO_ewt4)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(NLO_ew)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(NLO_ewt2)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NNLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ewt3), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO))))) + pow((logeta) * fatt,2) *
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) ) + pow( app, 2 ) *
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NNLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) )+ logeta * fatt 
                    * app * 
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
                             
               break; 
            
            case(NLO_ewt3):
                
               coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + (1./ eta) *
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(NLO_ew)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ewt1), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO))))) +  ((logeta/eta) * fatt) 
                    * app * 
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO))))) +  ( app * app/( eta) ) *
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NLO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
               
               break;
               
            case(NLO_ewt2):
                
               coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + eta *
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(j)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(NLO_ew)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(NLO_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NNLO)))))-
                    eta * logeta * fatt * 
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))))
                    - eta *  app *
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NNLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NNLO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) +
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) ), orders_ew(j));
               
               break;
            
            case(NLO_ewt1):
                
               coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,2)) *
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) +  ( app 
                    * app/( eta * eta ) ) * 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))), orders_ew(j));  
               
               break;
            
            case(NLO_ew):
                
               coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders_ew(j)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(LO_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) - logeta * fatt * 
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(LO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO))))) - app * 
                    (evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(NLO)))) + 
                    evolbs.Df1Evol(mu, mcbsm[i].getMu(), orders(NLO), NULL_ew, mcbsm[i].getScheme()) *
                    (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
             
               
               break;
               
            case(LO_ew):
             
                coeffsmumu.setCoeff(*coeffsmumu.getCoeff(orders_ew(j)) + (1./ pow(eta,1)) *
                evolbs.Df1Evol(mu, mcbsm[i].getMu(), NNLO, orders_ew(j), mcbsm[i].getScheme()) *
                (*(mcbsm[i].getCoeff(orders(LO)))) - ( app /( eta ) ) *
                ( evolbs.Df1Evol(mu, mcbsm[i].getMu(), LO, orders_ew(NULL_ew), mcbsm[i].getScheme()) *
                (*(mcbsm[i].getCoeff(orders(LO))))), orders_ew(j));
                
                
                
                break;
            }                
        }
    }
    return coeffsmumu.getCoeff();
}

gslpp::vector< gslpp::complex > ** HeffDB1::ComputeCoeffsnunu

(

)

Parameters

scheme

Returns

short distance contribution to the rare decay \( B_{s} \rightarrow \nu \bar{\nu} \)

Definition at line 465 of file HeffDB1.cpp.

{
    
     std::vector<WilsonCoefficient>& mcb = model.getMyMatching() -> CMBXsnn();
    
    orders ordDF1 = coeffsnunu.getOrder();
    
    for (unsigned int i = 0; i < mcb.size(); i++){
        for (int j = LO; j <= ordDF1; j++){
            coeffsnunu.setCoeff(*coeffsnunu.getCoeff(orders(j))
                                    + *mcb[i].getCoeff(orders(j)), orders(j));
        }
    }
     
    return coeffsnunu.getCoeff(); 
} 

WilsonCoefficient HeffDB1::getCoeffbtaunu ( ) const

inline

Definition at line 156 of file HeffDB1.h.

                                             {
        return coeffbtaunu;
    }

WilsonCoefficient HeffDB1::getCoeffdmumu ( ) const

inline

Definition at line 152 of file HeffDB1.h.

                                            {
        return coeffdmumu;
    }

WilsonCoefficient HeffDB1::getCoeffdnunu ( ) const

inline

Definition at line 164 of file HeffDB1.h.

                                            {
        return coeffdnunu;
    }

WilsonCoefficient HeffDB1::getCoeffnlep00 ( ) const

inline

Definition at line 132 of file HeffDB1.h.

                                             {
        return coeffnlep00;
    }

WilsonCoefficient HeffDB1::getCoeffnlep01 ( ) const

inline

Definition at line 140 of file HeffDB1.h.

                                             {
        return coeffnlep10;
    }

WilsonCoefficient HeffDB1::getCoeffnlep10 ( ) const

inline

Definition at line 136 of file HeffDB1.h.

                                             {
        return coeffnlep01;
    }

WilsonCoefficient HeffDB1::getCoeffnlep11 ( ) const

inline

Definition at line 144 of file HeffDB1.h.

                                             {
        return coeffnlep11;
    }

WilsonCoefficient HeffDB1::getCoeffprimesgamma ( ) const

inline

Definition at line 172 of file HeffDB1.h.

                                                  {
        return coeffprimesgamma;
    }

WilsonCoefficient HeffDB1::getCoeffsgamma ( ) const

inline

Definition at line 168 of file HeffDB1.h.

                                             {
        return coeffsgamma;
    }

WilsonCoefficient HeffDB1::getCoeffsmumu ( ) const

inline

Definition at line 148 of file HeffDB1.h.

                                            {
        return coeffsmumu;
    }

WilsonCoefficient HeffDB1::getCoeffsnunu ( ) const

inline

Definition at line 160 of file HeffDB1.h.

                                            {
        return coeffsnunu;
    }

const StandardModel& HeffDB1::GetModel ( ) const

inline

Definition at line 193 of file HeffDB1.h.

                                          {
        return model;
    }

EvolBsmm HeffDB1::getUBdmm ( ) const

inline

Definition at line 180 of file HeffDB1.h.

                              {
        return evolbd;
    }

EvolBsmm HeffDB1::getUBsmm ( ) const

inline

Definition at line 176 of file HeffDB1.h.

                              {
        return evolbs;
    }

EvolDB1bsg HeffDB1::getUDB1bsg ( ) const

inline

Definition at line 189 of file HeffDB1.h.

                                  {
        return evolDB1bsg;
    }

EvolDB1Mll HeffDB1::getUDF1BMll ( ) const

inline

Definition at line 185 of file HeffDB1.h.

                                   {
        return evolDF1BMll;
    }

Member Data Documentation

double HeffDB1::Bdmumu_mu_cache

private

Definition at line 237 of file HeffDB1.h.

std::vector<double> HeffDB1::Bdmumu_Mu_cache

private

Definition at line 239 of file HeffDB1.h.

schemes HeffDB1::Bdmumu_scheme_cache

private

Definition at line 238 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bdmumu_WC_cache

private

Definition at line 240 of file HeffDB1.h.

double HeffDB1::BMll_mu_cache

private

Definition at line 222 of file HeffDB1.h.

std::vector<double> HeffDB1::BMll_Mu_cache

private

Definition at line 224 of file HeffDB1.h.

schemes HeffDB1::BMll_scheme_cache

private

Definition at line 223 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::BMll_WC_cache

private

Definition at line 225 of file HeffDB1.h.

double HeffDB1::BMllprime_mu_cache

private

Definition at line 227 of file HeffDB1.h.

std::vector<double> HeffDB1::BMllprime_Mu_cache

private

Definition at line 229 of file HeffDB1.h.

schemes HeffDB1::BMllprime_scheme_cache

private

Definition at line 228 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::BMllprime_WC_cache

private

Definition at line 230 of file HeffDB1.h.

std::vector<double> HeffDB1::Bpsgamma_Mu_cache

private

Definition at line 218 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bpsgamma_WC_cache

private

Definition at line 220 of file HeffDB1.h.

double HeffDB1::Bsgamma_mu_cache

private

Definition at line 215 of file HeffDB1.h.

std::vector<double> HeffDB1::Bsgamma_Mu_cache

private

Definition at line 217 of file HeffDB1.h.

schemes HeffDB1::Bsgamma_scheme_cache

private

Definition at line 216 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bsgamma_WC_cache

private

Definition at line 219 of file HeffDB1.h.

double HeffDB1::Bsmumu_mu_cache

private

Definition at line 232 of file HeffDB1.h.

std::vector<double> HeffDB1::Bsmumu_Mu_cache

private

Definition at line 234 of file HeffDB1.h.

schemes HeffDB1::Bsmumu_scheme_cache

private

Definition at line 233 of file HeffDB1.h.

std::vector<WilsonCoefficient> HeffDB1::Bsmumu_WC_cache

private

Definition at line 235 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffBMll

private

Definition at line 208 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffbtaunu

private

Definition at line 205 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffdmumu

private

Definition at line 204 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffdnunu

private

Definition at line 206 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep00

private

Definition at line 200 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep00CC

private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep00qcd

private

Definition at line 200 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep01

private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep01A

private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep01B

private

Definition at line 202 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep10

private

Definition at line 201 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep10CC

private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep10qcd

private

Definition at line 201 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep11

private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep11A

private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffnlep11B

private

Definition at line 203 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffprimeBMll

private

Definition at line 208 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffprimesgamma

private

Definition at line 207 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffsgamma

private

Definition at line 207 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffsmumu

private

Definition at line 204 of file HeffDB1.h.

WilsonCoefficient HeffDB1::coeffsnunu

private

Definition at line 206 of file HeffDB1.h.

EvolBsmm HeffDB1::evolbd

private

Definition at line 211 of file HeffDB1.h.

EvolBsmm HeffDB1::evolbs

private

Definition at line 211 of file HeffDB1.h.

EvolDB1bsg HeffDB1::evolDB1bsg

private

Definition at line 210 of file HeffDB1.h.

EvolDB1Mll HeffDB1::evolDF1BMll

private

Definition at line 209 of file HeffDB1.h.

const StandardModel& HeffDB1::model

private

Definition at line 198 of file HeffDB1.h.

gslpp::vector<gslpp::complex> HeffDB1::nlep

private

Definition at line 242 of file HeffDB1.h.

gslpp::vector<gslpp::complex> HeffDB1::nlep2

private

Definition at line 242 of file HeffDB1.h.

gslpp::vector<gslpp::complex> HeffDB1::nlepCC

private

Definition at line 242 of file HeffDB1.h.

---

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

• HeffDB1.h
• HeffDB1.cpp