a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
Public Member Functions | Protected Attributes | Private Attributes | List of all members
HeffDF1 Class Reference

#include <HeffDF1.h>

+ Inheritance diagram for HeffDF1:

Detailed Description

Definition at line 19 of file HeffDF1.h.

Public Member Functions

virtual Expanded< gslpp::vector< gslpp::complex > > ComputeCoeff (double mu, schemes scheme=NDR)
 
EvolDF1 getEvol () const
 
const StandardModel & GetModel () const
 
 HeffDF1 (std::string blocks, const StandardModel &SM, qcd_orders order_qcd=QCD1, qed_orders order_qed=QED0)
 constructor More...
 
gslpp::vector< gslpp::complex > LowScaleCoeff (qcd_orders order_qcd, qed_orders order_qed)
 
virtual ~HeffDF1 ()
 destructor More...
 

Protected Attributes

WilsonCoefficientNew coeff
 

Private Attributes

std::string blocks
 
EvolDF1 evolDF1
 
const StandardModel & model
 
double mu_cache
 
unsigned int nops
 
schemes scheme_cache
 
std::vector< double > Vmu_cache
 
std::vector< WilsonCoefficientNew > WC_cache
 

Constructor & Destructor Documentation

◆ HeffDF1()

HeffDF1::HeffDF1 ( std::string  blocks,
const StandardModel &  SM,
qcd_orders  order_qcd = QCD1,
qed_orders  order_qed = QED0 
)

constructor

Parameters
SM
modelmatching

Definition at line 13 of file HeffDF1.cpp.

14: coeff(blocks_nops.at(blocks), NDR, order_qcd, order_qed),
15model(SM),
16evolDF1(blocks, NDR, SM, order_qcd, order_qed)
17{
18 this->blocks = blocks;
19 this->nops = blocks_nops.at(blocks);
20 mu_cache = 0.;
21}
blocks_nops
std::map< std::string, unsigned int > blocks_nops
Definition: EvolDF1.cpp:16
NDR
@ NDR
Definition: OrderScheme.h:21
HeffDF1::blocks
std::string blocks
Definition: HeffDF1.h:75
HeffDF1::model
const StandardModel & model
Definition: HeffDF1.h:71
HeffDF1::nops
unsigned int nops
Definition: HeffDF1.h:76
HeffDF1::evolDF1
EvolDF1 evolDF1
Definition: HeffDF1.h:73
HeffDF1::coeff
WilsonCoefficientNew coeff
Definition: HeffDF1.h:68
HeffDF1::mu_cache
double mu_cache
Definition: HeffDF1.h:77

◆ ~HeffDF1()

virtual HeffDF1::~HeffDF1 ( )
inlinevirtual

destructor

Definition at line 32 of file HeffDF1.h.

32 {
33 };

Member Function Documentation

◆ ComputeCoeff()

Expanded< gslpp::vector< gslpp::complex > > HeffDF1::ComputeCoeff ( double  mu,
schemes  scheme = NDR 
)
virtual
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu B -> K^*ll decay, Misiak basis, Chetyrkin et al hep-ph/9612313

Reimplemented in HeffDF1_NP.

Definition at line 110 of file HeffDF1.cpp.

111{
112 const std::vector<WilsonCoefficientNew>& mc = model.getMatching().CMDF1(blocks, nops);
113 uint i;
114
115 if (mu == mu_cache && scheme == scheme_cache)
116 {
117 bool check = true;
118 for (i = 0; i < mc.size(); i++)
119 if (mc[i].getMu() == Vmu_cache[i])
120 check = check && (mc[i].getCoeff() == WC_cache[i].getCoeff());
121 else check = false;
122 if (check) return coeff.getCoeff();
123 }
124
125 mu_cache = mu;
126 scheme_cache = scheme;
127 WC_cache = mc;
128 Vmu_cache.clear();
129
130 coeff.setMu(mu); // also reset the coefficients
131
132 for (i = 0; i < mc.size(); i++)
133 {
134 Vmu_cache.push_back(mc[i].getMu());
135 coeff.setCoeff(coeff.getCoeff() + evolDF1.DF1Evol(mu, mc[i].getMu(), mc[i].getScheme()) * mc[i].getCoeff()); // multiple matching scales wrong for EW corrections *** TO BE FIXED
136 }
137
138 return coeff.getCoeff();
139}
uint
unsigned int uint
Definition: EvolDF1.h:20
EvolDF1::DF1Evol
const Expanded< gslpp::matrix< double > > & DF1Evol(double mu, double M, schemes scheme=NDR)
a method returning the evolutor related to the high scale and the low scale
Definition: EvolDF1.cpp:1359
HeffDF1::Vmu_cache
std::vector< double > Vmu_cache
Definition: HeffDF1.h:79
HeffDF1::WC_cache
std::vector< WilsonCoefficientNew > WC_cache
Definition: HeffDF1.h:80
HeffDF1::scheme_cache
schemes scheme_cache
Definition: HeffDF1.h:78
ModelMatching::CMDF1
virtual std::vector< WilsonCoefficientNew > & CMDF1(std::string blocks, unsigned int nops)=0
StandardModel::getMatching
virtual StandardModelMatching & getMatching() const
A get method to access the member reference of type StandardModelMatching.
Definition: StandardModel.h:965
WilsonCoefficientNew::getCoeff
gslpp::vector< gslpp::complex > getCoeff(qcd_orders order_qcd_i, qed_orders order_qed_i=QED0) const
Definition: WilsonCoefficientNew.cpp:58
WilsonCoefficientNew::setCoeff
void setCoeff(int i, gslpp::complex z, qcd_orders order_qcd_i, qed_orders order_qed_i=QED0)
Definition: WilsonCoefficientNew.cpp:32
WilsonTemplateNew::setMu
void setMu(double mu)
Definition: WilsonTemplateNew.h:73

◆ getEvol()

EvolDF1 HeffDF1::getEvol ( ) const
inline

Definition at line 59 of file HeffDF1.h.

59 {
60 return evolDF1;
61 }

◆ GetModel()

const StandardModel & HeffDF1::GetModel ( ) const
inline

Definition at line 63 of file HeffDF1.h.

63 {
64 return model;
65 }

◆ LowScaleCoeff()

gslpp::vector< gslpp::complex > HeffDF1::LowScaleCoeff ( qcd_orders  order_qcd,
qed_orders  order_qed 
)
Parameters
muis the low energy scale
schemeindicates the renormalization scheme
Returns
the effective hamiltonian at the scale mu B -> K^*ll decay, Misiak basis, Chetyrkin et al hep-ph/9612313
Parameters
Coeffvector of Wilson coefficient
nmorder of the expansion
Returns
the coefficient of the expansion in low-energy coupling constants as defined in eq. (68) of Huber et al., hep-ph/0512066

Definition at line 23 of file HeffDF1.cpp.

24{
25 double mu = coeff.getMu(), eta, M, alsM, kM, b0, b1, b0e, b1e;
26
27 // gslpp::vector<gslpp::complex> aux01(nops, 0.);
28 // gslpp::vector<gslpp::complex> aux11(nops, 0.);
29 // gslpp::vector<gslpp::complex> aux21(nops, 0.);
30
31 if (mu == -1) throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): coeff not initialized.");
32 if (model.Nf(mu) != 5) throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): defined for 5 flavours only.");
33 if (order_qcd > coeff.getOrder_QCD() || order_qed > coeff.getOrder_QED())
34 throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): order not computed at the high scale.");
35
36 M = model.getMuw();
37 alsM = model.Als(M, FULLNNNLO, true, order_qed == QED0 ? false : true);
38 eta = alsM / model.Als(mu, FULLNNNLO, true, order_qed == QED0 ? false : true);
39 alsM /= 4. * M_PI; // AlsM tilde
40 if (order_qed != QED0)
41 {
42 b0 = model.Beta_s(00, 5.);
43 b0e = model.Beta_e(00, 5.);
44 b1 = model.Beta_s(10, 5.);
45 b1e = model.Beta_e(01, 5.);
46 kM = model.Ale(M, FULLNLO) / 4. / M_PI / alsM;
47 }
48 // if(blocks == "CPL") {
49 // aux01.assign(6, (*(coeff.getCoeff(orders_qed(LO_QED))))(6));
50 // aux11.assign(6, (*(coeff.getCoeff(orders_qed(NLO_QED11))))(6));
51 // aux21.assign(6, (*(coeff.getCoeff(orders_qed(NLO_QED21))))(6));
52 // aux01.assign(7, (*(coeff.getCoeff(orders_qed(LO_QED))))(7));
53 // aux11.assign(7, (*(coeff.getCoeff(orders_qed(NLO_QED11))))(7));
54 // aux21.assign(7, (*(coeff.getCoeff(orders_qed(NLO_QED21))))(7));
55 // }
56 // else if(blocks == "CPML" || blocks == "CPMLQB") {
57 // aux01.assign(8, (*(coeff.getCoeff(orders_qed(LO_QED))))(8));
58 // aux11.assign(8, (*(coeff.getCoeff(orders_qed(NLO_QED11))))(8));
59 // aux21.assign(8, (*(coeff.getCoeff(orders_qed(NLO_QED21))))(8));
60 // aux01.assign(9, (*(coeff.getCoeff(orders_qed(LO_QED))))(9));
61 // aux11.assign(9, (*(coeff.getCoeff(orders_qed(NLO_QED11))))(9));
62 // aux21.assign(9, (*(coeff.getCoeff(orders_qed(NLO_QED21))))(9));
63
64 switch (order_qed)
65 {
66 case QED0:
67 switch (order_qcd)
68 {
69 case QCD0:
70 return coeff.getCoeff(QCD0, QED0);
71 case QCD1:
72 return (coeff.getCoeff(QCD1, QED0) * eta / alsM);
73 case QCD2:
74 return (coeff.getCoeff(QCD2, QED0) * eta / alsM * eta / alsM);
75 default:
76 throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): undefined order.");
77
78 }
79 case QED1:
80 switch (order_qcd)
81 {
82 case QCD0:
83 return coeff.getCoeff(QCD0, QED1) / kM / eta;
84 case QCD1:
85 return (coeff.getCoeff(QCD1, QED1) / kM / alsM);
86 case QCD2:
87 return (coeff.getCoeff(QCD2, QED1) * eta / kM / alsM / alsM);
88 default:
89 throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): undefined order.");
90 }
91 case QED2:
92 switch (order_qcd)
93 {
94 case QCD0:
95 return (coeff.getCoeff(QCD0, QED2) / kM / kM / eta / eta + b0e / b0 * (1. - eta) / eta / eta * coeff.getCoeff(QCD0, QED1) / kM);
96 case QCD1:
97 return (coeff.getCoeff(QCD1, QED2) / alsM / kM / kM / eta + b0e / b0 * (1. - eta) / eta * coeff.getCoeff(QCD1, QED1) / kM / alsM
98 + log(eta) / eta * (b0e * b1 / b0 / b0 - b1e / b0) * coeff.getCoeff(QCD0, QED1) / kM);
99 case QCD2:
100 return (coeff.getCoeff(QCD2, QED2) / alsM / alsM / kM / kM + b0e / b0 * (1. - eta) * coeff.getCoeff(QCD2, QED1) / kM / alsM / alsM
101 + log(eta) * (b0e * b1 / b0 / b0 - b1e / b0) * coeff.getCoeff(QCD1, QED1) / kM / alsM);
102 default:
103 throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): undefined order.");
104 }
105 default:
106 throw std::runtime_error("Error in HeffDF1::LowScaleCoeff(): undefined order.");
107 }
108}
FULLNNNLO
@ FULLNNNLO
Definition: OrderScheme.h:40
FULLNLO
@ FULLNLO
Definition: OrderScheme.h:38
QED1
@ QED1
Definition: OrderScheme.h:92
QED0
@ QED0
Definition: OrderScheme.h:91
QED2
@ QED2
Definition: OrderScheme.h:93
QCD1
@ QCD1
Definition: OrderScheme.h:76
QCD0
@ QCD0
Definition: OrderScheme.h:75
QCD2
@ QCD2
Definition: OrderScheme.h:77
QCD::Nf
const double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:571
StandardModel::getMuw
const double getMuw() const
A get method to retrieve the matching scale around the weak scale.
Definition: StandardModel.h:951
StandardModel::Ale
const double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
Definition: StandardModel/src/StandardModel.cpp:777
StandardModel::Beta_s
const double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
Definition: StandardModel/src/StandardModel.cpp:626
StandardModel::Als
const double Als(const double mu, const orders order, const bool Nf_thr, const bool qed_flag) const
The running QCD coupling in the scheme including QED corrections.
Definition: StandardModel.h:1088
StandardModel::Beta_e
const double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.
Definition: StandardModel/src/StandardModel.cpp:654
WilsonTemplateNew::getMu
double getMu() const
Definition: WilsonTemplateNew.h:61
WilsonTemplateNew::getOrder_QCD
qcd_orders getOrder_QCD() const
Definition: WilsonTemplateNew.h:53
WilsonTemplateNew::getOrder_QED
qed_orders getOrder_QED() const
Definition: WilsonTemplateNew.h:57

Member Data Documentation

◆ blocks

std::string HeffDF1::blocks
private

Definition at line 75 of file HeffDF1.h.

◆ coeff

WilsonCoefficientNew HeffDF1::coeff
protected

Definition at line 68 of file HeffDF1.h.

◆ evolDF1

EvolDF1 HeffDF1::evolDF1
private

Definition at line 73 of file HeffDF1.h.

◆ model

const StandardModel& HeffDF1::model
private

Definition at line 71 of file HeffDF1.h.

◆ mu_cache

double HeffDF1::mu_cache
private

Definition at line 77 of file HeffDF1.h.

◆ nops

unsigned int HeffDF1::nops
private

Definition at line 76 of file HeffDF1.h.

◆ scheme_cache

schemes HeffDF1::scheme_cache
private

Definition at line 78 of file HeffDF1.h.

◆ Vmu_cache

std::vector<double> HeffDF1::Vmu_cache
private

Definition at line 79 of file HeffDF1.h.

◆ WC_cache

std::vector<WilsonCoefficientNew> HeffDF1::WC_cache
private

Definition at line 80 of file HeffDF1.h.

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