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