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 "HeffDF1_diujlknu.h"
15#include "HeffDS1.h"
16#include "HeffDB1.h"
17#include "MVgamma.h"
18#include "MVlnu.h"
19#include "MPlnu.h"
20#include "BClnu.h"
21#include "AmpDB2.h"
22
23Flavour::Flavour(const StandardModel& SM_i)
24: mySM(SM_i)
25{
26 dispersion = false;
27 zExpansion = false;
28 CLNflag = false;
29 BGLflag = false;
30 DMflag = false;
31 FixedWCbtosflag = false;
32 MPll_FNALMILC_flag = false;
33 BXsnunu_LFUNP_flag = false;
34 MPll_GRvDV_flag = false;
35 NeutrinoTree_flag = false;
36};
37
38bool Flavour::setFlag(const std::string name, const bool value)
39{
40
41 if (name.compare("UseDispersionRelation") == 0) {
42 setFlagUseDispersionRelation(value);
43 return true;
44 } else if (name.compare("UsezExpansion") == 0) {
45 setFlagUsezExpansion(value);
46 return true;
47 } else if (name.compare("CLNflag") == 0) {
48 setFlagCLN(value);
49 return true;
50 } else if (name.compare("BGLflag") == 0) {
51 setFlagBGL(value);
52 return true;
53 } else if (name.compare("DMflag") == 0) {
54 setFlagDM(value);
55 return true;
56 } else if (name.compare("FixedWCbtos") == 0) {
57 setFlagFixedWCbtos(value);
58 return true;
59 } else if (name.compare("MPll_FNALMILC_flag") == 0) {
60 setFlagMPll_FNALMILC(value);
61 return true;
62 } else if (name.compare("MPll_GRvDV_flag") == 0) {
63 setFlagMPll_GRvDV(value);
64 return true;
65 } else if (name.compare("MPll_DM_flag") == 0) {
66 setFlagMPll_DM(value);
67 return true;
68 } else if (name.compare("MVll_DM_flag") == 0) {
69 setFlagMVll_DM(value);
70 return true;
71 } else if (name.compare("NeutrinoTree_flag") == 0) {
72 setFlagNeutrinoTree(value);
73 return true;
74 } else if (name.compare("BXsnunu_LFUNP_flag") == 0) {
75 setFlagBXsnunu_LFUNP(value);
76 return true;
77 } else
78 return false;
79}
80
81
82HeffDF2& Flavour::getHDF2() const
83{
84 return *getPtr<HeffDF2>(HDF2);
85}
86
87HeffDF1_diujlknu& Flavour::getHDF1_diujlknu() const
88{
89 return *getPtr<HeffDF1_diujlknu>(HDF1_diujlknu);
90}
91
92HeffDS1& Flavour::getHDS1() const
93{
94 return *getPtr<HeffDS1>(HDS1);
95}
96
97HeffDB1& Flavour::getHDB1() const
98{
99 return *getPtr<HeffDB1>(HDB1);
100}
101
102gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBd(double mu, schemes scheme, bool SM) const
103{
104 return getPtr<HeffDF2>(HDF2)->ComputeCoeffBd(mu, scheme, SM);
105}
106
107gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBs(double mu, schemes scheme, bool SM) const
108{
109 return getPtr<HeffDF2>(HDF2)->ComputeCoeffBs(mu, scheme, SM);
110}
111
112gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdd(double mu, schemes scheme) const
113{
114 return getPtr<HeffDF2>(HDF2)->ComputeCoeffdd(mu, scheme);
115}
116
117gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffK(double mu, schemes scheme) const
118{
119 return getPtr<HeffDF2>(HDF2)->ComputeCoeffK(mu, scheme);
120}
121
122gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffmK(double mu, schemes scheme) const
123{
124 return getPtr<HeffDF2>(HDF2)->ComputeCoeffmK(mu, scheme);
125}
126
127gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffDS1PPv(double mu, schemes scheme) const
128{
129 return getPtr<HeffDS1>(HDS1)->ComputeCoeffDS1PPv(mu, scheme);
130}
131
132gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffDS1PPz(double muc, schemes scheme) const
133{
134 return getPtr<HeffDS1>(HDS1)->ComputeCoeffDS1PPz(muc, scheme);
135}
136
137gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffDS1pnunu() const
138{
139 return getPtr<HeffDS1>(HDS1)->ComputeCoeffDS1pnunu();
140}
141
142gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffDS1pnunuC() const
143{
144 return getPtr<HeffDS1>(HDS1)->ComputeCoeffDS1pnunuC();
145}
146
147gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffDS1mumu() const
148{
149 return getPtr<HeffDS1>(HDS1)->ComputeCoeffDS1mumu();
150}
151
152
153gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdiujlknu(int i, int j, int k, double mu) const
154{
155 return getPtr<HeffDF1_diujlknu>(HDF1_diujlknu)->ComputeCoeffdiujleptonknu(i, j, k, mu);
156}
157
158
159
160gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsmumu(double mu, schemes scheme) const
161{
162 return getPtr<HeffDB1>(HDB1)->ComputeCoeffsmumu(mu, scheme);
163}
164
165gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdmumu(double mu, schemes scheme) const
166{
167 return getPtr<HeffDB1>(HDB1)->ComputeCoeffdmumu(mu, scheme);
168}
169
170gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsnunu(QCD::lepton lepton, bool noSM) const
171{
172 return getPtr<HeffDB1>(HDB1)->ComputeCoeffsnunu(lepton, noSM);
173}
174
175gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffdnunu() const
176{
177 return getPtr<HeffDB1>(HDB1)->ComputeCoeffdnunu();
178}
179
180gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsgamma(double mu, bool noSM, schemes scheme) const
181{
182 return getPtr<HeffDB1>(HDB1)->ComputeCoeffsgamma(mu, noSM, scheme);
183}
184
185gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffsgamma_Buras(double mu, bool noSM, schemes scheme) const
186{
187 return getPtr<HeffDB1>(HDB1)->ComputeCoeffsgamma_Buras(mu, noSM, scheme);
188}
189
190gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffprimesgamma(double mu, schemes scheme) const
191{
192 return getPtr<HeffDB1>(HDB1)->ComputeCoeffprimesgamma(mu, scheme);
193}
194
195gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBMll(double mu, QCD::lepton lepton, bool noSM, schemes scheme) const
196{
197 return getPtr<HeffDB1>(HDB1)->ComputeCoeffBMll(mu, lepton, noSM, scheme);
198}
199
200gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffBMll_Buras(double mu, QCD::lepton lepton, bool noSM, schemes scheme) const
201{
202 return getPtr<HeffDB1>(HDB1)->ComputeCoeffBMll_Buras(mu, lepton, noSM, scheme);
203}
204
205gslpp::vector<gslpp::complex>** Flavour::ComputeCoeffprimeBMll(double mu, QCD::lepton lepton, schemes scheme) const
206{
207 return getPtr<HeffDB1>(HDB1)->ComputeCoeffprimeBMll(mu, lepton, scheme);
208}
209
210MVll& Flavour::getMVll(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
211{
212// std::reference_wrapper<std::shared_ptr<MVll> > x(MVll_BdKstarmu);
213// if (meson_i == StandardModel::B_D && vector_i == StandardModel::K_star && lep_i == StandardModel::MU) x = std::ref(MVll_BdKstarmu);
214// else if (meson_i == StandardModel::B_D && vector_i == StandardModel::K_star && lep_i == StandardModel::ELECTRON) x = std::ref(MVll_BdKstarel);
215// else if (meson_i == StandardModel::B_P && vector_i == StandardModel::K_star_P && lep_i == StandardModel::MU) x = std::ref(MVll_BpKstarmu);
216// else if (meson_i == StandardModel::B_P && vector_i == StandardModel::K_star_P && lep_i == StandardModel::ELECTRON) x = std::ref(MVll_BpKstarel);
217// else if (meson_i == StandardModel::B_S && vector_i == StandardModel::PHI && lep_i == StandardModel::MU) x = std::ref(MVll_Bsphimu);
218// else if (meson_i == StandardModel::B_S && vector_i == StandardModel::PHI && lep_i == StandardModel::ELECTRON) x = std::ref(MVll_Bsphiel);
219// else throw std::runtime_error("Flavour: Decay channel not implemented.");
220// return *getPtr<MVll>(x.get(), meson_i, vector_i, lep_i);
221// std::vector<int> key({meson_i, vector_i, lep_i});
222// if(MVllMap.find(key)==MVllMap.end()) {
223// MVllMap.insert(std::make_pair(key,std::shared_ptr<MVll>(new MVll(mySM,meson_i, vector_i, lep_i))));
224// }
225// return *MVllMap.at(key);
226 return getM<MVll>(MVllMap, meson_i, vector_i, lep_i);
227}
228
229AmpDB2& Flavour::getDB2(int Bmeson_i, bool flag_fixmub, bool flag_RI) const
230{
231 return getM<AmpDB2>(AmpDB2Map, Bmeson_i, flag_fixmub, flag_RI);
232}
233
234MVgamma& Flavour::getMVgamma(QCD::meson meson_i, QCD::meson vector_i) const
235{
236// std::reference_wrapper<std::shared_ptr<MVgamma> > x(MVgamma_BdKstgamma);
237// if (meson_i == StandardModel::B_D && vector_i == StandardModel::K_star) x = std::ref(MVgamma_BdKstgamma);
238// else if (meson_i == StandardModel::B_P && vector_i == StandardModel::K_star_P) x = std::ref(MVgamma_BpKstgamma);
239// else if (meson_i == StandardModel::B_S && vector_i == StandardModel::PHI) x = std::ref(MVgamma_Bsphigamma);
240// else throw std::runtime_error("Flavour: Decay channel not implemented.");
241// return *getPtr<MVgamma>(x.get(), meson_i, vector_i);
242// std::vector<int> key({meson_i, vector_i});
243// if(MVgammaMap.find(key)==MVgammaMap.end()) {
244// MVgammaMap.insert(std::make_pair(key,std::shared_ptr<MVgamma>(new MVgamma(mySM,meson_i, vector_i))));
245// }
246// return *MVgammaMap.at(key);
247 return getM<MVgamma>(MVgammaMap, meson_i, vector_i);
248}
249
250MVlnu& Flavour::getMVlnu(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
251{
252// std::reference_wrapper<std::shared_ptr<MVlnu> > x(MVlnu_BdbarDstartaunu);
253// if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_star_P && lep_i == StandardModel::TAU) x = std::ref(MVlnu_BdbarDstartaunu);
254// else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_star_P && lep_i == StandardModel::MU) x = std::ref(MVlnu_BdbarDstarmunu);
255// else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_star_P && lep_i == StandardModel::ELECTRON) x = std::ref(MVlnu_BdbarDstarelnu);
256// else throw std::runtime_error("Flavour: Decay channel not implemented.");
257// return *getPtr<MVlnu>(x.get(), meson_i, vector_i, lep_i);
258// std::vector<int> key({meson_i, vector_i, lep_i});
259// if(MVlnuMap.find(key)==MVlnuMap.end()) {
260// MVlnuMap.insert(std::make_pair(key,std::shared_ptr<MVlnu>(new MVlnu(mySM,meson_i, vector_i, lep_i))));
261// }
262// return *MVlnuMap.at(key);
263 return getM<MVlnu>(MVlnuMap, meson_i, vector_i, lep_i);
264
265}
266
267MPlnu& Flavour::getMPlnu(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
268{
269// std::reference_wrapper<std::shared_ptr<MPlnu> > x(MPlnu_BdbarDtaunu);
270// if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_P && lep_i == StandardModel::TAU) x = std::ref(MPlnu_BdbarDtaunu);
271// else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_P && lep_i == StandardModel::MU) x = std::ref(MPlnu_BdbarDmunu);
272// else if (meson_i == StandardModel::B_D && vector_i == StandardModel::D_P && lep_i == StandardModel::ELECTRON) x = std::ref(MPlnu_BdbarDelnu);
273// else throw std::runtime_error("Flavour: Decay channel not implemented.");
274// return *getPtr<MPlnu>(x.get(), meson_i, vector_i, lep_i);
275// std::vector<int> key({meson_i, vector_i, lep_i});
276// if(MPlnuMap.find(key)==MPlnuMap.end()) {
277// MPlnuMap.insert(std::make_pair(key,std::shared_ptr<MPlnu>(new MPlnu(mySM,meson_i, vector_i, lep_i))));
278// }
279// return *MPlnuMap.at(key);
280 return getM<MPlnu>(MPlnuMap, meson_i, vector_i, lep_i);
281}
282
283MPll& Flavour::getMPll(QCD::meson meson_i, QCD::meson vector_i, QCD::lepton lep_i) const
284{
285// std::reference_wrapper<std::shared_ptr<MPll> > x(MPll_BpKmu);
286// if (meson_i == QCD::B_P && pseudoscalar_i == QCD::K_P && lep_i == QCD::MU) x = std::ref(MPll_BpKmu);
287// else if (meson_i == QCD::B_P && pseudoscalar_i == QCD::K_P && lep_i == QCD::ELECTRON) x = std::ref(MPll_BpKel);
288// else if (meson_i == QCD::B_D && pseudoscalar_i == QCD::K_0 && lep_i == QCD::MU) x = std::ref(MPll_B0Kmu);
289// else if (meson_i == QCD::B_D && pseudoscalar_i == QCD::K_0 && lep_i == QCD::ELECTRON) x = std::ref(MPll_B0Kel);
290// else throw std::runtime_error("Flavour: Decay channel not implemented.");
291// return *getPtr<MPll>(x.get(), meson_i, pseudoscalar_i, lep_i);
292// std::vector<int> key({meson_i, vector_i, lep_i});
293// if(MPllMap.find(key)==MPllMap.end()) {
294// MPllMap.insert(std::make_pair(key,std::shared_ptr<MPll>(new MPll(mySM,meson_i, vector_i, lep_i))));
295// }
296// return *MPllMap.at(key);
297 return getM<MPll>(MPllMap, meson_i, vector_i, lep_i);
298}
299
300BClnu& Flavour::getBClnu(QCD::meson meson_i) const
301{
302 return getM<BClnu>(BClnuMap, meson_i);
303}
304
305template <typename T, typename... Args>
306T& Flavour::getM(std::map<std::vector<int>,std::shared_ptr<T> >& map, Args ... args) const
307{
308 std::vector<int> key({args...});
309 if(map.find(key)==map.end()) {
310 map.insert(std::make_pair(key,std::make_shared<T>(mySM,args...)));
311 }
312 return *map.at(key);
313}
314
315void Flavour::setUpdateFlag(QCD::meson meson_i, QCD::meson meson_j, QCD::lepton lep_i, bool updated_i) const
316{
317// if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::MU) update_BdKstarmu = updated_i;
318// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::ELECTRON) update_BdKstarel = updated_i;
319// else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::MU) update_BpKstarmu = updated_i;
320// else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::ELECTRON) update_BpKstarel = updated_i;
321// else if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::MU) update_Bsphimu = updated_i;
322// else if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::ELECTRON) update_Bsphiel = updated_i;
323// else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::MU) update_BpKmu = updated_i;
324// else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::ELECTRON) update_BpKel = updated_i;
325// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::MU) update_B0Kmu = updated_i;
326// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::ELECTRON) update_B0Kel = updated_i;
327// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::NOLEPTON) update_BdKstgamma = updated_i;
328// else if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::NOLEPTON) update_BpKstgamma = updated_i;
329// else if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::NOLEPTON) update_Bsphigamma = updated_i;
330// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::TAU) update_BdDstartaunu = updated_i;
331// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::MU) update_BdDstarmunu = updated_i;
332// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::ELECTRON) update_BdDstarelnu = updated_i;
333// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::TAU) update_BdDtaunu = updated_i;
334// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::MU) update_BdDmunu = updated_i;
335// else if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::ELECTRON) update_BdDelnu = updated_i;
336// else throw std::runtime_error("Flavour: Wrong update flag requested.");
337 flagUpdateMap[std::vector<int>({meson_i, meson_j, lep_i})] = updated_i;
338}
339
340bool Flavour::getUpdateFlag(QCD::meson meson_i, QCD::meson meson_j, QCD::lepton lep_i) const
341{
342// if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::MU) return update_BdKstarmu;
343// if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::ELECTRON) return update_BdKstarel;
344// if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::MU) return update_BpKstarmu;
345// if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::ELECTRON) return update_BpKstarel;
346// if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::MU) return update_Bsphimu;
347// if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::ELECTRON) return update_Bsphiel;
348// if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::MU) return update_BpKmu;
349// if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_P && lep_i == StandardModel::ELECTRON) return update_BpKel;
350// if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::MU) return update_B0Kmu;
351// if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_0 && lep_i == StandardModel::ELECTRON) return update_B0Kel;
352// if (meson_i == StandardModel::B_D && meson_j == StandardModel::K_star && lep_i == StandardModel::NOLEPTON) return update_BdKstgamma;
353// if (meson_i == StandardModel::B_P && meson_j == StandardModel::K_star_P && lep_i == StandardModel::NOLEPTON) return update_BpKstgamma;
354// if (meson_i == StandardModel::B_S && meson_j == StandardModel::PHI && lep_i == StandardModel::NOLEPTON) return update_Bsphigamma;
355// if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::TAU) return update_BdDstartaunu;
356// if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::MU) return update_BdDstarmunu;
357// if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_star_P && lep_i == StandardModel::ELECTRON) return update_BdDstarelnu;
358// if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::TAU) return update_BdDtaunu;
359// if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::MU) return update_BdDmunu;
360// if (meson_i == StandardModel::B_D && meson_j == StandardModel::D_P && lep_i == StandardModel::ELECTRON) return update_BdDelnu;
361// else throw std::runtime_error("Flavour: Wrong update flags requested.");
362//
363 std::vector<int> key({meson_i, meson_j, lep_i});
364 if(flagUpdateMap.find(key)==flagUpdateMap.end()) {
365 // Default value
366 flagUpdateMap[key]=true;
367 }
368 return flagUpdateMap.at(key);
369}
370
371template<typename T, typename... Args> std::shared_ptr<T>& Flavour::getPtr(std::shared_ptr<T>& x, Args ... args) const
372{
373 if (x.get() == nullptr){
374 x = std::make_shared<T>(mySM, args...);
375 }
376 return x;
377}
378
379void Flavour::setSMupdated() const
380{
381 for(auto &x : flagUpdateMap) x.second = true;
382}
HeffDF1_diujlknu.h
AmpDB2
Amplitude Class
Definition: AmpDB2.h:37
BClnu
Definition: BClnu.h:12
Flavour::setFlagMPll_FNALMILC
bool setFlagMPll_FNALMILC(bool MPll_FNALMILC_flag)
Definition: Flavour.h:319
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:180
Flavour::flagUpdateMap
std::map< std::vector< int >, bool > flagUpdateMap
Definition: Flavour.h:406
Flavour::BGLflag
bool BGLflag
Definition: Flavour.h:411
Flavour::CLNflag
bool CLNflag
Definition: Flavour.h:410
Flavour::HDB1
std::shared_ptr< HeffDB1 > HDB1
An Object for the Hamiltonian of the processes.
Definition: Flavour.h:397
Flavour::ComputeCoeffsgamma_Buras
gslpp::vector< gslpp::complex > ** ComputeCoeffsgamma_Buras(double mu, bool noSM=false, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:185
Flavour::getDB2
AmpDB2 & getDB2(int BMeson_i, bool flag_fixmub=false, bool flag_RI=false) const
Returns a reference to the meson dependent object for processes.
Definition: Flavour.cpp:229
Flavour::MVllMap
std::map< std::vector< int >, std::shared_ptr< MVll > > MVllMap
Definition: Flavour.h:399
Flavour::ComputeCoeffDS1pnunuC
gslpp::vector< gslpp::complex > ** ComputeCoeffDS1pnunuC() const
Definition: Flavour.cpp:142
Flavour::ComputeCoeffBd
gslpp::vector< gslpp::complex > ** ComputeCoeffBd(double mu, schemes scheme=NDR, bool SM=false) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:102
Flavour::getHDS1
HeffDS1 & getHDS1() const
The member that returns an object of the class HeffDS1.
Definition: Flavour.cpp:92
Flavour::getHDF1_diujlknu
HeffDF1_diujlknu & getHDF1_diujlknu() const
The member that returns an object of the class HeffDF1_diujlknu.
Definition: Flavour.cpp:87
Flavour::MPllMap
std::map< std::vector< int >, std::shared_ptr< MPll > > MPllMap
Definition: Flavour.h:402
Flavour::HDF1_diujlknu
std::shared_ptr< HeffDF1_diujlknu > HDF1_diujlknu
An Object for the Hamiltonian built with operators in the JMS basis, ordered as CnueduVLLkkij,...
Definition: Flavour.h:396
Flavour::ComputeCoeffsnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffsnunu(QCD::lepton lepton=QCD::NOLEPTON, bool noSM=false) const
Definition: Flavour.cpp:170
Flavour::setFlagBXsnunu_LFUNP
bool setFlagBXsnunu_LFUNP(bool BXsnunu_LFUNP_flag) const
Definition: Flavour.h:339
Flavour::setFlagDM
bool setFlagDM(bool DMflag)
Definition: Flavour.h:311
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:250
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:190
Flavour::getHDF2
HeffDF2 & getHDF2() const
The member that returns an object of the class HeffDF2.
Definition: Flavour.cpp:82
Flavour::setFlagNeutrinoTree
bool setFlagNeutrinoTree(bool NeutrinoTree_flag) const
Definition: Flavour.h:335
Flavour::setFlagBGL
bool setFlagBGL(bool BGLflag)
Definition: Flavour.h:307
Flavour::getHDB1
HeffDB1 & getHDB1() const
The member that returns an object of the class HeffDB1.
Definition: Flavour.cpp:97
Flavour::NeutrinoTree_flag
bool NeutrinoTree_flag
Definition: Flavour.h:418
Flavour::ComputeCoeffDS1mumu
gslpp::vector< gslpp::complex > ** ComputeCoeffDS1mumu() const
Definition: Flavour.cpp:147
Flavour::FixedWCbtosflag
bool FixedWCbtosflag
Definition: Flavour.h:413
Flavour::MVlnuMap
std::map< std::vector< int >, std::shared_ptr< MVlnu > > MVlnuMap
Definition: Flavour.h:400
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:107
Flavour::MVgammaMap
std::map< std::vector< int >, std::shared_ptr< MVgamma > > MVgammaMap
Definition: Flavour.h:401
Flavour::ComputeCoeffmK
gslpp::vector< gslpp::complex > ** ComputeCoeffmK(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:122
Flavour::BXsnunu_LFUNP_flag
bool BXsnunu_LFUNP_flag
Definition: Flavour.h:419
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:283
Flavour::MPll_FNALMILC_flag
bool MPll_FNALMILC_flag
Definition: Flavour.h:414
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:315
Flavour::getBClnu
BClnu & getBClnu(QCD::meson meson_i) const
Returns the initial and final state dependent object for .
Definition: Flavour.cpp:300
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:234
Flavour::dispersion
bool dispersion
Definition: Flavour.h:408
Flavour::ComputeCoeffDS1PPv
gslpp::vector< gslpp::complex > ** ComputeCoeffDS1PPv(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:127
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:210
Flavour::setFlagCLN
bool setFlagCLN(bool CLNflag)
Definition: Flavour.h:303
Flavour::setFlagFixedWCbtos
bool setFlagFixedWCbtos(bool FixedWCbtosflag)
Definition: Flavour.h:315
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:205
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:340
Flavour::AmpDB2Map
std::map< std::vector< int >, std::shared_ptr< AmpDB2 > > AmpDB2Map
Definition: Flavour.h:405
Flavour::ComputeCoeffDS1pnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffDS1pnunu() const
Definition: Flavour.cpp:137
Flavour::setFlagMPll_DM
bool setFlagMPll_DM(bool MPll_DM_flag)
Definition: Flavour.h:327
Flavour::ComputeCoeffBMll_Buras
gslpp::vector< gslpp::complex > ** ComputeCoeffBMll_Buras(double mu, QCD::lepton lepton, bool noSM=false, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:200
Flavour::ComputeCoeffK
gslpp::vector< gslpp::complex > ** ComputeCoeffK(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:117
Flavour::HDF2
std::shared_ptr< HeffDF2 > HDF2
An Object for the Hamiltonian of the processes.
Definition: Flavour.h:395
Flavour::ComputeCoeffdmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffdmumu(double mu, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:165
Flavour::setFlagMVll_DM
bool setFlagMVll_DM(bool MVll_DM_flag)
Definition: Flavour.h:331
Flavour::ComputeCoeffdiujlknu
gslpp::vector< gslpp::complex > ** ComputeCoeffdiujlknu(int i, int j, int k, double mu) const
Computes the Wilson coefficient for the Hamiltonian transitions in the JMS basis ordered as CnueduVL...
Definition: Flavour.cpp:153
Flavour::mySM
const StandardModel & mySM
Definition: Flavour.h:394
Flavour::MPll_GRvDV_flag
bool MPll_GRvDV_flag
Definition: Flavour.h:415
Flavour::ComputeCoeffdnunu
gslpp::vector< gslpp::complex > ** ComputeCoeffdnunu() const
Definition: Flavour.cpp:175
Flavour::ComputeCoeffsmumu
gslpp::vector< gslpp::complex > ** ComputeCoeffsmumu(double mu, schemes scheme=NDR) const
Computes the Wilson coefficient for the process .
Definition: Flavour.cpp:160
Flavour::zExpansion
bool zExpansion
Definition: Flavour.h:409
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:195
Flavour::HDS1
std::shared_ptr< HeffDS1 > HDS1
An Object for the Hamiltonian of the processes.
Definition: Flavour.h:398
Flavour::MPlnuMap
std::map< std::vector< int >, std::shared_ptr< MPlnu > > MPlnuMap
Definition: Flavour.h:403
Flavour::BClnuMap
std::map< std::vector< int >, std::shared_ptr< BClnu > > BClnuMap
Definition: Flavour.h:404
Flavour::setSMupdated
void setSMupdated() const
a member used for the caching for .
Definition: Flavour.cpp:379
Flavour::DMflag
bool DMflag
Definition: Flavour.h:412
Flavour::setFlagUseDispersionRelation
bool setFlagUseDispersionRelation(bool dispersion)
Definition: Flavour.h:295
Flavour::setFlagUsezExpansion
bool setFlagUsezExpansion(bool zExpansion)
Definition: Flavour.h:299
Flavour::getM
T & getM(std::map< std::vector< int >, std::shared_ptr< T > > &map, Args ... args) const
Definition: Flavour.cpp:306
Flavour::setFlagMPll_GRvDV
bool setFlagMPll_GRvDV(bool MPll_GRvDV_flag)
Definition: Flavour.h:323
Flavour::ComputeCoeffdd
gslpp::vector< gslpp::complex > ** ComputeCoeffdd(double mu, schemes scheme=NDR) const
Definition: Flavour.cpp:112
Flavour::Flavour
Flavour(const StandardModel &SM_i)
The constructor.
Definition: Flavour.cpp:23
Flavour::getPtr
std::shared_ptr< T > & getPtr(std::shared_ptr< T > &x, Args... args) const
Flavour::ComputeCoeffDS1PPz
gslpp::vector< gslpp::complex > ** ComputeCoeffDS1PPz(double muc, schemes scheme=NDR) const
Definition: Flavour.cpp:132
Flavour::setFlag
bool setFlag(const std::string name, const bool value)
Definition: Flavour.cpp:38
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:267
HeffDF1_diujlknu
Hamiltonian Class for transitions (leptonic and semileptonic charged-current meson decays)
Definition: HeffDF1_diujlknu.h:31
HeffDF2
A class for the effective Hamiltonian.
Definition: HeffDF2.h:28
MPll
A class for the decay.
Definition: MPll.h:173
MPlnu
Definition: MPlnu.h:23
MVgamma
A class for the decay.
Definition: MVgamma.h:143
MVll
A class for the decay.
Definition: MVll.h:308
MVlnu
Definition: MVlnu.h:21
QCD::meson
meson
An enum type for mesons.
Definition: QCD.h:336
QCD::lepton
lepton
An enum type for leptons.
Definition: QCD.h:310
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:521
schemes
schemes
An enum type for regularization schemes.
Definition: OrderScheme.h:20