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

#include <HeffDF1.h>

Detailed Description

Definition at line 19 of file HeffDF1.h.

Public Member Functions

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

Private Attributes

std::string blocks
 
WilsonCoefficientNew coeff
 
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 : model(SM),
15 coeff(blocks_nops.at(blocks), NDR, order_qcd, order_qed),
16 evolDF1(blocks, NDR, SM, order_qcd, order_qed)
17 {
18  this->blocks = blocks;
19  this->nops = blocks_nops.at(blocks);
20  mu_cache = 0.;
21 }

◆ ~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 
)
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

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 }

◆ 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, order_qed == QED0 ? false : true);
38  eta = alsM / model.Als(mu, FULLNNNLO, 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 }

Member Data Documentation

◆ blocks

std::string HeffDF1::blocks
private

Definition at line 73 of file HeffDF1.h.

◆ coeff

WilsonCoefficientNew HeffDF1::coeff
private

Definition at line 70 of file HeffDF1.h.

◆ evolDF1

EvolDF1 HeffDF1::evolDF1
private

Definition at line 71 of file HeffDF1.h.

◆ model

const StandardModel& HeffDF1::model
private

Definition at line 68 of file HeffDF1.h.

◆ mu_cache

double HeffDF1::mu_cache
private

Definition at line 75 of file HeffDF1.h.

◆ nops

unsigned int HeffDF1::nops
private

Definition at line 74 of file HeffDF1.h.

◆ scheme_cache

schemes HeffDF1::scheme_cache
private

Definition at line 76 of file HeffDF1.h.

◆ Vmu_cache

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

Definition at line 77 of file HeffDF1.h.

◆ WC_cache

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

Definition at line 78 of file HeffDF1.h.

The documentation for this class was generated from the following files:
HeffDF1::nops
unsigned int nops
Definition: HeffDF1.h:74
HeffDF1::WC_cache
std::vector< WilsonCoefficientNew > WC_cache
Definition: HeffDF1.h:78
QED0
Definition: OrderScheme.h:83
WilsonTemplateNew::getOrder_QED
qed_orders getOrder_QED() const
Definition: WilsonTemplateNew.h:57
HeffDF1::mu_cache
double mu_cache
Definition: HeffDF1.h:75
QCD::Nf
double Nf(const double mu) const
The number of active flavour at scale .
Definition: QCD.cpp:438
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
FULLNNNLO
Definition: OrderScheme.h:39
HeffDF1::model
const StandardModel & model
Definition: HeffDF1.h:68
HeffDF1::blocks
std::string blocks
Definition: HeffDF1.h:73
StandardModel::Beta_e
double Beta_e(int nm, unsigned int nf) const
QED beta function coefficients - eq. (36) hep-ph/0512066.
Definition: StandardModel.cpp:582
NDR
Definition: OrderScheme.h:21
WilsonCoefficientNew::setCoeff
void setCoeff(int i, gslpp::complex z, qcd_orders order_qcd_i, qed_orders order_qed_i=QED0)
Definition: WilsonCoefficientNew.cpp:32
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
WilsonTemplateNew::getOrder_QCD
qcd_orders getOrder_QCD() const
Definition: WilsonTemplateNew.h:53
QCD1
Definition: OrderScheme.h:68
QCD2
Definition: OrderScheme.h:69
HeffDF1::Vmu_cache
std::vector< double > Vmu_cache
Definition: HeffDF1.h:77
StandardModel::Ale
double Ale(double mu, orders order, bool Nf_thr=true) const
The running electromagnetic coupling in the scheme.
Definition: StandardModel.cpp:732
uint
unsigned int uint
Definition: EvolDF1.h:20
StandardModel::Als
double Als(double mu, orders order=FULLNLO, bool qed_flag=false, bool Nf_thr=true) const
The running QCD coupling in the scheme including QED corrections.
Definition: StandardModel.cpp:602
HeffDF1::evolDF1
EvolDF1 evolDF1
Definition: HeffDF1.h:71
QED2
Definition: OrderScheme.h:85
StandardModel::Beta_s
double Beta_s(int nm, unsigned int nf) const
QCD beta function coefficients including QED corrections - eq. (36) hep-ph/0512066.
Definition: StandardModel.cpp:554
QCD0
Definition: OrderScheme.h:67
blocks_nops
std::map< std::string, unsigned int > blocks_nops
Definition: EvolDF1.cpp:16
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:952
WilsonTemplateNew::setMu
void setMu(double mu)
Definition: WilsonTemplateNew.h:73
WilsonTemplateNew::getMu
double getMu() const
Definition: WilsonTemplateNew.h:61
HeffDF1::coeff
WilsonCoefficientNew coeff
Definition: HeffDF1.h:70
HeffDF1::scheme_cache
schemes scheme_cache
Definition: HeffDF1.h:76
WilsonCoefficientNew::getCoeff
gslpp::vector< gslpp::complex > getCoeff(qcd_orders order_qcd_i, qed_orders order_qed_i=QED0) const
Definition: WilsonCoefficientNew.cpp:58
FULLNLO
Definition: OrderScheme.h:37
QED1
Definition: OrderScheme.h:84
StandardModel::getMuw
double getMuw() const
A get method to retrieve the matching scale around the weak scale.
Definition: StandardModel.h:938