#include <HeffDF1bnlep.h>

Detailed Description

Definition at line 17 of file HeffDF1bnlep.h.

Public Member Functions
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)

WilsonCoefficient	getCoeffbnlep00 () const

WilsonCoefficient	getCoeffbnlep01 () const

WilsonCoefficient	getCoeffbnlep10 () const

WilsonCoefficient	getCoeffbnlep11 () const

const StandardModel &	GetModel () const

EvolDF1nlep &	getUDF1 () const

	HeffDF1bnlep (const StandardModel &SM)
	constructor More...

virtual	~HeffDF1bnlep ()
	destructor More...

Private Attributes
gslpp::vector< gslpp::complex >	bnlep

gslpp::vector< gslpp::complex >	bnlep2

gslpp::vector< gslpp::complex >	bnlepCC

WilsonCoefficient	coeffbnlep00

WilsonCoefficient	coeffbnlep00CC

WilsonCoefficient	coeffbnlep00qcd

WilsonCoefficient	coeffbnlep01

WilsonCoefficient	coeffbnlep01A

WilsonCoefficient	coeffbnlep01B

WilsonCoefficient	coeffbnlep10

WilsonCoefficient	coeffbnlep10CC

WilsonCoefficient	coeffbnlep10qcd

WilsonCoefficient	coeffbnlep11

WilsonCoefficient	coeffbnlep11A

WilsonCoefficient	coeffbnlep11B

const StandardModel &	model

std::unique_ptr< EvolDF1nlep >	u

Constructor & Destructor Documentation

◆ HeffDF1bnlep()

HeffDF1bnlep::HeffDF1bnlep ( const StandardModel & SM )

constructor

Parameters

SM
modelmatching

Definition at line 13 of file HeffDF1bnlep.cpp.

:       model(SM), 
        coeffbnlep00qcd (10, NDR, NLO, NLO_QED11), coeffbnlep00 (12, NDR, NLO, NLO_QED11),
        coeffbnlep10qcd (10, NDR, NLO, NLO_QED11), coeffbnlep10 (12, NDR, NLO, NLO_QED11),
        coeffbnlep01 (10, NDR, NLO), coeffbnlep01A(10, NDR, NLO), coeffbnlep01B(4, NDR, NLO), coeffbnlep00CC(10, NDR, NLO),
        coeffbnlep11 (10, NDR, NLO), coeffbnlep11A(10, NDR, NLO), coeffbnlep11B(4, NDR, NLO), coeffbnlep10CC(10, NDR, NLO),
        u(new EvolDF1nlep(10, NDR, NLO, NLO_QED11, SM)), 
        bnlep (12, 0.), bnlep2(10, 0.), bnlepCC(4, 0.)
{}

◆ ~HeffDF1bnlep()

HeffDF1bnlep::~HeffDF1bnlep ( )

virtual

destructor

Definition at line 23 of file HeffDF1bnlep.cpp.

24{}

Member Function Documentation

◆ ComputeCoeffBnlep00()

gslpp::vector< gslpp::complex > ** HeffDF1bnlep::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 | \)

Definition at line 31 of file HeffDF1bnlep.cpp.

{
    
    const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbnlep( 0);
    const std::vector<WilsonCoefficient>& mcbCC = model.getMatching().CMbnlepCC( 0);
    
    coeffbnlep00qcd.setMu(mu); //inizializes to zero the coefficients
    coeffbnlep00CC.setMu(mu);
    coeffbnlep00.setMu(mu);
    
    orders_qed ordDF1ew = coeffbnlep00.getOrder_qed();
    orders ordDF1 =  coeffbnlep00.getOrder();
    
    for (unsigned int i = 0; i < mcb.size(); i++){
        for (int j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++) {        
                
                //Evolves the LO terms and the ones proportional to alpha_s 
                coeffbnlep00qcd.setCoeff(*coeffbnlep00qcd.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcb[i].getMu(), orders(k), NO_QED, mcb[i].getScheme())*
                    (*(mcb[i].getCoeff(orders(j - k)))), orders(j));
                
                
                //Evolves terms proportional to alpha_e and alpha_e/aplha_s
                coeffbnlep00qcd.setCoeff(*coeffbnlep00qcd.getCoeff(orders_qed(j+4)) +
                    u->Df1Evolnlep(mu, mcb[i].getMu(), NNLO, orders_qed(k+4), mcb[i].getScheme()) *
                    (*(mcb[i].getCoeff(orders(j - k)))), orders_qed(j+4));
   
            }
        }
        
                coeffbnlep00qcd.setCoeff(*coeffbnlep00qcd.getCoeff(orders_qed(NLO_QED11)) +
                    u->Df1Evolnlep(mu, mcb[i].getMu(), orders(LO), NO_QED,  mcb[i].getScheme()) *
                    (*(mcb[i].getCoeff(orders_qed(NLO_QED11)))), orders_qed(NLO_QED11));       
        
    }     
    
    //Evolves the current*current part of the hamiltonian (the one non-proportional to lambda_t)   
    for (unsigned int i = 0; i < mcbCC.size(); i++)
        for (int j = LO; j <= ordDF1; j++)
            for (int k = LO; k <= j; k++)
                coeffbnlep00CC.setCoeff(*coeffbnlep00CC.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcbCC[i].getMu(), orders(k), NO_QED, mcbCC[i].getScheme()) *
                    (*(mcbCC[i].getCoeff(orders(j - k)))), orders(j)); 
        
    coeffbnlep00qcd.setScheme(scheme);
    coeffbnlep00CC.setScheme(scheme);
    
    //Puts all together in a wilson coefficient object of 12 component: 
    //the first 10 terms are the ones proportional to lambda_t
    //the last two are the remainder current*current operators 
    gslpp::complex appoggio[10], appoggio1[10], appoggio2[10], appoggio3[10];
    for (int i=0; i<10; i++) {
        appoggio[i] = 0.;
        appoggio1[i] = 0.;
        appoggio2[i] = 0.;
        appoggio3[i] = 0.;
    }
    for (int j=LO; j <= ordDF1; j++) {
        bnlep2 = *coeffbnlep00qcd.getCoeff(orders(j));
        std::cout<< std::endl <<"$$$$$$$$$$$$ "<< j <<" $$$$$$$$$$$"<<std::endl;
                
        for (int i = 0; i < 10; i++){
            bnlep.assign(i, bnlep2(i));
         if(j == LO){ appoggio[i] = bnlep(i);}
         if( j == NLO){ appoggio1[i] = bnlep(i); }   
            std::cout<<"++++++++++ "<< i <<" -> "<< bnlep(i) <<" ++++++++++++"<<std::endl;
        }
        bnlep2 = *coeffbnlep00CC.getCoeff(orders(j));
        for (int i = 10; i < 12; i++){
            bnlep.assign(i, bnlep2(i-10));
            std::cout<<"++++++++++ "<< i <<" -> "<< bnlep(i) <<" ++++++++++++"<<std::endl;
            
        }        
    coeffbnlep00.setCoeff(bnlep, orders(j));
    }
    for (int k=LO_QED; k <= ordDF1ew; k++) {
        bnlep2 = *coeffbnlep00qcd.getCoeff(orders_qed(k));
        std::cout<< std::endl <<"$$$$$$$$$$$$ "<<k<<" $$$$$$$$$$$"<<std::endl;
                
        for (int l = 0; l < 10; l++){
            bnlep.assign(l, bnlep2(l));
            if(k == LO_QED){ appoggio2[l] = bnlep(l); }
            if(k == NLO_QED11) { appoggio3[l] = bnlep(l); }
            std::cout<<"++++++++++ "<< l <<" -> "<< bnlep(l) <<" ++++++++++++"<<std::endl;
        }          
    
    coeffbnlep00.setCoeff(bnlep, orders_qed(k));
    }
    
    std::cout<< std::endl << " COEFFICIENTI TOTALI " << std::endl; 
    gslpp::complex aaa = 0. ;
    for (int l = 0; l < 10; l++){  
        aaa = appoggio[l] + appoggio2[l];
    std::cout<< std::endl << " C_0 + C_ALE/ALPHA_S "<< l <<" -> " << aaa  << std::endl;
       aaa = appoggio1[l] + appoggio3[l];
    std::cout<< std::endl <<" C_1 + C_ALE " << l <<" -> " << aaa  << std::endl;    
    std::cout << std::endl << " ************************************************ " << std::endl;  
    } 
    
    return coeffbnlep00.getCoeff();
}

◆ ComputeCoeffBnlep01()

gslpp::vector< gslpp::complex > ** HeffDF1bnlep::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 | \)

Definition at line 215 of file HeffDF1bnlep.cpp.

{
    
    const std::vector<WilsonCoefficient>& mcbCC1 = model.getMatching().CMbnlepCC( 2);
    const std::vector<WilsonCoefficient>& mcbCC2 = model.getMatching().CMbnlepCC( 3);
    
    coeffbnlep01.setMu(mu);
    coeffbnlep01A.setMu(mu);
    coeffbnlep01B.setMu(mu);
    
    orders ordDF1 = coeffbnlep01A.getOrder();
    
    //evolution of the current*current terms
    for (unsigned int i = 0; i < mcbCC1.size(); i++)
        for (int j = LO; j <= ordDF1; j++)
            for (int k = LO; k <= j; k++)
                coeffbnlep01A.setCoeff(*coeffbnlep01A.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcbCC1[i].getMu(), orders(k), NO_QED, mcbCC1[i].getScheme()) *
                    (*(mcbCC1[i].getCoeff(orders(j - k)))), orders(j)); 
        
    for (unsigned int i = 0; i < mcbCC2.size(); i++)
        for (int j = LO; j <= ordDF1; j++)
            for (int k = LO; k <= j; k++)
                coeffbnlep01B.setCoeff(*coeffbnlep01B.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcbCC2[i].getMu(), orders(k), NO_QED, mcbCC2[i].getScheme()) *
                    (*(mcbCC2[i].getCoeff(orders(j - k)))), orders(j)); 
        
    coeffbnlep01A.setScheme(scheme);
    coeffbnlep01B.setScheme(scheme);
    coeffbnlep01.setScheme(scheme);
    
    //Puts all together in a wilson coefficient object of 4 components
    for (int j=LO; j <= ordDF1; j++) {
        bnlep2 = *coeffbnlep01A.getCoeff(orders(j));
        for (int i = 0; i < 2; i++){
            bnlep.assign(i, bnlep2(i));
        }
        bnlep2 = *coeffbnlep01A.getCoeff(orders(j));
        for (int i = 2; i < 4; i++){
            bnlep.assign(i, bnlep2(i-2));
        }        
    coeffbnlep01.setCoeff(bnlep, orders(j));
    }    
    return coeffbnlep01.getCoeff();   
    
}

◆ ComputeCoeffBnlep10()

gslpp::vector< gslpp::complex > ** HeffDF1bnlep::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 | \)

Definition at line 139 of file HeffDF1bnlep.cpp.

{
    
    const std::vector<WilsonCoefficient>& mcb = model.getMatching().CMbnlep( 1);
    const std::vector<WilsonCoefficient>& mcbCC = model.getMatching().CMbnlepCC( 1);
    
    coeffbnlep10qcd.setMu(mu);
    coeffbnlep10CC.setMu(mu);
    coeffbnlep10.setMu(mu);
    
    orders_qed ordDF1ew = coeffbnlep10.getOrder_qed();
    orders ordDF1 =  coeffbnlep10.getOrder();
    
    for (unsigned int i = 0; i < mcb.size(); i++){
        for (int j = LO; j <= ordDF1; j++){
            for (int k = LO; k <= j; k++)   {
                
                //Evolves the LO terms and the ones proportional to alpha_s 
                coeffbnlep10qcd.setCoeff(*coeffbnlep10qcd.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcb[i].getMu(), orders(k), NO_QED,  mcb[i].getScheme()) *
                    (*(mcb[i].getCoeff(orders(j - k)))), orders(j));
                
                //Evolves terms proportional to alpha_e and alpha_e/aplha_s
                coeffbnlep10qcd.setCoeff(*coeffbnlep10qcd.getCoeff(orders_qed(j+4)) +
                    u->Df1Evolnlep(mu, mcb[i].getMu(), NNLO, orders_qed(k+4), mcb[i].getScheme()) *
                    (*(mcb[i].getCoeff(orders(j - k)))), orders_qed(j+4));
            }
        }
            
        coeffbnlep10qcd.setCoeff(*coeffbnlep10qcd.getCoeff(orders_qed(NLO_QED11)) +
                    u->Df1Evolnlep(mu, mcb[i].getMu(), orders(LO), NO_QED, mcb[i].getScheme()) *
                    (*(mcb[i].getCoeff(orders(LO_QED)))), orders_qed(NLO_QED11));
    }        
    
    //Evolves the current*current part of the hamiltonian (the one non-proportional to lambda_t) 
    for (unsigned int i = 0; i < mcbCC.size(); i++)
        for (int j = LO; j <= ordDF1; j++)
            for (int k = LO; k <= j; k++)
                coeffbnlep10CC.setCoeff(*coeffbnlep10CC.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcbCC[i].getMu(), orders(k), NO_QED, mcbCC[i].getScheme()) *
                    (*(mcbCC[i].getCoeff(orders(j - k)))), orders(j)); 
        
    coeffbnlep10qcd.setScheme(scheme);
    coeffbnlep10CC.setScheme(scheme);
    
    //Puts all together in a wilson coefficient object of 12 component: 
    //the first 10 terms are the one proportional to lambda_t
    //the last two are the remainder current*current operators 
    
    for (int j=LO; j <= ordDF1; j++) {
        bnlep2 = *coeffbnlep10qcd.getCoeff(orders(j));
        for (int i = 0; i < 10; i++){
            bnlep.assign(i, bnlep2(i));
        }
        bnlep2 = *coeffbnlep10CC.getCoeff(orders(j));
        for (int i = 10; i < 12; i++){
            bnlep.assign(i, bnlep2(i-10));
        }        
    coeffbnlep10.setCoeff(bnlep, orders(j));
    }
    for (int k=LO_QED; k <= ordDF1ew; k++) {
        bnlep2 = *coeffbnlep10qcd.getCoeff(orders_qed(k));
        for (int l = 0; l < 10; l++){
            bnlep.assign(l, bnlep2(l));;
        }       
    coeffbnlep10.setCoeff(bnlep, orders_qed(k));
    }
    
    return coeffbnlep10.getCoeff();
}

◆ ComputeCoeffBnlep11()

gslpp::vector< gslpp::complex > ** HeffDF1bnlep::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 | \)

Definition at line 267 of file HeffDF1bnlep.cpp.

{
    
    const std::vector<WilsonCoefficient>& mcbCC1 = model.getMatching().CMbnlepCC( 2);
    const std::vector<WilsonCoefficient>& mcbCC2 = model.getMatching().CMbnlepCC( 3);
    
    coeffbnlep11.setMu(mu);
    coeffbnlep11A.setMu(mu);
    coeffbnlep11B.setMu(mu);
    
    orders ordDF1 = coeffbnlep11A.getOrder();
    
    for (unsigned int i = 0; i < mcbCC1.size(); i++)
        for (int j = LO; j <= ordDF1; j++)
            for (int k = LO; k <= j; k++)
                coeffbnlep11A.setCoeff(*coeffbnlep11A.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcbCC1[i].getMu(), orders(k), NO_QED, mcbCC1[i].getScheme()) *
                    (*(mcbCC1[i].getCoeff(orders(j - k)))), orders(j)); 
        
    for (unsigned int i = 0; i < mcbCC2.size(); i++)
        for (int j = LO; j <= ordDF1; j++)
            for (int k = LO; k <= j; k++)
                coeffbnlep11B.setCoeff(*coeffbnlep11B.getCoeff(orders(j)) +
                    u->Df1Evolnlep(mu, mcbCC2[i].getMu(), orders(k), NO_QED, mcbCC2[i].getScheme()) *
                    (*(mcbCC2[i].getCoeff(orders(j - k)))), orders(j)); 
        
    coeffbnlep11A.setScheme(scheme);
    coeffbnlep11B.setScheme(scheme);
    coeffbnlep11.setScheme(scheme);
    
   for (int j=LO; j <= ordDF1; j++) {
        bnlep2 = *coeffbnlep11A.getCoeff(orders(j));
        for (int i = 0; i < 2; i++){
            bnlep.assign(i, bnlep2(i));
        }
        bnlep2 = *coeffbnlep11A.getCoeff(orders(j));
        for (int i = 2; i < 4; i++){
            bnlep.assign(i, bnlep2(i-2));
        }        
    coeffbnlep11.setCoeff(bnlep, orders(j));
    }    
    return coeffbnlep11.getCoeff();   
    
}

◆ getCoeffbnlep00()

WilsonCoefficient HeffDF1bnlep::getCoeffbnlep00 ( ) const

inline

Definition at line 64 of file HeffDF1bnlep.h.

                                              {
        return coeffbnlep00;
    }

◆ getCoeffbnlep01()

WilsonCoefficient HeffDF1bnlep::getCoeffbnlep01 ( ) const

inline

Definition at line 72 of file HeffDF1bnlep.h.

                                              {
        return coeffbnlep10;
    }

◆ getCoeffbnlep10()

WilsonCoefficient HeffDF1bnlep::getCoeffbnlep10 ( ) const

inline

Definition at line 68 of file HeffDF1bnlep.h.

                                              {
        return coeffbnlep01;
    }

◆ getCoeffbnlep11()

WilsonCoefficient HeffDF1bnlep::getCoeffbnlep11 ( ) const

inline

Definition at line 76 of file HeffDF1bnlep.h.

                                              {
        return coeffbnlep11;
    }

◆ GetModel()

const StandardModel & HeffDF1bnlep::GetModel ( ) const

inline

Definition at line 84 of file HeffDF1bnlep.h.

                                          {
        return model;
    }

◆ getUDF1()

EvolDF1nlep & HeffDF1bnlep::getUDF1 ( ) const

inline

Definition at line 80 of file HeffDF1bnlep.h.

                                 {
        return *u;
    }

Member Data Documentation

◆ bnlep

gslpp::vector<gslpp::complex> HeffDF1bnlep::bnlep

private

Definition at line 97 of file HeffDF1bnlep.h.

◆ bnlep2

gslpp::vector<gslpp::complex> HeffDF1bnlep::bnlep2

private

Definition at line 97 of file HeffDF1bnlep.h.

◆ bnlepCC

gslpp::vector<gslpp::complex> HeffDF1bnlep::bnlepCC

private

Definition at line 97 of file HeffDF1bnlep.h.

◆ coeffbnlep00

WilsonCoefficient HeffDF1bnlep::coeffbnlep00

private

Definition at line 91 of file HeffDF1bnlep.h.

◆ coeffbnlep00CC

WilsonCoefficient HeffDF1bnlep::coeffbnlep00CC

private

Definition at line 93 of file HeffDF1bnlep.h.

◆ coeffbnlep00qcd

WilsonCoefficient HeffDF1bnlep::coeffbnlep00qcd

private

Definition at line 91 of file HeffDF1bnlep.h.

◆ coeffbnlep01

WilsonCoefficient HeffDF1bnlep::coeffbnlep01

private

Definition at line 93 of file HeffDF1bnlep.h.

◆ coeffbnlep01A

WilsonCoefficient HeffDF1bnlep::coeffbnlep01A

private

Definition at line 93 of file HeffDF1bnlep.h.

◆ coeffbnlep01B

WilsonCoefficient HeffDF1bnlep::coeffbnlep01B

private

Definition at line 93 of file HeffDF1bnlep.h.

◆ coeffbnlep10

WilsonCoefficient HeffDF1bnlep::coeffbnlep10

private

Definition at line 92 of file HeffDF1bnlep.h.

◆ coeffbnlep10CC

WilsonCoefficient HeffDF1bnlep::coeffbnlep10CC

private

Definition at line 94 of file HeffDF1bnlep.h.

◆ coeffbnlep10qcd

WilsonCoefficient HeffDF1bnlep::coeffbnlep10qcd

private

Definition at line 92 of file HeffDF1bnlep.h.

◆ coeffbnlep11

WilsonCoefficient HeffDF1bnlep::coeffbnlep11

private

Definition at line 94 of file HeffDF1bnlep.h.

◆ coeffbnlep11A

WilsonCoefficient HeffDF1bnlep::coeffbnlep11A

private

Definition at line 94 of file HeffDF1bnlep.h.

◆ coeffbnlep11B

WilsonCoefficient HeffDF1bnlep::coeffbnlep11B

private

Definition at line 94 of file HeffDF1bnlep.h.

◆ model

const StandardModel& HeffDF1bnlep::model

private

Definition at line 89 of file HeffDF1bnlep.h.

◆ u

std::unique_ptr<EvolDF1nlep> HeffDF1bnlep::u

private

Definition at line 95 of file HeffDF1bnlep.h.

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

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ HeffDF1bnlep()

◆ ~HeffDF1bnlep()

Member Function Documentation

◆ ComputeCoeffBnlep00()

◆ ComputeCoeffBnlep01()

◆ ComputeCoeffBnlep10()

◆ ComputeCoeffBnlep11()

◆ getCoeffbnlep00()

◆ getCoeffbnlep01()

◆ getCoeffbnlep10()

◆ getCoeffbnlep11()

◆ GetModel()

◆ getUDF1()

Member Data Documentation

◆ bnlep

◆ bnlep2

◆ bnlepCC

◆ coeffbnlep00

◆ coeffbnlep00CC

◆ coeffbnlep00qcd

◆ coeffbnlep01

◆ coeffbnlep01A

◆ coeffbnlep01B

◆ coeffbnlep10

◆ coeffbnlep10CC

◆ coeffbnlep10qcd

◆ coeffbnlep11

◆ coeffbnlep11A

◆ coeffbnlep11B

◆ model

◆ u