Detailed Description

A class for the matching in the LeftRightSymmetricModel.

Author: HEPfit Collaboration

Copyright: GNU General Public License

Definition at line 24 of file LeftRightSymmetricModelMatching.h.

Public Member Functions
std::vector< WilsonCoefficient > &	CMBMll (QCD::lepton lepton)

virtual std::vector< WilsonCoefficient > &	CMbsg ()

std::vector< WilsonCoefficient > &	CMprimeBMll (QCD::lepton lepton)

std::vector< WilsonCoefficient > &	CMprimebsg ()

	LeftRightSymmetricModelMatching (const LeftRightSymmetricModel &LeftRightSymmetricModel_i)

void	setCMbsgWR ()

gslpp::complex	setWCbsgHp (int i, orders order)

gslpp::complex	setWCbsgWR (int i, orders order)

void	updateLeftRightSymmetricModelParameters ()
	Updates to new LeftRightSymmetricModel parameter sets. More...

Public Member Functions inherited from StandardModelMatching
virtual std::vector< WilsonCoefficient > &	CMdbd2 ()
	\( \Delta B = 2 \), \( B_{d} \) More...

virtual std::vector< WilsonCoefficient > &	CMdbs2 ()
	\( \Delta B = 2 \), \( B_{s} \) More...

virtual std::vector< WilsonCoefficient > &	CMdd2 ()
	\( \Delta C = 2 \), More...

	StandardModelMatching (const StandardModel &SM_i)

void	updateSMParameters ()
	Updates to new Standard Model parameter sets. More...

virtual	~StandardModelMatching ()

Public Member Functions inherited from ModelMatching
virtual std::vector< WilsonCoefficient > &	CMbnlep (const int a)=0

virtual std::vector< WilsonCoefficient > &	CMbnlepCC (const int a)=0

virtual std::vector< WilsonCoefficient > &	CMd1 ()=0

virtual std::vector< WilsonCoefficient > &	CMd1Buras ()=0

virtual std::vector< WilsonCoefficientNew > &	CMDF1 (std::string blocks, unsigned int nops)=0

virtual	~ModelMatching ()

Private Attributes
double	alpha

gslpp::complex	CWbsgArrayLO [8]

double	gW

double	mbottom

WilsonCoefficient	mcBMll

WilsonCoefficient	mcbsg

WilsonCoefficient	mcprimeBMll

WilsonCoefficient	mcprimebsg

double	mH2psq

double	mtop

double	Mut

double	Muw

double	mW

double	mWR

gslpp::matrix< gslpp::complex >	myCKM

gslpp::matrix< gslpp::complex >	myCKMR

const LeftRightSymmetricModel &	myLeftRightSymmetricModel

double	vev

std::vector< WilsonCoefficient >	vmcBMll

std::vector< WilsonCoefficient >	vmcbsg

std::vector< WilsonCoefficient >	vmcprimeBMll

std::vector< WilsonCoefficient >	vmcprimebsg

double	xi

Constructor & Destructor Documentation

◆ LeftRightSymmetricModelMatching()

LeftRightSymmetricModelMatching::LeftRightSymmetricModelMatching ( const LeftRightSymmetricModel & LeftRightSymmetricModel_i )

Definition at line 12 of file LeftRightSymmetricModelMatching.cpp.

                                                                                                                           :
  
     StandardModelMatching(LeftRightSymmetricModel_i),
     myLeftRightSymmetricModel(LeftRightSymmetricModel_i),
     myCKM(3, 3, 0.),
     myCKMR(3, 3, 0.),
     mcbsg(8, NDR, NLO),
     mcprimebsg(8, NDR, NLO),
     mcBMll(13, NDR, NLO),
     mcprimeBMll(13, NDR, NLO)
 {}

Member Function Documentation

◆ CMBMll()

std::vector< WilsonCoefficient > & LeftRightSymmetricModelMatching::CMBMll ( QCD::lepton lepton )

virtual

Implements ModelMatching.

Definition at line 276 of file LeftRightSymmetricModelMatching.cpp.

 {
  
     vmcBMll = StandardModelMatching::CMBMll(lepton);
  
     switch (mcbsg.getScheme()) {
         case NDR:
  
             break;
         default:
             std::stringstream out;
             out << mcBMll.getScheme();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMBMll(): scheme " + out.str() + "not implemented");
     }
  
     mcBMll.setMu(myLeftRightSymmetricModel.getMuw());
  
     switch (mcBMll.getOrder()) {
         case NNLO:
         case NLO:
             //mcBMll.setCoeff(6, 0., NLO);
         case LO:
             mcBMll.setCoeff(6, 0., LO);
             mcBMll.setCoeff(8, 0., LO);
             mcBMll.setCoeff(9, 0., LO);
             break;
         default:
             std::stringstream out;
             out << mcBMll.getOrder();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMBMll(): order " + out.str() + "not implemented");
     }
  
     vmcBMll.push_back(mcBMll);
     return (vmcBMll);
 }

◆ CMbsg()

std::vector< WilsonCoefficient > & LeftRightSymmetricModelMatching::CMbsg ( )

virtual

Implements ModelMatching.

Definition at line 209 of file LeftRightSymmetricModelMatching.cpp.

 {
  
     setCMbsgWR();
     switch (mcbsg.getScheme()) {
         case NDR:
             break;
         default:
             std::stringstream out;
             out << mcbsg.getScheme();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMbsg(): scheme " + out.str() + "not implemented"); 
     }
  
     mcbsg.setMu(sqrt(mH2psq));
  
     switch (mcbsg.getOrder()) {
         case NNLO:
         case NLO:
         case LO: {
             mcbsg.setCoeff(6, setWCbsgHp(6, LO), LO);
             mcbsg.setCoeff(7, setWCbsgHp(7, LO), LO);
             break;
         }
         default:
             std::stringstream out;
             out << mcbsg.getOrder();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMbsg(): order " + out.str() + "not implemented"); 
     }
  
     vmcbsg.push_back(mcbsg);
     return (vmcbsg);
 }

◆ CMprimeBMll()

std::vector< WilsonCoefficient > & LeftRightSymmetricModelMatching::CMprimeBMll ( QCD::lepton lepton )

virtual

Implements ModelMatching.

Definition at line 312 of file LeftRightSymmetricModelMatching.cpp.

 {
  
     vmcprimeBMll = StandardModelMatching::CMprimeBMll(lepton);
  
     switch (mcprimebsg.getScheme()) {
         case NDR:
  
             break;
         default:
             std::stringstream out;
             out << mcprimeBMll.getScheme();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMprimeBMll(): scheme " + out.str() + "not implemented"); 
     }
  
     mcprimeBMll.setMu(myLeftRightSymmetricModel.getMuw());
  
     switch (mcprimeBMll.getOrder()) {
         case NNLO:
         case NLO:
             //mcprimeBMll.setCoeff(6, 0., NLO);
         case LO:
             mcprimeBMll.setCoeff(6, 0., LO);
             mcprimeBMll.setCoeff(8, 0., LO);
             mcprimeBMll.setCoeff(9, 0., LO);
             break;
         default:
             std::stringstream out;
             out << mcprimeBMll.getOrder();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMprimeBMll(): order " + out.str() + "not implemented"); 
     }
  
     vmcprimeBMll.push_back(mcprimeBMll);
     return (vmcprimeBMll);
 }

◆ CMprimebsg()

std::vector< WilsonCoefficient > & LeftRightSymmetricModelMatching::CMprimebsg ( )

virtual

Implements ModelMatching.

Definition at line 242 of file LeftRightSymmetricModelMatching.cpp.

 {
  
     vmcprimebsg = StandardModelMatching::CMprimebsg();
  
     switch (mcprimebsg.getScheme()) {
         case NDR:
  
             break;
         default:
             std::stringstream out;
             out << mcprimebsg.getScheme();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMprimebsg(): scheme " + out.str() + "not implemented"); 
     }
  
     mcprimebsg.setMu(myLeftRightSymmetricModel.getMuw());
  
     switch (mcprimebsg.getOrder()) {
         case NNLO:
         case NLO:
             mcprimebsg.setCoeff(6, 0., NLO);
         case LO:
             mcprimebsg.setCoeff(6, 0., LO);
             break;
         default:
             std::stringstream out;
             out << mcprimebsg.getOrder();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMprimebsg(): order " + out.str() + "not implemented"); 
     }
  
     vmcprimebsg.push_back(mcprimebsg);
     return (vmcprimebsg);
 }

◆ setCMbsgWR()

void LeftRightSymmetricModelMatching::setCMbsgWR ( )

Definition at line 170 of file LeftRightSymmetricModelMatching.cpp.

 {
  
     vmcbsg = StandardModelMatching::CMbsg();
  
     switch (mcbsg.getScheme()) {
         case NDR:
             break;
         default:
             std::stringstream out;
             out << mcbsg.getScheme();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMbsg(): scheme " + out.str() + "not implemented"); 
     }
  
     mcbsg.setMu(mWR);
  
     switch (mcbsg.getOrder()) {
         case NNLO:
         case NLO:
         case LO: {
 //                std::cout<<"LRSM matching"<<std::endl;
 //            gslpp::complex dummy7 = setWCbsg(6, 100.0, LO);
 //            gslpp::complex dummy8 = setWCbsg(7, 100.0, LO);
 //            std::cout<<"C7 = "<<dummy7<<std::endl;
 //            std::cout<<"C8 = "<<dummy8<<std::endl;
             mcbsg.setCoeff(6, setWCbsgWR(6, LO), LO);
             mcbsg.setCoeff(7, setWCbsgWR(7, LO), LO);
             break;
         }
         default:
             std::stringstream out;
             out << mcbsg.getOrder();
             throw std::runtime_error("LeftRightSymmetricModelMatching::CMbsg(): order " + out.str() + "not implemented"); 
     }
  
     vmcbsg.push_back(mcbsg);
 //    return (vmcbsg);
 }

◆ setWCbsgHp()

gslpp::complex LeftRightSymmetricModelMatching::setWCbsgHp	(	int	i,
		orders	order
	)

Definition at line 105 of file LeftRightSymmetricModelMatching.cpp.

 {
 //    if ( tanbsg == tan && mtbsg == mt  && mhpbsg == mhp && mubsg == mu){
 //        switch (order){
 //        case NNLO:
 //            return ( CWbsgArrayNNLO[i] );
 //        case NLO:
 //            return ( CWbsgArrayNLO[i] );
 //            break;
 //        case LO:
 //            return ( CWbsgArrayLO[i] );
 //            break;
 //        default:
 //            std::stringstream out;
 //            out << order;
 //            throw std::runtime_error("order" + out.str() + "not implemeted"); 
 //        }
 //    }
     
 //    tanbsg = tan; mtbsg = mt; mhpbsg = mhp; mubsg = mu;
     double yt = mtop * mtop / mH2psq;
     double ytm1sq = (yt - 1.0)*(yt - 1.0);
     double kappa = vev * sqrt(0.5 / (1.0 + xi * xi));
     double kappaprime = xi*kappa;
     double sinb = kappaprime * sqrt(2.0) / vev;
     
     double A1Hp = ((yt * yt - 2.0 / 3.0 * yt) * log(yt) / ((1.0 - yt) * ytm1sq) + (5.0 * yt * yt - 3.0 * yt) / (6.0 * ytm1sq));
     double A2Hp = -((0.5 * yt * yt * yt - yt * yt / 3.0) * log(yt) / (ytm1sq * ytm1sq)+(-8.0 * yt * yt * yt - 5.0 * yt * yt + 7.0 * yt) / (36.0 * ytm1sq * (yt - 1.0))) - A1Hp;
     gslpp::complex DeltaC7_Hp = -(sinb * kappa * sqrt(2.0) / vev * mtop / mbottom * (cos(alpha) + gslpp::complex::i() * sin(alpha))*(myCKMR(2, 2) / myCKM(2, 2)) * A1Hp
                                 + 4.0 * sinb * sinb * kappa * kappa / (vev * vev) * A2Hp)
                                 / (1.0 - 4.0 * sinb * sinb + 4.0 * sinb * sinb * sinb * sinb);
     gslpp::complex DeltaC8_Hp = 0.0;
  
     switch (order) {
         case NNLO:
         case NLO:
         case LO:
  
             CWbsgArrayLO[6] = DeltaC7_Hp;
             CWbsgArrayLO[7] = DeltaC8_Hp;
  
             break;
         default:
             std::stringstream out;
             out << order;
             throw std::runtime_error("order" + out.str() + "not implemeted");
     }
     
     /*std::cout << "CWbsgArrayLO[6] = " << CWbsgArrayLO[6] << std::endl;
     std::cout << "CWbsgArrayLO[7] = " << CWbsgArrayLO[7] << std::endl << std::endl;*/
     
     
     switch (order) {
             //        case NNLO:
             //        case NLO:
         case LO:
             return ( CWbsgArrayLO[i]);
             break;
         default:
             std::stringstream out;
             out << order;
             throw std::runtime_error("order" + out.str() + "not implemeted");
     }
 }

◆ setWCbsgWR()

gslpp::complex LeftRightSymmetricModelMatching::setWCbsgWR	(	int	i,
		orders	order
	)

Definition at line 43 of file LeftRightSymmetricModelMatching.cpp.

 {
 //    if ( tanbsg == tan && mtbsg == mt  && mhpbsg == mhp && mubsg == mu){
 //        switch (order){
 //        case NNLO:
 //            return ( CWbsgArrayNNLO[i] );
 //        case NLO:
 //            return ( CWbsgArrayNLO[i] );
 //            break;
 //        case LO:
 //            return ( CWbsgArrayLO[i] );
 //            break;
 //        default:
 //            std::stringstream out;
 //            out << order;
 //            throw std::runtime_error("order" + out.str() + "not implemeted"); 
 //        }
 //    }
     
 //    tanbsg = tan; mtbsg = mt; mhpbsg = mhp; mubsg = mu;
     double xt = mtop * mtop / (mW * mW);
     double xtm1sq = (xt - 1.0)*(xt - 1.0);
     double kappa = vev * sqrt(0.5 / (1.0 + xi * xi));
     double kappaprime = xi*kappa;
     double kappaR = mWR / gW;
     gslpp::complex Atb = (mtop / mbottom) * kappaprime * kappa / (kappaR * kappaR)*(cos(alpha) + gslpp::complex::i() * sin(alpha))*(myCKMR(2, 2) / myCKM(2, 2));
     gslpp::complex DeltaC7_LR = Atb * ((1.5 * xt * xt - xt) * log(xt) / ((1.0 - xt) * xtm1sq) + (-5.0 * xt * xt + 31.0 * xt - 20.0) / (12.0 * xtm1sq));
     gslpp::complex DeltaC8_LR = Atb * (-1.5 * xt * log(xt) / ((1.0 - xt) * xtm1sq) + (-xt * xt - xt - 4.0) / (4.0 * xtm1sq));
     
  
     switch (order) {
         case NNLO:
         case NLO:
         case LO:
  
             CWbsgArrayLO[6] = DeltaC7_LR;
             CWbsgArrayLO[7] = DeltaC8_LR;
  
             break;
         default:
             std::stringstream out;
             out << order;
             throw std::runtime_error("order" + out.str() + "not implemeted");
     }
     
     /*std::cout << "CWbsgArrayLO[6] = " << CWbsgArrayLO[6] << std::endl;
     std::cout << "CWbsgArrayLO[7] = " << CWbsgArrayLO[7] << std::endl << std::endl;*/
     
     
     switch (order) {
             //        case NNLO:
             //        case NLO:
         case LO:
             return ( CWbsgArrayLO[i]);
             break;
         default:
             std::stringstream out;
             out << order;
             throw std::runtime_error("order" + out.str() + "not implemeted");
     }
 }

◆ updateLeftRightSymmetricModelParameters()

void LeftRightSymmetricModelMatching::updateLeftRightSymmetricModelParameters ( )

Updates to new LeftRightSymmetricModel parameter sets.

Returns

Definition at line 24 of file LeftRightSymmetricModelMatching.cpp.

 {
     myCKM = myLeftRightSymmetricModel.getVCKM();
     StandardModelMatching::updateSMParameters();
     Muw = myLeftRightSymmetricModel.getMuw();
     Mut = myLeftRightSymmetricModel.getMut();
     mW = myLeftRightSymmetricModel.Mw();
     mtop = myLeftRightSymmetricModel.Mrun(Mut, myLeftRightSymmetricModel.getQuarks(QCD::TOP).getMass_scale(),
                         myLeftRightSymmetricModel.getQuarks(QCD::TOP).getMass(), FULLNNLO);
     mbottom = myLeftRightSymmetricModel.getQuarks(QCD::BOTTOM).getMass();
     vev = myLeftRightSymmetricModel.v();
     gW = sqrt(8.0*myLeftRightSymmetricModel.getGF() / sqrt(2.0)) * mW;
     myCKMR = myLeftRightSymmetricModel.getVCKMR();
     mWR = myLeftRightSymmetricModel.getmWR();
     mH2psq = myLeftRightSymmetricModel.getmH2p_2();
     xi = myLeftRightSymmetricModel.getxi_LRSM();
     alpha = myLeftRightSymmetricModel.getalpha_LRSM();
 }