a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
MVgamma.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2014 HEPfit Collaboration
3  *
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "Flavour.h"
9 #include "MVgamma.h"
10 #include "StandardModel.h"
11 #include "std_make_vector.h"
12 #include "gslpp_function_adapter.h"
13 #include "F_1.h"
14 #include "F_2.h"
15 #include "AmpDB2.h"
16 #include <boost/bind.hpp>
17 #include <limits>
18 #include <gsl/gsl_sf_zeta.h>
19 #include <gsl/gsl_sf_gegenbauer.h>
20 
21 MVgamma::MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
22 : SM(SM_i), myF_1(new F_1()), myF_2(new F_2())
23 {
24  meson = meson_i;
25  vectorM = vector_i;
26  dispersion = false;
27  FixedWCbtos = false;
28  mJ2 = 3.096*3.096;
29 
30  w_GSL = gsl_integration_cquad_workspace_alloc (100);
31 }
32 
33 MVgamma::~MVgamma()
34 {}
35 
36 std::vector<std::string> MVgamma::initializeMVgammaParameters()
37 {
38  dispersion = SM.getFlavour().getFlagUseDispersionRelation();
39  FixedWCbtos = SM.getFlavour().getFlagFixedWCbtos();
40 
41 #if NFPOLARBASIS_MVGAMMA
42  if (vectorM == StandardModel::PHI) mVgammaParameters = make_vector<std::string>() <<
43  "a_0T1phi" << "a_0A1phi" << "a_0Vphi" <<
44  "absh_p" << "absh_m" << "argh_p" << "argh_m" << "SU3_breaking_abs" << "SU3_breaking_arg";
45  else if (vectorM == StandardModel::K_star || vectorM == StandardModel::K_star_P)
46  mVgammaParameters = make_vector<std::string>() << "a_0T1" << "a_0A1" << "a_0V" <<
47  "absh_p" << "absh_m" << "argh_p" << "argh_m";
48  else if (vectorM == StandardModel::RHO || vectorM == StandardModel::RHO_P)
49  mVgammaParameters = make_vector<std::string>() << "a_0T1rho" << "a_0A1rho" << "a_0Vrho" <<
50  "absh_p" << "absh_m" << "argh_p" << "argh_m";
51  else if (vectorM == StandardModel::OMEGA)
52  mVgammaParameters = make_vector<std::string>() << "a_0T1omega" << "a_0A1omega" << "a_0Vomega" <<
53  "absh_p" << "absh_m" << "argh_p" << "argh_m";
54 #else
55  if (vectorM == StandardModel::PHI) mVgammaParameters = make_vector<std::string>() <<
56  "a_0T1phi" << "a_0A1phi" << "a_0Vphi" <<
57  "reh_p" << "reh_m" << "imh_p" << "imh_m" << "SU3_breaking_abs" << "SU3_breaking_arg";
58  else if (vectorM == StandardModel::K_star || vectorM == StandardModel::K_star_P)
59  mVgammaParameters = make_vector<std::string>() << "a_0T1" << "a_0A1" << "a_0V" <<
60  "reh_p" << "reh_m" << "imh_p" << "imh_m";
61  else if (vectorM == StandardModel::RHO || vectorM == StandardModel::RHO_P)
62  mVgammaParameters = make_vector<std::string>() << "a_0T1rho" << "a_0A1rho" << "a_0Vrho" <<
63  "reh_p" << "reh_m" << "imh_p" << "imh_m";
64  else if (vectorM == StandardModel::OMEGA)
65  mVgammaParameters = make_vector<std::string>() << "a_0T1omega" << "a_0A1omega" << "a_0Vomega" <<
66  "reh_p" << "reh_m" << "imh_p" << "imh_m";
67 #endif
68  else {
69  std::stringstream out;
70  out << vectorM;
71  throw std::runtime_error("MVgamma: vector " + out.str() + " not implemented");
72  }
73 
74  if (dispersion) {
75  mVgammaParameters.clear();
76  if (vectorM == StandardModel::PHI) mVgammaParameters = make_vector<std::string>() <<
77  "a_0T1phi" << "a_0A1phi" << "a_0Vphi" <<
78  "r1_1" << "r2_1" << "deltaC9_1" << "phDC9_1" << "r1_2" << "r2_2" << "deltaC9_2" << "phDC9_2" << "SU3_breaking_abs" << "SU3_breaking_arg";
79  else if (vectorM == StandardModel::K_star || vectorM == StandardModel::K_star_P)
80  mVgammaParameters = make_vector<std::string>() << "a_0T1" << "a_0A1" << "a_0V" <<
81  "r1_1" << "r2_1" << "deltaC9_1" << "phDC9_1" << "r1_2" << "r2_2" << "deltaC9_2" << "phDC9_2";
82  else if (vectorM == StandardModel::RHO || vectorM == StandardModel::RHO_P)
83  mVgammaParameters = make_vector<std::string>() << "a_0T1rho" << "a_0A1rho" << "a_0Vrho" <<
84  "r1_1" << "r2_1" << "deltaC9_1" << "phDC9_1" << "r1_2" << "r2_2" << "deltaC9_2" << "phDC9_2";
85  else if (vectorM == StandardModel::OMEGA)
86  mVgammaParameters = make_vector<std::string>() << "a_0T1omega" << "a_0A1omega" << "a_0Vomega" <<
87  "r1_1" << "r2_1" << "deltaC9_1" << "phDC9_1" << "r1_2" << "r2_2" << "deltaC9_2" << "phDC9_2";
88  else {
89  std::stringstream out;
90  out << vectorM;
91  throw std::runtime_error("MVgamma: vector " + out.str() + " not implemented");
92  }
93  }
94 
95  if (FixedWCbtos) mVgammaParameters.push_back("C7_SM" );
96 
97  SM.initializeMeson(meson);
98  SM.initializeMeson(vectorM);
99  return mVgammaParameters;
100 }
101 
102 void MVgamma::updateParameters()
103 {
104  if (!SM.getFlavour().getUpdateFlag(meson, vectorM, QCD::NOLEPTON)) return;
105 
106  GF = SM.getGF();
107  ale = SM.getAle();
108  MM = SM.getMesons(meson).getMass();
109  MM2 = MM * MM;
110  MV = SM.getMesons(vectorM).getMass();
111  Mb = SM.getQuarks(QCD::BOTTOM).getMass(); // add the PS b mass
112  mb_pole = SM.Mbar2Mp(Mb); /* Conversion to pole mass*/
113  mc_pole = SM.Mbar2Mp(SM.getQuarks(QCD::CHARM).getMass(),FULLNLO); /* Conversion to pole mass*/
114  Ms = SM.getQuarks(QCD::STRANGE).getMass();
115  MW = SM.Mw();
116  mu_b = SM.getMub();
117  mu_h = sqrt(mu_b * .5); // From Beneke Neubert
118  fB = SM.getMesons(meson).getDecayconst();
119  width = SM.getMesons(meson).computeWidth();
120  lambda = MM2 - pow(MV, 2.);
121  alpha_s_mub = SM.Als(mu_b, FULLNLO); /* Used for QCDF @ NLO */
122 
123  switch (vectorM) {
124  case StandardModel::K_star:
125  a_0T1 = SM.getOptionalParameter("a_0T1");
126  a_0A1 = SM.getOptionalParameter("a_0A1");
127  a_0V = SM.getOptionalParameter("a_0V");
128  lambda_t = SM.getCKM().computelamt_s();
129  lambda_u = SM.getCKM().computelamu_s();
130  spectator_charge = SM.getQuarks(QCD::DOWN).getCharge();
131  SU3_breaking = 1.;
132  break;
133  case StandardModel::K_star_P:
134  a_0T1 = SM.getOptionalParameter("a_0T1");
135  a_0A1 = SM.getOptionalParameter("a_0A1");
136  a_0V = SM.getOptionalParameter("a_0V");
137  lambda_t = SM.getCKM().computelamt_s();
138  lambda_u = SM.getCKM().computelamu_s();
139  spectator_charge = SM.getQuarks(QCD::UP).getCharge();
140  SU3_breaking = 1.;
141  break;
142  case StandardModel::PHI:
143  a_0T1 = SM.getOptionalParameter("a_0T1phi");
144  a_0A1 = SM.getOptionalParameter("a_0A1phi");
145  a_0V = SM.getOptionalParameter("a_0Vphi");
146  lambda_t = SM.getCKM().computelamt_s();
147  lambda_u = SM.getCKM().computelamu_s();
148  spectator_charge = SM.getQuarks(QCD::STRANGE).getCharge();
149  SU3_breaking = gslpp::complex(1. + SM.getOptionalParameter("SU3_breaking_abs"),
150  SM.getOptionalParameter("SU3_breaking_arg"), true);
151  break;
152  case StandardModel::RHO:
153  a_0T1 = SM.getOptionalParameter("a_0T1rho");
154  a_0A1 = SM.getOptionalParameter("a_0A1rho");
155  a_0V = SM.getOptionalParameter("a_0Vrho");
156  lambda_t = SM.getCKM().computelamt_d();
157  lambda_u = SM.getCKM().computelamu_d();
158  spectator_charge = SM.getQuarks(QCD::DOWN).getCharge();
159  SU3_breaking = 1.;
160  break;
161  case StandardModel::RHO_P:
162  a_0T1 = SM.getOptionalParameter("a_0T1rho");
163  a_0A1 = SM.getOptionalParameter("a_0A1rho");
164  a_0V = SM.getOptionalParameter("a_0Vrho");
165  lambda_t = SM.getCKM().computelamt_d();
166  lambda_u = SM.getCKM().computelamu_d();
167  spectator_charge = SM.getQuarks(QCD::UP).getCharge();
168  SU3_breaking = 1.;
169  break;
170  case StandardModel::OMEGA:
171  a_0T1 = SM.getOptionalParameter("a_0T1omega");
172  a_0A1 = SM.getOptionalParameter("a_0A1omega");
173  a_0V = SM.getOptionalParameter("a_0Vomega");
174  lambda_t = SM.getCKM().computelamt_d();
175  lambda_u = SM.getCKM().computelamu_d();
176  spectator_charge = SM.getQuarks(QCD::DOWN).getCharge();
177  SU3_breaking = 1.;
178  break;
179  default:
180  std::stringstream out;
181  out << vectorM;
182  throw std::runtime_error("MVgamma: vector " + out.str() + " not implemented");
183  }
184 
185  fpara = SM.getMesons(vectorM).getDecayconst();
186  fperp = SM.getMesons(vectorM).getDecayconst_p();
187 
188  double ms_over_mb = SM.Mrun(mu_b, SM.getQuarks(QCD::STRANGE).getMass_scale(),
189  SM.getQuarks(QCD::STRANGE).getMass(), FULLNNLO)
190  /SM.Mrun(mu_b, SM.getQuarks(QCD::BOTTOM).getMass_scale(),
191  SM.getQuarks(QCD::BOTTOM).getMass(), FULLNNLO);
192 
193  if (!dispersion) {
194 #if NFPOLARBASIS_MVGAMMA
195  h[0] = gslpp::complex(SM.getOptionalParameter("absh_p"), SM.getOptionalParameter("argh_p"), true); //h_plus
196  h[1] = gslpp::complex(SM.getOptionalParameter("absh_m"), SM.getOptionalParameter("argh_m"), true); //h_minus
197  h[1] *= 2. * (Mb / MM) / (16. * M_PI * M_PI) * (T_1() * lambda / MM2) ;
198  h[0] += ms_over_mb * h[1] ;
199 
200  r1_1 = 0.;
201  r1_2 = 0.;
202  r2_1 = 0.;
203  r2_2 = 0.;
204  deltaC9_1 = 0.;
205  deltaC9_2 = 0.;
206  exp_Phase_1 = 0.;
207  exp_Phase_2 = 0.;
208 #else
209  h[0] = gslpp::complex(SM.getOptionalParameter("reh_p"), SM.getOptionalParameter("imh_p"), false); //h_plus
210  h[1] = gslpp::complex(SM.getOptionalParameter("reh_m"), SM.getOptionalParameter("imh_m"), false); //h_minus
211  h[1] *= 2. * (Mb / MM) / (16. * M_PI * M_PI) * (T_1() * lambda / MM2) ;
212  h[0] += ms_over_mb * h[1] ;
213 
214  r1_1 = 0.;
215  r1_2 = 0.;
216  r2_1 = 0.;
217  r2_2 = 0.;
218  deltaC9_1 = 0.;
219  deltaC9_2 = 0.;
220  exp_Phase_1 = 0.;
221  exp_Phase_2 = 0.;
222 #endif
223  } else {
224  //gslpp::complex DC7_1 = SM.getOptionalParameter("deltaC7_1")*exp(gslpp::complex::i()*SM.getOptionalParameter("phDC7_1"));
225  //gslpp::complex DC7_2 = SM.getOptionalParameter("deltaC7_2")*exp(gslpp::complex::i()*SM.getOptionalParameter("phDC7_2"));
226  //h[0] = (-(2.*Mb)/(MM*16.*M_PI*M_PI) * lambda/(2.*MM2) * T_1()*(DC7_2 - DC7_1)).abs();
227  //h[1] = (-(2.*Mb)/(MM*16.*M_PI*M_PI) * lambda/(2.*MM2) * T_1()*(DC7_2 + DC7_1)).abs();
228  r1_1 = SM.getOptionalParameter("r1_1");
229  r1_2 = SM.getOptionalParameter("r1_2");
230  r2_1 = SM.getOptionalParameter("r2_1");
231  r2_2 = SM.getOptionalParameter("r2_2");
232  deltaC9_1 = SM.getOptionalParameter("deltaC9_1");
233  deltaC9_2 = SM.getOptionalParameter("deltaC9_2");
234  exp_Phase_1 = exp(gslpp::complex::i()*SM.getOptionalParameter("phDC9_1"));
235  exp_Phase_2 = exp(gslpp::complex::i()*SM.getOptionalParameter("phDC9_2"));
236 
237  h[0] = h_lambda(0);
238  h[1] = h_lambda(1);
239  }
240 
241 #if UNIFIEDBTOS
242  allcoeff = SM.getFlavour().ComputeCoeffBMll(mu_b, QCD::MU); //check the mass scale, scheme fixed to NDR. QCD::MU does not make any difference to the WC necessary here.
243  allcoeffprime = SM.getFlavour().ComputeCoeffprimeBMll(mu_b, QCD::MU); //check the mass scale, scheme fixed to NDR. QCD::MU does not make any difference to the WC necessary here.
244 
245  C_1 = (*(allcoeff[LO]))(0) + (*(allcoeff[NLO]))(0);
246  C_2 = (*(allcoeff[LO]))(1) + (*(allcoeff[NLO]))(1);
247  C_3 = (*(allcoeff[LO]))(2) + (*(allcoeff[NLO]))(2);
248  C_4 = (*(allcoeff[LO]))(3) + (*(allcoeff[NLO]))(3);
249  C_5 = (*(allcoeff[LO]))(4) + (*(allcoeff[NLO]))(4);
250  C_6 = (*(allcoeff[LO]))(5) + (*(allcoeff[NLO]))(5);
251  C_8 = (*(allcoeff[LO]))(7) + (*(allcoeff[NLO]))(7);
252 
253  if (FixedWCbtos) {
254  allcoeff_noSM = SM.getFlavour().ComputeCoeffBMll(mu_b, StandardModel::NOLEPTON, true); //check the mass scale, scheme fixed to NDR
255  C_7 = SM.getOptionalParameter("C7_SM") + ((*(allcoeff_noSM[LO]))(6) + (*(allcoeff_noSM[NLO]))(6));
256  }
257  else C_7 = ((*(allcoeff[LO]))(6) + (*(allcoeff[NLO]))(6));
258  C_7p = ms_over_mb * ((*(allcoeffprime[LO]))(6) + (*(allcoeffprime[NLO]))(6));
259 // C_7p -= ms_over_mb * C_7;
260  /* Done in the dirty way to remove from the effective basis since the effective C7p does not involve the non-primed C_1 to C_6.*/
261  C_7p += ms_over_mb * (-C_7 - 1. / 3. * C_3 - 4 / 9 * C_4 - 20. / 3. * C_5 - 80. / 9. * C_6);
262 #else
263  allcoeff = SM.getFlavour().ComputeCoeffsgamma(mu_b);
264  allcoeffprime = SM.getFlavour().ComputeCoeffprimesgamma(mu_b);
265 
266  C_1 = (*(allcoeff[LO]))(0) + (*(allcoeff[NLO]))(0);
267  C_2 = (*(allcoeff[LO]))(1) + (*(allcoeff[NLO]))(1);
268  C_3 = (*(allcoeff[LO]))(2) + (*(allcoeff[NLO]))(2);
269  C_4 = (*(allcoeff[LO]))(3) + (*(allcoeff[NLO]))(3);
270  C_5 = (*(allcoeff[LO]))(4) + (*(allcoeff[NLO]))(4);
271  C_6 = (*(allcoeff[LO]))(5) + (*(allcoeff[NLO]))(5);
272  C_8 = (*(allcoeff[LO]))(7) + (*(allcoeff[NLO]))(7);
273 
274  if (FixedWCbtos) {
275  allcoeff_noSM = SM.getFlavour().ComputeCoeffsgamma(mu_b, true); //check the mass scale, scheme fixed to NDR
276  C_7 = SM.getOptionalParameter("C7_SM") + ((*(allcoeff_noSM[LO]))(6) + (*(allcoeff_noSM[NLO]))(6));
277  }
278  else C_7 = ((*(allcoeff[LO]))(6) + (*(allcoeff[NLO]))(6)););
279  C_7p = (*(allcoeffprime[LO]))(6) + (*(allcoeffprime[NLO]))(6);
280  /* Done in the dirty way to remove from the effective basis since the effective C7p does not involve the non-primed C_1 to C_6.*/
281  C_7p += -ms_over_mb * C_7 - 1. / 3. * C_3 - 4 / 9 * C_4 - 20. / 3. * C_5 - 80. / 9. * C_6;
282 #endif
283  DC7_QCDF = deltaC7_QCDF(false);
284  DC7_QCDF_bar = deltaC7_QCDF(true);
285 
286  gsl_error_handler_t * old_handler = gsl_set_error_handler_off();
287 
288  f_GSL = convertToGslFunction(boost::bind(&MVgamma::getT_perp_integrand_real, &(*this), _1));
289  if (gsl_integration_cquad(&f_GSL, 0., 1., 1.e-2, 1.e-1, w_GSL, &average, &error, NULL) != 0) T_perp_real = std::numeric_limits<double>::quiet_NaN();
290  T_perp_real = average;
291 
292  f_GSL = convertToGslFunction(boost::bind(&MVgamma::getT_perp_integrand_imag, &(*this), _1));
293  if (gsl_integration_cquad(&f_GSL, 0., 1., 1.e-2, 1.e-1, w_GSL, &average, &error, NULL) != 0) T_perp_imag = std::numeric_limits<double>::quiet_NaN();
294  T_perp_imag = average;
295 
296  f_GSL = convertToGslFunction(boost::bind(&MVgamma::getT_perp_bar_integrand_real, &(*this), _1));
297  if (gsl_integration_cquad(&f_GSL, 0., 1., 1.e-2, 1.e-1, w_GSL, &average, &error, NULL) != 0) T_perp_bar_real = std::numeric_limits<double>::quiet_NaN();
298  T_perp_bar_real = average;
299 
300  f_GSL = convertToGslFunction(boost::bind(&MVgamma::getT_perp_bar_integrand_imag, &(*this), _1));
301  if (gsl_integration_cquad(&f_GSL, 0., 1., 1.e-2, 1.e-1, w_GSL, &average, &error, NULL) != 0) T_perp_bar_imag = std::numeric_limits<double>::quiet_NaN();
302  T_perp_bar_imag = average;
303 
304  gsl_set_error_handler(old_handler);
305 
306  SM.getFlavour().setUpdateFlag(meson, vectorM, QCD::NOLEPTON, false);
307 
308 }
309 
310 /*******************************************************************************
311  * Form Factor *
312  * ****************************************************************************/
313 double MVgamma::T_1()
314 {
315  return ( a_0T1);
316 }
317 
318 gslpp::complex MVgamma::deltaC7_QCDF(bool conjugate)
319 {
320  double muh = mu_b/mb_pole;
321  double z = mc_pole*mc_pole/mb_pole/mb_pole;
322 
323 #if FULLNLOQCDF_MVGAMMA
324  gslpp::complex A_Seidel = 1./729. * (833. + 120.*gslpp::complex::i()*M_PI - 312. * log(mb_pole*mb_pole/mu_b/mu_b)); /* hep-ph/0403185v2.*/
325  gslpp::complex Fu_17 = -A_Seidel; /* sign different from hep-ph/0403185v2 but consistent with hep-ph/0412400 */
326  gslpp::complex Fu_27 = 6. * A_Seidel; /* sign different from hep-ph/0403185v2 but consistent with hep-ph/0412400 */
327 #endif
328  gslpp::complex F_17 = myF_1->F_17re(muh, z, 0.00001, 20) + gslpp::complex::i() * myF_1->F_17im(muh, z, 0.00001, 20); /*q^2 = 0 gives nan. Independent of how small q^2 is. arXiv:0810.4077*/
329  gslpp::complex F_27 = myF_2->F_27re(muh, z, 0.00001, 20) + gslpp::complex::i() * myF_2->F_27im(muh, z, 0.00001, 20); /*q^2 = 0 gives nan. Independent of how small q^2 is. arXiv:0810.4077*/
330  gslpp::complex F_87 = (-4.*(33. + 24.*log(muh) + 6.*gslpp::complex::i()*M_PI - 2.*M_PI*M_PI))/27.;
331 
332  if (!conjugate) {
333  gslpp::complex delta = C_1 * F_17 + C_2 * F_27;
334  gslpp::complex delta_t = C_8 * F_87 + delta;
335 #if FULLNLOQCDF_MVGAMMA
336  gslpp::complex delta_u = delta + C_1 * Fu_17 + C_2 * Fu_27;
337  return -alpha_s_mub / (4. * M_PI) * (delta_t - lambda_u / lambda_t * delta_u);
338 #else
339  return -alpha_s_mub / (4. * M_PI) * delta_t;
340 #endif
341  } else {
342  gslpp::complex delta = C_1.conjugate() * F_17 + C_2.conjugate() * F_27;
343  gslpp::complex delta_t = C_8.conjugate() * F_87 + delta;
344 #if FULLNLOQCDF_MVGAMMA
345  gslpp::complex delta_u = delta + C_1.conjugate() * Fu_17 + C_2.conjugate() * Fu_27;
346  return -alpha_s_mub / (4. * M_PI) * (delta_t - (lambda_u / lambda_t).conjugate() * delta_u);
347 #else
348  return -alpha_s_mub / (4. * M_PI) * delta_t;
349 #endif
350  }
351 }
352 
353 gslpp::complex MVgamma::Cq34(bool conjugate)
354 {
355  gslpp::complex T_t = C_3 + 4./3.*(C_4 + 12.*C_5 + 16.*C_6);
356  gslpp::complex T_u = 0.; /* 0 for K*0, phi*/
357  if (meson == QCD::B_P) T_u = -3.*C_2;
358  else if (vectorM == QCD::PHI) T_t = T_t + 6.*(C_3 + 10.*C_5);
359  else if (vectorM == QCD::RHO) T_u = 4./3.*C_1 + C_2;
360  else if (vectorM == QCD::OMEGA) {
361  T_u = -4./3.*C_1 + C_2;
362  T_t = T_t + 6.*2.*(C_3 + 10.*C_5);
363  }
364  if (!conjugate) return T_t + lambda_u / lambda_t * T_u;
365  else return T_t + (lambda_u / lambda_t).conjugate() * T_u;
366 }
367 
368 gslpp::complex MVgamma::T_perp_WA_1()
369 {
370  return -spectator_charge * 4./mb_pole * (C_3 + 4./3.*(C_4 + 3.*C_5 + 4.*C_6));
371 }
372 
373 gslpp::complex MVgamma::T_perp_WA_2(bool conjugate)
374 {
375  return spectator_charge * 2./mb_pole * Cq34(conjugate);
376 }
377 
378 gslpp::complex MVgamma::L1(gslpp::complex x)
379 {
380  if (x == 0.) return -(M_PI*M_PI/6.);
381  if (x == 1.) return 0.;
382  else return log((x-1.)/x)*log(1.-x) - (M_PI*M_PI/6.) + dilog(x/(x-1.));
383 }
384 
385 double MVgamma::phi_V(double u)
386 {
387  return 6.* u * (1. - u) * (1. + SM.getMesons(vectorM).getGegenalpha(0) * gsl_sf_gegenpoly_1(3./2., (2.*u - 1.)) + SM.getMesons(vectorM).getGegenalpha(1) * gsl_sf_gegenpoly_2(3./2., (2.*u - 1.)));
388 }
389 
390 gslpp::complex MVgamma::t_perp(double u, double m)
391 {
392  double ubar = 1. - u;
393  gslpp::complex x0 = sqrt(0.25 - (m*m - gslpp::complex::i()*1.e-10)/(ubar * MM2));
394  gslpp::complex xp = 0.5 + x0;
395  gslpp::complex xm = 0.5 - x0;
396 
397  return 4./ubar * (1. + 2.*(m*m - gslpp::complex::i()*1.e-10)/(ubar*MM2) * (L1(xp) + L1(xm)));
398 }
399 
400 gslpp::complex MVgamma::T_perp_plus_QSS(double u, bool conjugate)
401 {
402  gslpp::complex t_perp_mc = t_perp(u, mc_pole);
403  double eu = 2./3.;
404 #if FULLNLOQCDF_MVGAMMA
405  gslpp::complex t_perp_0 = t_perp(u, 0.);
406  double ed = -1./3.;
407  gslpp::complex T_t = (alpha_s_mub/(3.*M_PI))*MM/(2.*mb_pole)*(eu * t_perp_mc * (-C_1/6. + C_2 + 6.*C_6)
408  + ed * t_perp(u, mb_pole) * (C_3 - C_4/6. + 16.*C_5 + 10.*C_6/3. + 4.*mb_pole/MM*(-C_3 + C_4/6. - 4.*C_5 + 2.*C_6/3.))
409  + ed * t_perp_0 * (-C_3 + C_4/6. - 16.*C_5 + 8.*C_6/3.));
410 
411  gslpp::complex T_u = ((alpha_s_mub/(3.*M_PI))*eu*MM/(2.*mb_pole)*(t_perp_mc - t_perp_0)*(C_2 - C_1/6.));
412  if (!conjugate) return T_t + lambda_u / lambda_t * T_u;
413  else return T_t + (lambda_u / lambda_t).conjugate() * T_u;
414 #else
415  return (alpha_s_mub/(3.*M_PI))*MM/(2.*mb_pole)*(eu * t_perp_mc * (-C_1/6. + C_2 + 6.*C_6));
416 #endif
417 }
418 
419 gslpp::complex MVgamma::T_perp_plus_O8(double u)
420 {
421  return -(alpha_s_mub/(3.*M_PI))*4.*(-1./3.)*C_8/u;
422 }
423 
424 gslpp::complex MVgamma::T_perp(double u, bool conjugate)
425 {
426  double N = M_PI*M_PI/3.*fB*fperp/MM;
427  gslpp::complex T_amp = N/SM.getMesons(meson).getLambdaM() * phi_V(u) * (T_perp_plus_O8(u) + T_perp_plus_QSS(u, conjugate));
428 #if FULLNLOQCDF_MVGAMMA
429  double ubar = 1. - u;
430  T_amp += N * phi_V(u)/ubar * T_perp_WA_1() + N/SM.getMesons(meson).getLambdaM() * fpara/fperp * MV * T_perp_WA_2(conjugate);
431  /*last term proportional to T_perp_WA_2 is a constant but is included in the integral because u is integrated over the range [0,1]*/
432 #endif
433  return T_amp;
434 }
435 
436 gslpp::complex MVgamma::T_QCDF_minus(bool conjugate)
437 {
438  if (!conjugate) return (T_perp_real + gslpp::complex::i() * T_perp_imag);
439  else return (T_perp_bar_real + gslpp::complex::i() * T_perp_bar_imag);
440 }
441 
442 /*******************************************************************************
443  * Helicity amplitudes *
444  * ****************************************************************************/
445 
446 gslpp::complex MVgamma::h_lambda(int hel)
447 {
448  if (hel == 0) {
449  return SU3_breaking * ( -1./(MM2*16.*M_PI*M_PI) * (
450  ((MM+MV)*a_0A1) / (2.*MM) * ((- r1_2 + deltaC9_2) / (1. + r2_2 / mJ2) )*exp_Phase_2
451  - lambda / (2.*MM*(MM+MV))*a_0V * ((- r1_1 + deltaC9_1) / (1. + r2_1 / mJ2) )*exp_Phase_1 ) );
452  }
453  else if (hel == 1) {
454  return SU3_breaking * (-1./(MM2*16.*M_PI*M_PI) *
455  (((MM+MV)*a_0A1) / (2.*MM) * ((- r1_2 + deltaC9_2) / (1. + r2_2 / mJ2) )*exp_Phase_2
456  + lambda / (2.*MM*(MM+MV))*a_0V * ((- r1_1 + deltaC9_1) / (1. + r2_1 / mJ2) )*exp_Phase_1 ) );
457  }
458  else {
459  std::stringstream out;
460  out << hel;
461  throw std::runtime_error("MVgamma: hel " + out.str() + " not implemented, can only be 1 (+) or 2 (-)");
462  }
463 }
464 
465 gslpp::complex MVgamma::H_V_m()
466 {
467  return lambda_t * (((C_7 + DC7_QCDF) * T_1() + MM2/(MM2 - MV*MV) * T_QCDF_minus(false)) * lambda / MM2 - MM / (2. * Mb)*16. * M_PI * M_PI * h[1]);
468 }
469 
470 gslpp::complex MVgamma::H_V_p()
471 {
472  return lambda_t * (-C_7p * T_1() * lambda / MM2 - MM / (2. * Mb)*16. * M_PI * M_PI * h[0]);
473 }
474 
475 gslpp::complex MVgamma::H_V_m_bar()
476 {
477  return lambda_t.conjugate() * (((C_7 + DC7_QCDF_bar) * T_1() + MM2/(MM2 - MV*MV) * T_QCDF_minus(true)) * lambda / MM2 - MM / (2. * Mb)*16. * M_PI * M_PI * h[1]);
478 }
479 
480 gslpp::complex MVgamma::H_V_p_bar()
481 {
482  return lambda_t.conjugate() * (-C_7p * T_1() * lambda / MM2 - MM / (2. * Mb)*16. * M_PI * M_PI * h[0]);
483 }
484 
485 /*******************************************************************************
486  * Observables *
487  * ****************************************************************************/
488 
489 
490 BR_MVgamma::BR_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
491 : ThObservable(SM_i), myAmpDB2(*(new AmpDB2(SM_i)))
492 {
493  meson = meson_i;
494  vectorM = vector_i;
495 
496  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
497 }
498 
499 double BR_MVgamma::computeBR_MVgamma(QCD::meson meson, QCD::meson vector)
500 {
501  QCD::meson meson_i = meson;
502  QCD::meson vector_i = vector;
503 
504  SM.getFlavour().getMVgamma(meson_i, vector_i).updateParameters();
505 
506  gslpp::complex HVm = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_m();
507  gslpp::complex HVm_bar = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_m_bar();
508  gslpp::complex HVp = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_p();
509  gslpp::complex HVp_bar = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_p_bar();
510 
511  switch (vector_i) {
512  case StandardModel::K_star:
513  case StandardModel::K_star_P:
514  case StandardModel::RHO:
515  case StandardModel::RHO_P:
516  case StandardModel::OMEGA:
517  arg = myAmpDB2.getAmpBd(FULLNLO).arg();
518  t_int = 1.;
519  break;
520  case StandardModel::PHI:
521  arg = myAmpDB2.getAmpBs(FULLNLO).arg();
522  /* For correctly defined polarization the numerator should be H_V_p().conjugate()*H_V_p_bar() + H_V_m().conjugate()*H_V_m_bar(). Switched to keep consistency with K*ll.*/
523  /* See discussion around eq.53 in hep-ph/0510104*/
524  ADG = 2.*(exp(gslpp::complex::i()*arg)*(HVp.conjugate()*HVm_bar + HVm.conjugate()*HVp_bar)).real() / (HVp.abs2() + HVm.abs2() + HVp_bar.abs2() + HVm_bar.abs2());
525  ys = SM.getMesons(QCD::B_S).getDgamma_gamma()/2.;
526  t_int = (1. - ADG * ys)/(1. - ys*ys);
527  break;
528  default:
529  std::stringstream out;
530  out << vector_i;
531  throw std::runtime_error("MVgamma: vector " + out.str() + " not implemented");
532  }
533 
534  double GF = SM.getGF();
535  double ale = SM.getAle();
536  double MM = SM.getMesons(meson_i).getMass();
537  double MM2 = MM * MM;
538  double Mb = SM.getQuarks(QCD::BOTTOM).getMass();
539  double MV = SM.getMesons(vector_i).getMass();
540  double width = SM.getMesons(meson_i).computeWidth();
541  double lambda = MM2 - pow(MV, 2.);
542 
543 
544  return ale * pow(GF * Mb / (4 * M_PI * M_PI), 2.) * MM * lambda / (4. * width) * (HVp.abs2() + HVm.abs2() + HVp_bar.abs2() + HVm_bar.abs2()) * t_int;
545 }
546 
547 double BR_MVgamma::computeThValue()
548 {
549  return computeBR_MVgamma(meson, vectorM);
550 }
551 
552 R_MVgamma::R_MVgamma(const StandardModel& SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2)
553 : BR_MVgamma(SM_i, meson_1, vector_1)
554 {
555  meson1 = meson_1;
556  meson2 = meson_2;
557  vector1 = vector_1;
558  vector2 = vector_2;
559 
560  setParametersForObservable(SM.getFlavour().getMVgamma(meson1, vector1).initializeMVgammaParameters());
561  setParametersForObservable(SM.getFlavour().getMVgamma(meson2, vector2).initializeMVgammaParameters());
562 }
563 
564 double R_MVgamma::computeThValue()
565 {
566  return computeBR_MVgamma(meson1, vector1)/computeBR_MVgamma(meson2, vector2);
567 }
568 
569 D0p_MVgamma::D0p_MVgamma(const StandardModel& SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2)
570 : BR_MVgamma(SM_i, meson_1, vector_1)
571 {
572  meson1 = meson_1;
573  meson2 = meson_2;
574  vector1 = vector_1;
575  vector2 = vector_2;
576 
577  setParametersForObservable(SM.getFlavour().getMVgamma(meson1, vector1).initializeMVgammaParameters());
578  setParametersForObservable(SM.getFlavour().getMVgamma(meson2, vector2).initializeMVgammaParameters());
579 }
580 
581 double D0p_MVgamma::computeThValue()
582 {
583  return (computeBR_MVgamma(meson1, vector1) - computeBR_MVgamma(meson2, vector2)) /
584  (computeBR_MVgamma(meson1, vector1) + computeBR_MVgamma(meson2, vector2));
585 }
586 
587 ACP_MVgamma::ACP_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
588 : ThObservable(SM_i)
589 {
590  meson = meson_i;
591  vectorM = vector_i;
592 
593  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
594 }
595 
596 double ACP_MVgamma::computeACP_MVgamma(QCD::meson meson, QCD::meson vector)
597 {
598  QCD::meson meson_i = meson;
599  QCD::meson vector_i = vector;
600 
601  SM.getFlavour().getMVgamma(meson_i, vector_i).updateParameters();
602 
603  gslpp::complex HVm = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_m();
604  gslpp::complex HVm_bar = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_m_bar();
605  gslpp::complex HVp = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_p();
606  gslpp::complex HVp_bar = SM.getFlavour().getMVgamma(meson_i, vector_i).H_V_p_bar();
607  double CC = ((HVp.abs2() + HVm.abs2() - HVp_bar.abs2() - HVm_bar.abs2())) / (HVp.abs2() + HVm.abs2() + HVp_bar.abs2() + HVm_bar.abs2());
608  return -CC;
609 }
610 
611 double ACP_MVgamma::computeThValue()
612 {
613  return computeACP_MVgamma(meson, vectorM);
614 }
615 
616 DACP_MVgamma::DACP_MVgamma(const StandardModel& SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2)
617 : ACP_MVgamma(SM_i, meson_1, vector_1)
618 {
619  meson1 = meson_1;
620  meson2 = meson_2;
621  vector1 = vector_1;
622  vector2 = vector_2;
623 
624  setParametersForObservable(SM.getFlavour().getMVgamma(meson1, vector1).initializeMVgammaParameters());
625  setParametersForObservable(SM.getFlavour().getMVgamma(meson2, vector2).initializeMVgammaParameters());
626 }
627 
628 double DACP_MVgamma::computeThValue()
629 {
630  return (computeACP_MVgamma(meson1, vector1) - computeACP_MVgamma(meson2, vector2));
631 }
632 
633 C_MVgamma::C_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
634 : ThObservable(SM_i)
635 {
636  meson = meson_i;
637  vectorM = vector_i;
638 
639  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
640 }
641 
642 double C_MVgamma::computeThValue()
643 {
644  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
645 
646  gslpp::complex HVm = SM.getFlavour().getMVgamma(meson, vectorM).H_V_m();
647  gslpp::complex HVm_bar = SM.getFlavour().getMVgamma(meson, vectorM).H_V_m_bar();
648  gslpp::complex HVp = SM.getFlavour().getMVgamma(meson, vectorM).H_V_p();
649  gslpp::complex HVp_bar = SM.getFlavour().getMVgamma(meson, vectorM).H_V_p_bar();
650  /* REMEMBER: ACP = -C by definition in neutral B mesons.*/
651  double CC = ((HVp.abs2() + HVm.abs2() - HVp_bar.abs2() - HVm_bar.abs2())) / (HVp.abs2() + HVm.abs2() + HVp_bar.abs2() + HVm_bar.abs2());
652  if (meson == QCD::B_P) return -CC;
653  else return CC;
654 
655 }
656 
657 S_MVgamma::S_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
658 : ThObservable(SM_i), myAmpDB2(*(new AmpDB2(SM_i)))
659 {
660  meson = meson_i;
661  vectorM = vector_i;
662 
663  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
664 }
665 
666 double S_MVgamma::computeThValue()
667 {
668  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
669 
670  gslpp::complex HVm = SM.getFlavour().getMVgamma(meson, vectorM).H_V_m();
671  gslpp::complex HVm_bar = SM.getFlavour().getMVgamma(meson, vectorM).H_V_m_bar();
672  gslpp::complex HVp = SM.getFlavour().getMVgamma(meson, vectorM).H_V_p();
673  gslpp::complex HVp_bar = SM.getFlavour().getMVgamma(meson, vectorM).H_V_p_bar();
674 
675  switch (vectorM) {
676  case StandardModel::K_star:
677  case StandardModel::RHO:
678  arg = myAmpDB2.getAmpBd(FULLNLO).arg();
679  break;
680  case StandardModel::PHI:
681  arg = myAmpDB2.getAmpBs(FULLNLO).arg();
682  break;
683  default:
684  std::stringstream out;
685  out << vectorM;
686  throw std::runtime_error("MVgamma: vector " + out.str() + " not implemented");
687  }
688 
689  /* For correctly defined polarization the numerator should be H_V_p().conjugate()*H_V_p_bar() + H_V_m().conjugate()*H_V_m_bar(). Switched to keep consistency with K*ll.*/
690  /* See discussion around eq.53 in hep-ph/0510104*/
691  return 2.*(exp(gslpp::complex::i()*arg)*(HVp.conjugate()*HVm_bar + HVm.conjugate()*HVp_bar)).imag() / (HVp.abs2() + HVm.abs2() + HVp_bar.abs2() + HVm_bar.abs2());
692 }
693 
694 ADG_MVgamma::ADG_MVgamma(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
695 : ThObservable(SM_i), myAmpDB2(*(new AmpDB2(SM_i)))
696 {
697  meson = meson_i;
698  vectorM = vector_i;
699 
700  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
701 }
702 
703 double ADG_MVgamma::computeThValue()
704 {
705  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
706 
707  gslpp::complex HVm = SM.getFlavour().getMVgamma(meson, vectorM).H_V_m();
708  gslpp::complex HVm_bar = SM.getFlavour().getMVgamma(meson, vectorM).H_V_m_bar();
709  gslpp::complex HVp = SM.getFlavour().getMVgamma(meson, vectorM).H_V_p();
710  gslpp::complex HVp_bar = SM.getFlavour().getMVgamma(meson, vectorM).H_V_p_bar();
711 
712  switch (vectorM) {
713  case StandardModel::K_star:
714  arg = myAmpDB2.getAmpBd(FULLNLO).arg();
715  break;
716  case StandardModel::PHI:
717  arg = myAmpDB2.getAmpBs(FULLNLO).arg();
718  break;
719  default:
720  std::stringstream out;
721  out << vectorM;
722  throw std::runtime_error("MVgamma: vector " + out.str() + " not implemented");
723  }
724 
725  /* For correctly defined polarization the numerator should be H_V_p().conjugate()*H_V_p_bar() + H_V_m().conjugate()*H_V_m_bar(). Switched to keep consistency with K*ll.*/
726  /* See discussion around eq.53 in hep-ph/0510104*/
727  return 2.*(exp(gslpp::complex::i()*arg)*(HVp.conjugate()*HVm_bar + HVm.conjugate()*HVp_bar)).real() / (HVp.abs2() + HVm.abs2() + HVp_bar.abs2() + HVm_bar.abs2());
728 }
729 
730 DC7_1::DC7_1(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
731 : ThObservable(SM_i)
732 {
733  meson = meson_i;
734  vectorM = vector_i;
735 
736  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
737 }
738 
739 double DC7_1::computeThValue()
740 {
741  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
742  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[1] - SM.getFlavour().getMVgamma(meson, vectorM).h[0])).abs();
743 }
744 
745 DC7_2::DC7_2(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
746 : ThObservable(SM_i)
747 {
748  meson = meson_i;
749  vectorM = vector_i;
750 
751  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
752 }
753 
754 double DC7_2::computeThValue()
755 {
756  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
757  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[1] + SM.getFlavour().getMVgamma(meson, vectorM).h[0])).abs();
758 }
759 
760 hp0_hm0::hp0_hm0(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
761 : ThObservable(SM_i)
762 {
763  meson = meson_i;
764  vectorM = vector_i;
765 
766  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
767 }
768 
769 double hp0_hm0::computeThValue()
770 {
771  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
772  return SM.getFlavour().getMVgamma(meson, vectorM).h[0].abs()/SM.getFlavour().getMVgamma(meson, vectorM).h[1].abs();
773 }
774 
775 AbsDC7_L::AbsDC7_L(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
776 : ThObservable(SM_i)
777 {
778  meson = meson_i;
779  vectorM = vector_i;
780 
781  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
782 }
783 
784 double AbsDC7_L::computeThValue()
785 {
786  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
787  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[1])).abs();
788 }
789 
790 AbsDC7_R::AbsDC7_R(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
791 : ThObservable(SM_i)
792 {
793  meson = meson_i;
794  vectorM = vector_i;
795 
796  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
797 }
798 
799 double AbsDC7_R::computeThValue()
800 {
801  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
802  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[0])).abs();
803 }
804 
805 ReDC7_L::ReDC7_L(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
806 : ThObservable(SM_i)
807 {
808  meson = meson_i;
809  vectorM = vector_i;
810 
811  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
812 }
813 
814 double ReDC7_L::computeThValue()
815 {
816  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
817  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[1])).real();
818 }
819 
820 ReDC7_R::ReDC7_R(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
821 : ThObservable(SM_i)
822 {
823  meson = meson_i;
824  vectorM = vector_i;
825 
826  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
827 }
828 
829 double ReDC7_R::computeThValue()
830 {
831  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
832  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[0])).real();
833 }
834 
835 ImDC7_L::ImDC7_L(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
836 : ThObservable(SM_i)
837 {
838  meson = meson_i;
839  vectorM = vector_i;
840 
841  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
842 }
843 
844 double ImDC7_L::computeThValue()
845 {
846  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
847  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[1])).imag();
848 }
849 
850 ImDC7_R::ImDC7_R(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
851 : ThObservable(SM_i)
852 {
853  meson = meson_i;
854  vectorM = vector_i;
855 
856  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
857 }
858 
859 double ImDC7_R::computeThValue()
860 {
861  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
862  return ( (8. * M_PI * M_PI * SM.getFlavour().getMVgamma(meson, vectorM).MM2 * SM.getFlavour().getMVgamma(meson, vectorM).MM) / (SM.getFlavour().getMVgamma(meson, vectorM).lambda * SM.getFlavour().getMVgamma(meson, vectorM).Mb * SM.getFlavour().getMVgamma(meson, vectorM).T_1())*(SM.getFlavour().getMVgamma(meson, vectorM).h[0])).imag();
863 }
864 
865 AbsDC7_QCDF::AbsDC7_QCDF(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
866 : ThObservable(SM_i)
867 {
868  meson = meson_i;
869  vectorM = vector_i;
870 
871  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
872 }
873 
874 double AbsDC7_QCDF::computeThValue()
875 {
876  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
877 
878  double MM = SM.getMesons(meson).getMass();
879  double MM2 = MM * MM;
880  double MV = SM.getMesons(vectorM).getMass();
881  double T1 = SM.getFlavour().getMVgamma(meson, vectorM).T_1();
882 
883  return ( SM.getFlavour().getMVgamma(meson, vectorM).DC7_QCDF + MM2/(MM2 - MV*MV) * SM.getFlavour().getMVgamma(meson, vectorM).T_QCDF_minus(false)/T1 ).abs();
884 }
885 
886 AbsDC7_QCDF_bar::AbsDC7_QCDF_bar(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
887 : ThObservable(SM_i)
888 {
889  meson = meson_i;
890  vectorM = vector_i;
891 
892  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
893 }
894 
895 double AbsDC7_QCDF_bar::computeThValue()
896 {
897  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
898 
899  double MM = SM.getMesons(meson).getMass();
900  double MM2 = MM * MM;
901  double MV = SM.getMesons(vectorM).getMass();
902  double T1 = SM.getFlavour().getMVgamma(meson, vectorM).T_1();
903 
904  return ( SM.getFlavour().getMVgamma(meson, vectorM).DC7_QCDF_bar + MM2/(MM2 - MV*MV) * SM.getFlavour().getMVgamma(meson, vectorM).T_QCDF_minus(true)/T1 ).abs();
905 }
906 
907 ReDC7_QCDF::ReDC7_QCDF(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
908 : ThObservable(SM_i)
909 {
910  meson = meson_i;
911  vectorM = vector_i;
912 
913  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
914 }
915 
916 double ReDC7_QCDF::computeThValue()
917 {
918  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
919 
920  double MM = SM.getMesons(meson).getMass();
921  double MM2 = MM * MM;
922  double MV = SM.getMesons(vectorM).getMass();
923  double T1 = SM.getFlavour().getMVgamma(meson, vectorM).T_1();
924 
925  return ( SM.getFlavour().getMVgamma(meson, vectorM).DC7_QCDF + MM2/(MM2 - MV*MV) * SM.getFlavour().getMVgamma(meson, vectorM).T_QCDF_minus(false)/T1 ).real();
926 }
927 
928 ReDC7_QCDF_bar::ReDC7_QCDF_bar(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
929 : ThObservable(SM_i)
930 {
931  meson = meson_i;
932  vectorM = vector_i;
933 
934  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
935 }
936 
937 double ReDC7_QCDF_bar::computeThValue()
938 {
939  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
940 
941  double MM = SM.getMesons(meson).getMass();
942  double MM2 = MM * MM;
943  double MV = SM.getMesons(vectorM).getMass();
944  double T1 = SM.getFlavour().getMVgamma(meson, vectorM).T_1();
945 
946  return ( SM.getFlavour().getMVgamma(meson, vectorM).DC7_QCDF_bar + MM2/(MM2 - MV*MV) * SM.getFlavour().getMVgamma(meson, vectorM).T_QCDF_minus(true)/T1 ).real();
947 }
948 
949 ImDC7_QCDF::ImDC7_QCDF(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
950 : ThObservable(SM_i)
951 {
952  meson = meson_i;
953  vectorM = vector_i;
954 
955  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
956 }
957 
958 double ImDC7_QCDF::computeThValue()
959 {
960  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
961 
962  double MM = SM.getMesons(meson).getMass();
963  double MM2 = MM * MM;
964  double MV = SM.getMesons(vectorM).getMass();
965  double T1 = SM.getFlavour().getMVgamma(meson, vectorM).T_1();
966 
967  return ( SM.getFlavour().getMVgamma(meson, vectorM).DC7_QCDF + MM2/(MM2 - MV*MV) * SM.getFlavour().getMVgamma(meson, vectorM).T_QCDF_minus(false)/T1 ).imag();
968 }
969 
970 ImDC7_QCDF_bar::ImDC7_QCDF_bar(const StandardModel& SM_i, QCD::meson meson_i, QCD::meson vector_i)
971 : ThObservable(SM_i)
972 {
973  meson = meson_i;
974  vectorM = vector_i;
975 
976  setParametersForObservable(SM.getFlavour().getMVgamma(meson, vectorM).initializeMVgammaParameters());
977 }
978 
979 double ImDC7_QCDF_bar::computeThValue()
980 {
981  SM.getFlavour().getMVgamma(meson, vectorM).updateParameters();
982 
983  double MM = SM.getMesons(meson).getMass();
984  double MM2 = MM * MM;
985  double MV = SM.getMesons(vectorM).getMass();
986  double T1 = SM.getFlavour().getMVgamma(meson, vectorM).T_1();
987 
988  return ( SM.getFlavour().getMVgamma(meson, vectorM).DC7_QCDF_bar + MM2/(MM2 - MV*MV) * SM.getFlavour().getMVgamma(meson, vectorM).T_QCDF_minus(true)/T1 ).imag();
989 }
AmpDB2
Amplitude Class
Definition: AmpDB2.h:37
DACP_MVgamma::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:625
ADG_MVgamma::myAmpDB2
AmpDB2 & myAmpDB2
Definition: MVgamma.h:713
MVgamma::MV
double MV
Definition: MVgamma.h:176
std_make_vector.h
AbsDC7_QCDF::meson
QCD::meson meson
Definition: MVgamma.h:1059
ReDC7_QCDF_bar::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:934
R_MVgamma::meson2
QCD::meson meson2
Definition: MVgamma.h:480
MVgamma.h
BR_MVgamma::computeBR_MVgamma
double computeBR_MVgamma(QCD::meson meson, QCD::meson vector)
The in .
Definition: MVgamma.cpp:496
AbsDC7_L::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:781
QCD::BOTTOM
Definition: QCD.h:329
QCD::NOLEPTON
Definition: QCD.h:317
AbsDC7_R::meson
QCD::meson meson
Definition: MVgamma.h:885
ReDC7_R::vectorM
QCD::meson vectorM
Definition: MVgamma.h:956
R_MVgamma::meson1
QCD::meson meson1
Definition: MVgamma.h:479
ImDC7_L::meson
QCD::meson meson
Definition: MVgamma.h:989
ThObservable::setParametersForObservable
void setParametersForObservable(std::vector< std::string > parametersForObservable_i)
A set method to get the parameters for the specific observable.
Definition: ThObservable.h:109
QCD::RHO_P
Definition: QCD.h:352
ACP_MVgamma::computeACP_MVgamma
double computeACP_MVgamma(QCD::meson meson, QCD::meson vector)
The parameter of CPV in .
Definition: MVgamma.cpp:593
gslpp::dilog
complex dilog(const complex &z)
Definition: gslpp_complex.cpp:370
AbsDC7_R::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:796
ImDC7_QCDF::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1196
QCD::B_S
Definition: QCD.h:345
ImDC7_QCDF_bar::meson
QCD::meson meson
Definition: MVgamma.h:1229
MVgamma::lambda_u
gslpp::complex lambda_u
Definition: MVgamma.h:189
D0p_MVgamma::meson1
QCD::meson meson1
Definition: MVgamma.h:520
hp0_hm0::hp0_hm0
hp0_hm0(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:757
MVgamma::GF
double GF
Definition: MVgamma.h:172
F_2.h
DC7_1::DC7_1
DC7_1(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:727
ImDC7_QCDF::ImDC7_QCDF
ImDC7_QCDF(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:946
ACP_MVgamma::meson
QCD::meson meson
Definition: MVgamma.h:561
ReDC7_QCDF_bar::ReDC7_QCDF_bar
ReDC7_QCDF_bar(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:925
DACP_MVgamma::DACP_MVgamma
DACP_MVgamma(const StandardModel &SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2)
Constructor.
Definition: MVgamma.cpp:613
ACP_MVgamma::ACP_MVgamma
ACP_MVgamma(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:584
make_vector
Definition: std_make_vector.h:15
MVgamma::r1_1
double r1_1
Definition: MVgamma.h:191
LO
Definition: OrderScheme.h:33
QCD::UP
Definition: QCD.h:324
DC7_2::meson
QCD::meson meson
Definition: MVgamma.h:784
C_MVgamma::C_MVgamma
C_MVgamma(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:630
S_MVgamma::arg
double arg
Definition: MVgamma.h:677
StandardModel.h
F_1.h
hp0_hm0::meson
QCD::meson meson
Definition: MVgamma.h:815
ReDC7_L::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:811
DACP_MVgamma::vector2
QCD::meson vector2
Definition: MVgamma.h:603
QCD::CHARM
Definition: QCD.h:326
gslpp::complex
A class for defining operations on and functions of complex numbers.
Definition: gslpp_complex.h:35
DC7_2::DC7_2
DC7_2(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:742
ACP_MVgamma::computeThValue
double computeThValue()
Definition: MVgamma.cpp:608
gslpp::log
complex log(const complex &z)
Definition: gslpp_complex.cpp:342
S_MVgamma::vectorM
QCD::meson vectorM
Definition: MVgamma.h:675
BR_MVgamma::ADG
double ADG
Definition: MVgamma.h:439
S_MVgamma::S_MVgamma
S_MVgamma(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:654
D0p_MVgamma::D0p_MVgamma
D0p_MVgamma(const StandardModel &SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2)
Constructor.
Definition: MVgamma.cpp:566
BR_MVgamma::myAmpDB2
AmpDB2 & myAmpDB2
Definition: MVgamma.h:437
MVgamma::fB
double fB
Definition: MVgamma.h:185
ACP_MVgamma
A class for the parameter of CPV in decay.
Definition: MVgamma.h:541
AbsDC7_QCDF::AbsDC7_QCDF
AbsDC7_QCDF(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:862
ImDC7_QCDF_bar::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1230
gslpp::complex::abs2
double abs2() const
Definition: gslpp_complex.cpp:86
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:474
MVgamma::deltaC9_1
double deltaC9_1
Definition: MVgamma.h:195
S_MVgamma::meson
QCD::meson meson
Definition: MVgamma.h:674
ImDC7_QCDF_bar::ImDC7_QCDF_bar
ImDC7_QCDF_bar(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:967
ADG_MVgamma::vectorM
QCD::meson vectorM
Definition: MVgamma.h:712
Meson::computeWidth
double computeWidth() const
A method to compute the width of the meson from its lifetime.
Definition: Meson.cpp:479
MVgamma::mu_h
double mu_h
Definition: MVgamma.h:181
BR_MVgamma::vectorM
QCD::meson vectorM
Definition: MVgamma.h:436
MVgamma::fperp
double fperp
Definition: MVgamma.h:183
MVgamma::MW
double MW
Definition: MVgamma.h:187
AbsDC7_QCDF::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1060
D0p_MVgamma::vector2
QCD::meson vector2
Definition: MVgamma.h:523
ReDC7_QCDF::ReDC7_QCDF
ReDC7_QCDF(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:904
hp0_hm0::computeThValue
double computeThValue()
The absolute value of the ratio in .
Definition: MVgamma.cpp:766
BR_MVgamma::BR_MVgamma
BR_MVgamma(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:487
AmpDB2.h
ACP_MVgamma::vectorM
QCD::meson vectorM
Definition: MVgamma.h:562
ReDC7_QCDF_bar::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1162
AmpDB2::getAmpBs
gslpp::complex getAmpBs(orders order)
The value of .
Definition: AmpDB2.h:59
gslpp::complex::conjugate
complex conjugate() const
Definition: gslpp_complex.cpp:288
Particle::getMass
const double & getMass() const
A get method to access the particle mass.
Definition: Particle.h:61
MVgamma::spectator_charge
double spectator_charge
Definition: MVgamma.h:201
ImDC7_L::vectorM
QCD::meson vectorM
Definition: MVgamma.h:990
DACP_MVgamma::meson2
QCD::meson meson2
Definition: MVgamma.h:601
MVgamma::mc_pole
double mc_pole
Definition: MVgamma.h:179
QCD::RHO
Definition: QCD.h:351
QCD::K_star
Definition: QCD.h:348
gslpp::complex::abs
double abs() const
Definition: gslpp_complex.cpp:81
ReDC7_QCDF_bar::meson
QCD::meson meson
Definition: MVgamma.h:1161
ImDC7_QCDF::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:955
ImDC7_R::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1026
Flavour.h
D0p_MVgamma::meson2
QCD::meson meson2
Definition: MVgamma.h:521
QCD::meson
meson
An enum type for mesons.
Definition: QCD.h:336
QCD::B_P
Definition: QCD.h:344
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
gslpp::complex::arg
double arg() const
Definition: gslpp_complex.cpp:76
QCD::OMEGA
Definition: QCD.h:353
F_2
Definition: F_2.h:15
ReDC7_L::meson
QCD::meson meson
Definition: MVgamma.h:919
DC7_2::vectorM
QCD::meson vectorM
Definition: MVgamma.h:785
gslpp::pow
complex pow(const complex &z1, const complex &z2)
Definition: gslpp_complex.cpp:395
StandardModel::getGF
double getGF() const
A get method to retrieve the Fermi constant .
Definition: StandardModel.h:736
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
AbsDC7_QCDF_bar::AbsDC7_QCDF_bar
AbsDC7_QCDF_bar(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:883
QCD::getMesons
Meson getMesons(const QCD::meson m) const
A get method to access a meson as an object of the type Meson.
Definition: QCD.h:524
gslpp::complex::i
static const complex & i()
Definition: gslpp_complex.cpp:154
ImDC7_QCDF::meson
QCD::meson meson
Definition: MVgamma.h:1195
hp0_hm0::vectorM
QCD::meson vectorM
Definition: MVgamma.h:816
BR_MVgamma::arg
double arg
Definition: MVgamma.h:438
ImDC7_R::meson
QCD::meson meson
Definition: MVgamma.h:1025
DC7_1::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:736
MVgamma::mu_b
double mu_b
Definition: MVgamma.h:180
S_MVgamma::myAmpDB2
AmpDB2 & myAmpDB2
Definition: MVgamma.h:676
AbsDC7_R::vectorM
QCD::meson vectorM
Definition: MVgamma.h:886
ReDC7_QCDF::meson
QCD::meson meson
Definition: MVgamma.h:1127
BR_MVgamma::ys
double ys
Definition: MVgamma.h:440
ImDC7_L::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:841
MVgamma::deltaC9_2
double deltaC9_2
Definition: MVgamma.h:196
ReDC7_L::ReDC7_L
ReDC7_L(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:802
gslpp_function_adapter.h
QCD::getQuarks
Particle getQuarks(const QCD::quark q) const
A get method to access a quark as an object of the type Particle.
Definition: QCD.h:534
ThObservable::SM
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
ReDC7_QCDF::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1128
AmpDB2::getAmpBd
gslpp::complex getAmpBd(orders order)
The value of .
Definition: AmpDB2.h:50
MVgamma::r2_1
double r2_1
Definition: MVgamma.h:193
C_MVgamma::computeThValue
double computeThValue()
The parameter of CPV in .
Definition: MVgamma.cpp:639
R_MVgamma::vector1
QCD::meson vector1
Definition: MVgamma.h:481
StandardModel::getFlavour
const Flavour & getFlavour() const
Definition: StandardModel.h:1006
MVgamma::~MVgamma
virtual ~MVgamma()
Destructor.
Definition: MVgamma.cpp:33
ImDC7_R::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:856
ADG_MVgamma::ADG_MVgamma
ADG_MVgamma(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:691
MVgamma::r1_2
double r1_2
Definition: MVgamma.h:192
C_MVgamma::meson
QCD::meson meson
Definition: MVgamma.h:639
AbsDC7_L::vectorM
QCD::meson vectorM
Definition: MVgamma.h:850
MVgamma::fpara
double fpara
Definition: MVgamma.h:184
D0p_MVgamma::vector1
QCD::meson vector1
Definition: MVgamma.h:522
MVgamma::exp_Phase_1
gslpp::complex exp_Phase_1
Definition: MVgamma.h:197
R_MVgamma::R_MVgamma
R_MVgamma(const StandardModel &SM_i, QCD::meson meson_1, QCD::meson vector_1, QCD::meson meson_2, QCD::meson vector_2)
Constructor.
Definition: MVgamma.cpp:549
C_4
Definition: Doxygen/examples-src/myModel/src/myObservables.h:76
MVgamma::updateParameters
void updateParameters()
The update parameter method for MVgamma.
Definition: MVgamma.cpp:102
ReDC7_R::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:826
MVgamma::width
double width
Definition: MVgamma.h:182
F_1
Definition: F_1.h:15
MVgamma::ale
double ale
Definition: MVgamma.h:173
MVgamma::MM
double MM
Definition: MVgamma.h:174
DC7_2::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:751
DACP_MVgamma::meson1
QCD::meson meson1
Definition: MVgamma.h:600
DACP_MVgamma::vector1
QCD::meson vector1
Definition: MVgamma.h:602
MVgamma::Ms
double Ms
Definition: MVgamma.h:186
ThObservable
A class for a model prediction of an observable.
Definition: ThObservable.h:25
QCD::K_star_P
Definition: QCD.h:349
AbsDC7_R::AbsDC7_R
AbsDC7_R(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:787
QCD::STRANGE
Definition: QCD.h:327
AbsDC7_QCDF_bar::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:892
D0p_MVgamma::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:578
ADG_MVgamma::meson
QCD::meson meson
Definition: MVgamma.h:711
QCD::PHI
Definition: QCD.h:347
MVgamma::mb_pole
double mb_pole
Definition: MVgamma.h:178
ADG_MVgamma::computeThValue
double computeThValue()
The parameter for CPV in .
Definition: MVgamma.cpp:700
AbsDC7_QCDF_bar::vectorM
QCD::meson vectorM
Definition: MVgamma.h:1094
MVgamma::MM2
double MM2
Definition: MVgamma.h:175
AbsDC7_QCDF_bar::meson
QCD::meson meson
Definition: MVgamma.h:1093
S_MVgamma::computeThValue
double computeThValue()
The parameter for CPV in .
Definition: MVgamma.cpp:663
ReDC7_R::meson
QCD::meson meson
Definition: MVgamma.h:955
BR_MVgamma
A class for the in decay.
Definition: MVgamma.h:415
ImDC7_R::ImDC7_R
ImDC7_R(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:847
MVgamma::lambda_t
gslpp::complex lambda_t
Definition: MVgamma.h:188
R_MVgamma::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:561
NLO
Definition: OrderScheme.h:34
Meson::getDgamma_gamma
const double & getDgamma_gamma() const
Definition: Meson.h:411
convertToGslFunction
gsl_function convertToGslFunction(const F &f)
Definition: gslpp_function_adapter.h:24
gslpp::exp
complex exp(const complex &z)
Definition: gslpp_complex.cpp:333
BR_MVgamma::meson
QCD::meson meson
Definition: MVgamma.h:435
BR_MVgamma::t_int
double t_int
Definition: MVgamma.h:441
MVgamma::MVgamma
MVgamma(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:21
AbsDC7_L::meson
QCD::meson meson
Definition: MVgamma.h:849
ADG_MVgamma::arg
double arg
Definition: MVgamma.h:714
C_3
Definition: Doxygen/examples-src/myModel/src/myObservables.h:59
MVgamma::initializeMVgammaParameters
std::vector< std::string > initializeMVgammaParameters()
A method for initializing the parameters necessary for MVgamma.
Definition: MVgamma.cpp:36
BR_MVgamma::computeThValue
double computeThValue()
Definition: MVgamma.cpp:544
FULLNNLO
Definition: OrderScheme.h:38
ReDC7_R::ReDC7_R
ReDC7_R(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:817
MVgamma::SU3_breaking
gslpp::complex SU3_breaking
Definition: MVgamma.h:199
ImDC7_L::ImDC7_L
ImDC7_L(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:832
MVgamma::Mb
double Mb
Definition: MVgamma.h:177
QCD::DOWN
Definition: QCD.h:325
MVgamma::exp_Phase_2
gslpp::complex exp_Phase_2
Definition: MVgamma.h:198
MVgamma::h
gslpp::complex h[2]
Definition: MVgamma.h:190
MVgamma::lambda
double lambda
Definition: MVgamma.h:200
ReDC7_QCDF::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:913
FULLNLO
Definition: OrderScheme.h:37
C_MVgamma::vectorM
QCD::meson vectorM
Definition: MVgamma.h:640
StandardModel::getAle
double getAle() const
A get method to retrieve the fine-structure constant .
Definition: StandardModel.h:745
AbsDC7_L::AbsDC7_L
AbsDC7_L(const StandardModel &SM_i, QCD::meson meson_i, QCD::meson vector_i)
Constructor.
Definition: MVgamma.cpp:772
MVgamma::r2_2
double r2_2
Definition: MVgamma.h:194
QCD::MU
Definition: QCD.h:314
R_MVgamma::vector2
QCD::meson vector2
Definition: MVgamma.h:482
AbsDC7_QCDF::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:871
ImDC7_QCDF_bar::computeThValue
double computeThValue()
The in .
Definition: MVgamma.cpp:976
ReDC7_L::vectorM
QCD::meson vectorM
Definition: MVgamma.h:920
DC7_1::meson
QCD::meson meson
Definition: MVgamma.h:748
DC7_1::vectorM
QCD::meson vectorM
Definition: MVgamma.h:749