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