a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
Flavour.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 HEPfit Collaboration
3  *
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include <functional>
9 #include "StandardModel.h"
10 #include "Flavour.h"
11 #include "MVll.h"
12 #include "MPll.h"
13 #include "HeffDF2.h"
14 #include "HeffDB1.h"
15 #include "MVgamma.h"
16 #include "MVlnu.h"
17 #include "MPlnu.h"
18 
19 Flavour::Flavour(const StandardModel& SM_i)
20 : mySM(SM_i)
21 {
22  dispersion = false;
23  CLNflag = false;
24 };
25 
26 bool Flavour::setFlag(const std::string name, const bool value)
27 {
28 
29  if (name.compare("UseDispersionRelation") == 0) {
30  setFlagUseDispersionRelation(value);
31  return true;
32  } else if (name.compare("CLNflag") == 0) {
33  setFlagCLN(value);
34  return true;
35  } else if (name.compare("FixedWCbtos") == 0) {
36  setFlagFixedWCbtos(value);
37  return true;
38  } else
39  return false;
40 }
41 
42 
43 HeffDF2& Flavour::getHDF2() const
44 {
45  return *getPtr<HeffDF2>(HDF2);
46 }
47 
48 HeffDB1& Flavour::getHDB1() const
49 {
50  return *getPtr<HeffDB1>(HDB1);
51 }
52 
53 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBd(double mu, schemes scheme) const
54 {
55  return getPtr<HeffDF2>(HDF2)->ComputeCoeffBd(mu, scheme);
56 }
57 
58 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBs(double mu, schemes scheme, bool SM) const
59 {
60  return getPtr<HeffDF2>(HDF2)->ComputeCoeffBs(mu, scheme, SM);
61 }
62 
63 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdd(double mu, schemes scheme) const
64 {
65  return getPtr<HeffDF2>(HDF2)->ComputeCoeffdd(mu, scheme);
66 }
67 
68 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffK(double mu, schemes scheme) const
69 {
70  return getPtr<HeffDF2>(HDF2)->ComputeCoeffK(mu, scheme);
71 }
72 
73 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffmK(double mu, schemes scheme) const
74 {
75  return getPtr<HeffDF2>(HDF2)->ComputeCoeffmK(mu, scheme);
76 }
77 
78 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsmumu(double mu, schemes scheme) const
79 {
80  return getPtr<HeffDB1>(HDB1)->ComputeCoeffsmumu(mu, scheme);
81 }
82 
83 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdmumu(double mu, schemes scheme) const
84 {
85  return getPtr<HeffDB1>(HDB1)->ComputeCoeffdmumu(mu, scheme);
86 }
87 
88 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffbtaunu(QCD::meson meson_i) const
89 {
90  return getPtr<HeffDB1>(HDB1)->ComputeCoeffbtaunu(meson_i);
91 }
92 
93 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsnunu() const
94 {
95  return getPtr<HeffDB1>(HDB1)->ComputeCoeffsnunu();
96 }
97 
98 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdnunu() const
99 {
100  return getPtr<HeffDB1>(HDB1)->ComputeCoeffdnunu();
101 }
102 
103 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsgamma(double mu, bool noSM, schemes scheme) const
104 {
105  return getPtr<HeffDB1>(HDB1)->ComputeCoeffsgamma(mu, noSM, scheme);
106 }
107 
108 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffprimesgamma(double mu, schemes scheme) const
109 {
110  return getPtr<HeffDB1>(HDB1)->ComputeCoeffprimesgamma(mu, scheme);
111 }
112 
113 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBMll(double mu, QCD::lepton lepton, bool noSM, schemes scheme) const
114 {
115  return getPtr<HeffDB1>(HDB1)->ComputeCoeffBMll(mu, lepton, noSM, scheme);
116 }
117 
118 gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffprimeBMll(double mu, QCD::lepton lepton, schemes scheme) const
119 {
120  return getPtr<HeffDB1>(HDB1)->ComputeCoeffprimeBMll(mu, lepton, scheme);
121 }
122 
123 MVll& Flavour::getMVll(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
124 {
125 // std::reference_wrapper<std::shared_ptr<MVll> > x(MVll_BdKstarmu);
126 // if (meson_i == StandardModel::B_D && vector_i == StandardModel::K_star && lep_i == StandardModel::MU) x = std::ref(MVll_BdKstarmu);
127 // else if (meson_i == StandardModel::B_D && vector_i == StandardModel::K_star && lep_i == StandardModel::ELECTRON) x = std::ref(MVll_BdKstarel);
128 // else if (meson_i == StandardModel::B_P && vector_i == StandardModel::K_star_P && lep_i == StandardModel::MU) x = std::ref(MVll_BpKstarmu);
129 // else if (meson_i == StandardModel::B_P && vector_i == StandardModel::K_star_P && lep_i == StandardModel::ELECTRON) x = std::ref(MVll_BpKstarel);
130 // else if (meson_i == StandardModel::B_S && vector_i == StandardModel::PHI && lep_i == StandardModel::MU) x = std::ref(MVll_Bsphimu);
131 // else if (meson_i == StandardModel::B_S && vector_i == StandardModel::PHI && lep_i == StandardModel::ELECTRON) x = std::ref(MVll_Bsphiel);
132 // else throw std::runtime_error("Flavour: Decay channel not implemented.");
133 // return *getPtr<MVll>(x.get(), meson_i, vector_i, lep_i);
134 // std::vector<int> key({meson_i, vector_i, lep_i});
135 // if(MVllMap.find(key)==MVllMap.end()) {
136 // MVllMap.insert(std::make_pair(key,std::shared_ptr<MVll>(new MVll(mySM,meson_i, vector_i, lep_i))));
137 // }
138 // return *MVllMap.at(key);
139  return getM<MVll>(MVllMap, meson_i, vector_i, lep_i);
140 }
141 
142 MVgamma& Flavour::getMVgamma(QCD::meson meson_i, QCD::meson vector_i) const
143 {
144 // std::reference_wrapper<std::shared_ptr<MVgamma> > x(MVgamma_BdKstgamma);
145 // if (meson_i == StandardModel::B_D && vector_i == StandardModel::K_star) x = std::ref(MVgamma_BdKstgamma);
146 // else if (meson_i == StandardModel::B_P && vector_i == StandardModel::K_star_P) x = std::ref(MVgamma_BpKstgamma);
147 // else if (meson_i == StandardModel::B_S && vector_i == StandardModel::PHI) x = std::ref(MVgamma_Bsphigamma);
148 // else throw std::runtime_error("Flavour: Decay channel not implemented.");
149 // return *getPtr<MVgamma>(x.get(), meson_i, vector_i);
150 // std::vector<int> key({meson_i, vector_i});
151 // if(MVgammaMap.find(key)==MVgammaMap.end()) {
152 // MVgammaMap.insert(std::make_pair(key,std::shared_ptr<MVgamma>(new MVgamma(mySM,meson_i, vector_i))));
153 // }
154 // return *MVgammaMap.at(key);
155  return getM<MVgamma>(MVgammaMap, meson_i, vector_i);
156 }
157 
158 MVlnu& Flavour::getMVlnu(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
159 {
160 // std::reference_wrapper<std::shared_ptr<MVlnu> > x(MVlnu_BdbarDstartaunu);
161 // if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_star_P && lep_i == StandardModel::TAU) x = std::ref(MVlnu_BdbarDstartaunu);
162 // else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_star_P && lep_i == StandardModel::MU) x = std::ref(MVlnu_BdbarDstarmunu);
163 // else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_star_P && lep_i == StandardModel::ELECTRON) x = std::ref(MVlnu_BdbarDstarelnu);
164 // else throw std::runtime_error("Flavour: Decay channel not implemented.");
165 // return *getPtr<MVlnu>(x.get(), meson_i, vector_i, lep_i);
166 // std::vector<int> key({meson_i, vector_i, lep_i});
167 // if(MVlnuMap.find(key)==MVlnuMap.end()) {
168 // MVlnuMap.insert(std::make_pair(key,std::shared_ptr<MVlnu>(new MVlnu(mySM,meson_i, vector_i, lep_i))));
169 // }
170 // return *MVlnuMap.at(key);
171  return getM<MVlnu>(MVlnuMap, meson_i, vector_i, lep_i);
172 
173 }
174 
175 MPlnu& Flavour::getMPlnu(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
176 {
177 // std::reference_wrapper<std::shared_ptr<MPlnu> > x(MPlnu_BdbarDtaunu);
178 // if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_P && lep_i == StandardModel::TAU) x = std::ref(MPlnu_BdbarDtaunu);
179 // else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_P && lep_i == StandardModel::MU) x = std::ref(MPlnu_BdbarDmunu);
180 // else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_P && lep_i == StandardModel::ELECTRON) x = std::ref(MPlnu_BdbarDelnu);
181 // else throw std::runtime_error("Flavour: Decay channel not implemented.");
182 // return *getPtr<MPlnu>(x.get(), meson_i, vector_i, lep_i);
183 // std::vector<int> key({meson_i, vector_i, lep_i});
184 // if(MPlnuMap.find(key)==MPlnuMap.end()) {
185 // MPlnuMap.insert(std::make_pair(key,std::shared_ptr<MPlnu>(new MPlnu(mySM,meson_i, vector_i, lep_i))));
186 // }
187 // return *MPlnuMap.at(key);
188  return getM<MPlnu>(MPlnuMap, meson_i, vector_i, lep_i);
189 }
190 
191 MPll& Flavour::getMPll(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
192 {
193 // std::reference_wrapper<std::shared_ptr<MPll> > x(MPll_BpKmu);
194 // if (meson_i == QCD::B_P && pseudoscalar_i == QCD::K_P && lep_i == QCD::MU) x = std::ref(MPll_BpKmu);
195 // else if (meson_i == QCD::B_P && pseudoscalar_i == QCD::K_P && lep_i == QCD::ELECTRON) x = std::ref(MPll_BpKel);
196 // else if (meson_i == QCD::B_D && pseudoscalar_i == QCD::K_0 && lep_i == QCD::MU) x = std::ref(MPll_B0Kmu);
197 // else if (meson_i == QCD::B_D && pseudoscalar_i == QCD::K_0 && lep_i == QCD::ELECTRON) x = std::ref(MPll_B0Kel);
198 // else throw std::runtime_error("Flavour: Decay channel not implemented.");
199 // return *getPtr<MPll>(x.get(), meson_i, pseudoscalar_i, lep_i);
200 // std::vector<int> key({meson_i, vector_i, lep_i});
201 // if(MPllMap.find(key)==MPllMap.end()) {
202 // MPllMap.insert(std::make_pair(key,std::shared_ptr<MPll>(new MPll(mySM,meson_i, vector_i, lep_i))));
203 // }
204 // return *MPllMap.at(key);
205  return getM<MPll>(MPllMap, meson_i, vector_i, lep_i);
206 }
207 
208 template <typename T, typename... Args>
209 T& Flavour::getM(std::map<std::vector<int>,std::shared_ptr<T> >& map, Args ... args) const
210 {
211  std::vector<int> key({args...});
212  if(map.find(key)==map.end()) {
213  map.insert(std::make_pair(key,std::shared_ptr<T>(new T(mySM,args...))));
214  }
215  return *map.at(key);
216 }
217 
218 void Flavour::setUpdateFlag(QCD::meson meson_i, QCD::meson meson_j, QCD::lepton lep_i, bool updated_i) const
219 {
220 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::MU) update_BdKstarmu = updated_i;
221 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::ELECTRON) update_BdKstarel = updated_i;
222 // else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::MU) update_BpKstarmu = updated_i;
223 // else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::ELECTRON) update_BpKstarel = updated_i;
224 // else if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::MU) update_Bsphimu = updated_i;
225 // else if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::ELECTRON) update_Bsphiel = updated_i;
226 // else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::MU) update_BpKmu = updated_i;
227 // else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::ELECTRON) update_BpKel = updated_i;
228 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::MU) update_B0Kmu = updated_i;
229 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::ELECTRON) update_B0Kel = updated_i;
230 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::NOLEPTON) update_BdKstgamma = updated_i;
231 // else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::NOLEPTON) update_BpKstgamma = updated_i;
232 // else if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::NOLEPTON) update_Bsphigamma = updated_i;
233 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::TAU) update_BdDstartaunu = updated_i;
234 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::MU) update_BdDstarmunu = updated_i;
235 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::ELECTRON) update_BdDstarelnu = updated_i;
236 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::TAU) update_BdDtaunu = updated_i;
237 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::MU) update_BdDmunu = updated_i;
238 // else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::ELECTRON) update_BdDelnu = updated_i;
239 // else throw std::runtime_error("Flavour: Wrong update flag requested.");
240  flagUpdateMap[std::vector<int>({meson_i, meson_j, lep_i})] = updated_i;
241 }
242 
243 bool Flavour::getUpdateFlag(QCD::meson meson_i, QCD::meson meson_j, QCD::lepton lep_i) const
244 {
245 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::MU) return update_BdKstarmu;
246 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::ELECTRON) return update_BdKstarel;
247 // if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::MU) return update_BpKstarmu;
248 // if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::ELECTRON) return update_BpKstarel;
249 // if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::MU) return update_Bsphimu;
250 // if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::ELECTRON) return update_Bsphiel;
251 // if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::MU) return update_BpKmu;
252 // if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::ELECTRON) return update_BpKel;
253 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::MU) return update_B0Kmu;
254 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::ELECTRON) return update_B0Kel;
255 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::NOLEPTON) return update_BdKstgamma;
256 // if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::NOLEPTON) return update_BpKstgamma;
257 // if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::NOLEPTON) return update_Bsphigamma;
258 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::TAU) return update_BdDstartaunu;
259 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::MU) return update_BdDstarmunu;
260 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::ELECTRON) return update_BdDstarelnu;
261 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::TAU) return update_BdDtaunu;
262 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::MU) return update_BdDmunu;
263 // if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::ELECTRON) return update_BdDelnu;
264 // else throw std::runtime_error("Flavour: Wrong update flags requested.");
265 //
266  std::vector<int> key({meson_i, meson_j, lep_i});
267  if(flagUpdateMap.find(key)==flagUpdateMap.end()) {
268  // Default value
269  flagUpdateMap[key]=true;
270  }
271  return flagUpdateMap.at(key);
272 }
273 
274 template<typename T, typename... Args> std::shared_ptr<T>& Flavour::getPtr(std::shared_ptr<T>& x, Args ... args) const
275 {
276  if (x.get() == nullptr)
277  x.reset(new T(mySM, args...));
278  return x;
279 }
280 
281 void Flavour::setSMupdated() const
282 {
283  for(auto &x : flagUpdateMap) x.second = true;
284 }
HeffDB1
Definition: HeffDB1.h:20
Flavour::setFlagCLN
bool setFlagCLN(bool CLNflag)
Definition: Flavour.h:232
Flavour::getM
T & getM(std::map< std::vector< int >, std::shared_ptr< T > > &map, Args ... args) const
Definition: Flavour.cpp:209
Flavour::MPllMap
std::map< std::vector< int >, std::shared_ptr< MPll > > MPllMap
Definition: Flavour.h:266
MVgamma.h
Flavour::CLNflag
bool CLNflag
Definition: Flavour.h:271
Flavour::dispersion
bool dispersion
Definition: Flavour.h:270
MPll.h
Flavour::MVlnuMap
std::map< std::vector< int >, std::shared_ptr< MVlnu > > MVlnuMap
Definition: Flavour.h:264
Flavour::ComputeCoeffsmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumu(double mu, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:78
Flavour::ComputeCoeffK
gslpp::vector< gslpp::complex > ** ComputeCoeffK(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:68
HeffDF2
A class for the effective Hamiltonian.
Definition: HeffDF2.h:28
StandardModel.h
Flavour::getMPll
MPll & getMPll(QCD::meson meson_i, QCD::meson pseudoscalar_i, QCD::lepton lep_i) const
Returns the initial and final state dependent object for .
Definition: Flavour.cpp:191
Flavour::setUpdateFlag
void setUpdateFlag(QCD::meson meson_i, QCD::meson meson_j, QCD::lepton lep_i, bool updated_i) const
sets the update flag for the initial and final state dependent object for .
Definition: Flavour.cpp:218
Flavour::getUpdateFlag
bool getUpdateFlag(QCD::meson meson_i, QCD::meson meson_j, QCD::lepton lep_i) const
gets the update flag for the initial and final state dependent object for .
Definition: Flavour.cpp:243
Flavour::ComputeCoeffBs
gslpp::vector< gslpp::complex > ** ComputeCoeffBs(double mu, schemes scheme=NDR, bool SM=false) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:58
Flavour::ComputeCoeffmK
gslpp::vector< gslpp::complex > ** ComputeCoeffmK(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:73
Flavour::ComputeCoeffdmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffdmumu(double mu, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:83
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:474
Flavour::MPlnuMap
std::map< std::vector< int >, std::shared_ptr< MPlnu > > MPlnuMap
Definition: Flavour.h:267
Flavour::ComputeCoeffdnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffdnunu() const
Definition: Flavour.cpp:98
Flavour::ComputeCoeffdd
gslpp::vector< gslpp::complex > ** ComputeCoeffdd(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:63
MVll.h
Flavour::HDF2
std::shared_ptr< HeffDF2 > HDF2
An Object for the Hamiltonian of the processes.
Definition: Flavour.h:261
Flavour::getMPlnu
MPlnu & getMPlnu(QCD::meson meson_i, QCD::meson pseudoscalar_i, QCD::lepton lep_i) const
Returns the initial and final state dependent object for .
Definition: Flavour.cpp:175
Flavour::getHDF2
HeffDF2 & getHDF2() const
The member that returns an object of the class HeffDF2.
Definition: Flavour.cpp:43
Flavour::setFlagUseDispersionRelation
bool setFlagUseDispersionRelation(bool dispersion)
Definition: Flavour.h:227
schemes
schemes
An enum type for regularization schemes.
Definition: OrderScheme.h:19
Flavour.h
QCD::meson
meson
An enum type for mesons.
Definition: QCD.h:336
Flavour::getMVgamma
MVgamma & getMVgamma(QCD::meson meson_i, QCD::meson vector_i) const
Returns the initial and final state dependent object for .
Definition: Flavour.cpp:142
HeffDB1.h
MPlnu.h
Flavour::flagUpdateMap
std::map< std::vector< int >, bool > flagUpdateMap
Definition: Flavour.h:268
Flavour::getMVlnu
MVlnu & getMVlnu(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
Returns the initial and final state dependent object for .
Definition: Flavour.cpp:158
HeffDF2.h
MPlnu
Definition: MPlnu.h:21
Flavour::getPtr
std::shared_ptr< T > & getPtr(std::shared_ptr< T > &x, Args... args) const
Flavour::MVllMap
std::map< std::vector< int >, std::shared_ptr< MVll > > MVllMap
Definition: Flavour.h:263
Flavour::mySM
const StandardModel & mySM
Definition: Flavour.h:260
Flavour::ComputeCoeffsnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffsnunu() const
Definition: Flavour.cpp:93
MVlnu.h
Flavour::setSMupdated
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:281
Flavour::setFlag
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:26
Flavour::ComputeCoeffBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffBMll(double mu, QCD::lepton lepton, bool noSM=false, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:113
MVgamma
A class for the decay.
Definition: MVgamma.h:144
Flavour::ComputeCoeffBd
gslpp::vector< gslpp::complex > ** ComputeCoeffBd(double mu, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:53
Flavour::Flavour
Flavour(const StandardModel &SM_i)
The constructor.
Definition: Flavour.cpp:19
Flavour::ComputeCoeffsgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma(double mu, bool noSM=false, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:103
MVlnu
Definition: MVlnu.h:16
MVll
A class for the decay.
Definition: MVll.h:308
Flavour::ComputeCoeffprimesgamma
gslpp::vector< gslpp::complex > ** ComputeCoeffprimesgamma(double mu, schemes scheme=NDR) const
Computes the chirality flipped Wilson coefficient for the process .
Definition: Flavour.cpp:108
MPll
A class for the decay.
Definition: MPll.h:172
Flavour::ComputeCoeffprimeBMll
gslpp::vector< gslpp::complex > ** ComputeCoeffprimeBMll(double mu, QCD::lepton lepton, schemes scheme=NDR) const
Computes the chirality flipped Wilson coefficient for the process .
Definition: Flavour.cpp:118
Flavour::setFlagFixedWCbtos
bool setFlagFixedWCbtos(bool FixedWCbtosflag)
Definition: Flavour.h:237
Flavour::MVgammaMap
std::map< std::vector< int >, std::shared_ptr< MVgamma > > MVgammaMap
Definition: Flavour.h:265
Flavour::HDB1
std::shared_ptr< HeffDB1 > HDB1
An Object for the Hamiltonian of the processes.
Definition: Flavour.h:262
Flavour::getMVll
MVll & getMVll(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
Returns the initial and final state dependent object for .
Definition: Flavour.cpp:123
Flavour::ComputeCoeffbtaunu
gslpp::vector< gslpp::complex > ** ComputeCoeffbtaunu(QCD::meson meson_i) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:88
gslpp::vector< gslpp::complex >
Flavour::getHDB1
HeffDB1 & getHDB1() const
The member that returns an object of the class HeffDB1.
Definition: Flavour.cpp:48
QCD::lepton
lepton
An enum type for leptons.
Definition: QCD.h:310