HeffDF1bnlep Class Reference

#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.

{}

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 30 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 212 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));
    }    

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 137 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));
    }
    

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 263 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));

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:

• HeffDF1bnlep.h
• HeffDF1bnlep.cpp