Belle II Software  release-05-01-25
EvtBSemiTauonicHelicityAmplitudeCalculator.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2013 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Koji Hara *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <cmath>
12 #include <string>
13 #include "framework/logging/Logger.h"
14 #include "generators/evtgen/models/EvtBSemiTauonicHelicityAmplitudeCalculator.h"
15 
16 namespace Belle2 {
23  EvtBSemiTauonicHelicityAmplitudeCalculator::EvtBSemiTauonicHelicityAmplitudeCalculator():
24  m_CV1(0), m_CV2(0), m_CS1(0), m_CS2(0), m_CT(0)
25  {
26  m_mB = 5.279; // value used in PRD87,034028
27  m_mD = 1.866; // value used in PRD87,034028
28  m_mDst = 2.009; // value used in PRD87,034028
29 
30  m_rho12 = 1.186; // HFAG end of year 2011
31  m_rhoA12 = 1.207; // HFAG end of year 2011
32 
33  m_ffR11 = 1.403; // HFAG end of year 2011
34  m_ffR21 = 0.854; // HFAG end of year 2011
35 
36  m_aS1 = 1.;
37  m_aR3 = 1.;
38 
39  m_mBottom = 4.20; // PRD77,113016
40  m_mCharm = 0.901; // PRD77,113016 running mass at m_b scale
41 
42  B2INFO("EvtBSemiTauonicHelicityAmplitudeCalculator initialized with the default values.");
43  B2INFO("rho_1^2 : " << m_rho12);
44  B2INFO("rho_A1^22 : " << m_rhoA12);
45  B2INFO("R_1(1) : " << m_ffR11);
46  B2INFO("R_2(1) : " << m_ffR21);
47  B2INFO("a_S1: " << m_aS1);
48  B2INFO("a_R3: " << m_aR3);
49  B2INFO("bottom quark mass: " << m_mBottom);
50  B2INFO("charm quark mass: " << m_mCharm);
51  B2INFO("CV1 : " << m_CV1);
52  B2INFO("CV2 : " << m_CV2);
53  B2INFO("CS1 : " << m_CS1);
54  B2INFO("CS2 : " << m_CS2);
55  B2INFO("CT : " << m_CT);
56  B2INFO("B meson mass: " << m_mB);
57  B2INFO("D meson mass: " << m_mD);
58  B2INFO("D* meson mass: " << m_mDst);
59  }
60 
61  EvtBSemiTauonicHelicityAmplitudeCalculator::EvtBSemiTauonicHelicityAmplitudeCalculator(const double rho12, const double rhoA12,
62  const double ffR11, const double ffR21, const double aS1, const double aR3,
63  const double bottomMass, const double charmMass,
64  const EvtComplex& CV1, const EvtComplex& CV2, const EvtComplex& CS1, const EvtComplex& CS2, const EvtComplex& CT,
65  const double parentMass, const double DMass, const double DstarMass):
66  m_CV1(CV1), m_CV2(CV2), m_CS1(CS1), m_CS2(CS2), m_CT(CT)
67  {
68  m_mB = parentMass;
69  m_mD = DMass;
70  m_mDst = DstarMass;
71  m_mBottom = bottomMass;
72  m_mCharm = charmMass;
73 
74  m_rho12 = rho12;
75  m_rhoA12 = rhoA12;
76 
77  m_ffR11 = ffR11;
78  m_ffR21 = ffR21;
79 
80  m_aS1 = aS1;
81  m_aR3 = aR3;
82 
83  B2INFO("EvtBSemiTauonicHelicityAmplitudeCalculator initialized.");
84  B2INFO("rho_1^2 : " << rho12);
85  B2INFO("rho_A1^2 : " << rhoA12);
86  B2INFO("R_1(1) : " << ffR11);
87  B2INFO("R_2(1) : " << ffR21);
88  B2INFO("a_S1: " << m_aS1);
89  B2INFO("a_R3: " << m_aR3);
90  B2INFO("bottom quark mass: " << m_mBottom);
91  B2INFO("charm quark mass: " << m_mCharm);
92  B2INFO("CV1 : " << m_CV1);
93  B2INFO("CV2 : " << m_CV2);
94  B2INFO("CS1 : " << m_CS1);
95  B2INFO("CS2 : " << m_CS2);
96  B2INFO("CT : " << m_CT);
97  B2INFO("Parent meson mass: " << m_mB);
98  B2INFO("D meson mass: " << m_mD);
99  B2INFO("D* meson mass: " << m_mDst);
100  }
101 
102 // Total amplitude
103  EvtComplex EvtBSemiTauonicHelicityAmplitudeCalculator::helAmp(double mtau, int tauhel, int Dhel, double w, double costau) const
104  {
105  return helAmp(m_CV1, m_CV2, m_CS1, m_CS2, m_CT,
106  mtau, tauhel, Dhel, w, costau);
107  }
108 
109 // Total amplitude
110  EvtComplex EvtBSemiTauonicHelicityAmplitudeCalculator::helAmp(const EvtComplex& CV1, const EvtComplex& CV2, const EvtComplex& CS1,
111  const EvtComplex& CS2, const EvtComplex& CT,
112  double mtau, int tauhel, int Dhel, double w, double costau) const
113  {
114  // sanity check
115  assert(chktauhel(tauhel) && chkDhel(Dhel));
116 
117  return //(GF/sqrt(2))*Vcb* // <-- constants which does not affect the distribution omitted
118  (1.*helampSM(mtau, tauhel, Dhel, w, costau)
119  + CV1 * helampV1(mtau, tauhel, Dhel, w, costau)
120  + CV2 * helampV2(mtau, tauhel, Dhel, w, costau)
121  + CS1 * helampS1(mtau, tauhel, Dhel, w, costau)
122  + CS2 * helampS2(mtau, tauhel, Dhel, w, costau)
123  + CT * helampT(mtau, tauhel, Dhel, w, costau));
124  }
125 
126 // Leptonic Amplitudes //
127 
128 // vector
129  double EvtBSemiTauonicHelicityAmplitudeCalculator::Lep(const double mtau, int tauhel,
130  int whel,
131  double q2, double costau) const
132  {
133  // sanity check
134  assert(chktauhel(tauhel) && chkwhel(whel));
135 
136  if (tauhel == -1 && whel == -1)return sqrt(2.*q2) * v(mtau, q2) * (1. - costau);
137  if (tauhel == -1 && whel == 0) return -2.*sqrt(q2) * v(mtau, q2) * sqrt(1 - costau * costau);
138  if (tauhel == -1 && whel == +1)return sqrt(2.*q2) * v(mtau, q2) * (1. + costau);
139  if (tauhel == -1 && whel == 2) return 0.;
140 
141  if (tauhel == +1 && whel == -1)return -sqrt(2.) * mtau * v(mtau, q2) * sqrt(1. - costau * costau);
142  if (tauhel == +1 && whel == 0) return 2.*mtau * v(mtau, q2) * costau;
143  if (tauhel == +1 && whel == +1)return sqrt(2.) * mtau * v(mtau, q2) * sqrt(1 - costau * costau);
144  if (tauhel == +1 && whel == 2) return -2.*mtau * v(mtau, q2);
145 
146  // should never reach here ...
147  assert(0);
148  return 0.;
149  }
150 
151 // Scalar
152  double EvtBSemiTauonicHelicityAmplitudeCalculator::Lep(const double mtau, int tauhel,
153  double q2, double /*costau*/) const
154  {
155  // sanity check
156  assert(chktauhel(tauhel));
157 
158  if (tauhel == -1)return 0.;
159  if (tauhel == +1)return -2.*sqrt(q2) * v(mtau, q2);
160 
161  // should never reach here ...
162  assert(0);
163  return 0.;
164  }
165 
166 // Tensor
167  double EvtBSemiTauonicHelicityAmplitudeCalculator::Lep(const double mtau, int tauhel,
168  int whel1, int whel2,
169  double q2, double costau) const
170  {
171  // sanity check
172  assert(chktauhel(tauhel) && chkwhel(whel1) && chkwhel(whel2));
173 
174  if (whel1 == whel2)return 0;
175  if (whel1 > whel2)return -Lep(mtau, tauhel, whel2, whel1, q2, costau);
176 
177  if (tauhel == -1 && whel1 == -1 && whel2 == 0) return -sqrt(2.) * mtau * v(mtau, q2) * (1. - costau);
178  if (tauhel == -1 && whel1 == -1 && whel2 == +1) return 2 * mtau * v(mtau, q2) * sqrt(1. - costau * costau);
179  if (tauhel == -1 && whel1 == -1 && whel2 == 2) return Lep(mtau, -1, -1, 0, q2, costau);
180  if (tauhel == -1 && whel1 == 0 && whel2 == +1) return -sqrt(2.) * mtau * v(mtau, q2) * (1. + costau);
181  if (tauhel == -1 && whel1 == 0 && whel2 == 2) return Lep(mtau, -1, -1, +1, q2, costau);
182  if (tauhel == -1 && whel1 == +1 && whel2 == 2) return Lep(mtau, -1, 0, +1, q2, costau);
183 
184  if (tauhel == +1 && whel1 == -1 && whel2 == 0) return sqrt(2.*q2) * v(mtau, q2) * sqrt(1. - costau * costau);
185  if (tauhel == +1 && whel1 == -1 && whel2 == +1) return -2.*sqrt(q2) * v(mtau, q2) * costau;
186  if (tauhel == +1 && whel1 == -1 && whel2 == 2) return Lep(mtau, +1, -1, 0, q2, costau);
187  if (tauhel == +1 && whel1 == 0 && whel2 == +1) return -Lep(mtau, +1, -1, 0, q2, costau);
188  if (tauhel == +1 && whel1 == 0 && whel2 == 2) return Lep(mtau, +1, -1, +1, q2, costau);
189  if (tauhel == +1 && whel1 == +1 && whel2 == 2) return -Lep(mtau, +1, -1, 0, q2, costau);
190 
191  // should never reach here ...
192  assert(0);
193  return 0.;
194  }
195 
196 // Hadronic Amplitudes //
197 
198 // V-A
199  double EvtBSemiTauonicHelicityAmplitudeCalculator::HadV1(int Dhel, int whel, double w) const
200  {
201  // sanity check
202  assert(chkDhel(Dhel) && chkwhel(whel));
203 
204  const double r0 = r(Dhel);
205  if (Dhel == 2 && whel == 0) {
206  return m_mB * sqrt(r0 * (w * w - 1.) / qh2(2, w)) * ((1 + r0) * hp(w) - (1 - r0) * hm(w));
207  }
208  if (Dhel == 2 && whel == 2) {
209  return m_mB * sqrt(r0 / qh2(2, w)) * ((1 - r0) * (w + 1) * hp(w) - (1 + r0) * (w - 1) * hm(w));
210  }
211  if (Dhel == +1 && whel == +1) {
212  return m_mB * sqrt(r0) * ((w + 1) * hA1(w) - sqrt(w * w - 1) * hV(w));
213  }
214  if (Dhel == -1 && whel == -1) {
215  return m_mB * sqrt(r0) * ((w + 1) * hA1(w) + sqrt(w * w - 1) * hV(w));
216  }
217  if (Dhel == 0 && whel == 0) {
218  return m_mB * sqrt(r0 / qh2(0, w)) * (w + 1) *
219  (-(w - r0) * hA1(w) + (w - 1) * (r0 * hA2(w) + hA3(w)));
220  }
221  if (Dhel == 0 && whel == 2) {
222  return m_mB * sqrt(r0 * (w * w - 1) / qh2(0, w)) * (-(w + 1) * hA1(w) + (1 - r0 * w) * hA2(w) + (w - r0) * hA3(w));
223  }
224 
225  // other cases
226  return 0.;
227 
228  }
229 
230 // V+A
231  double EvtBSemiTauonicHelicityAmplitudeCalculator::HadV2(int Dhel, int whel, double w) const
232  {
233  // sanity check
234  assert(chkDhel(Dhel) && chkwhel(whel));
235 
236  if (Dhel == 2) return HadV1(2, whel, w);
237  if (Dhel == +1 && whel == +1)return -HadV1(-1, -1, w);
238  if (Dhel == -1 && whel == -1)return -HadV1(+1, +1, w);
239  if (Dhel == 0) return -HadV1(0, whel, w);
240  return 0;
241  }
242 
243 //S+P
244  double EvtBSemiTauonicHelicityAmplitudeCalculator::HadS1(int Dhel, double w) const
245  {
246  // sanity check
247  assert(chkDhel(Dhel));
248 
249  if (Dhel == 2) return m_mB * sqrt(r(2)) * (w + 1) * hS(w);
250  if (Dhel == 0) return -m_mB * sqrt(r(0)) * sqrt(w * w - 1) * hP(w);
251  return 0.;
252 
253  }
254 
255 // S-P
256  double EvtBSemiTauonicHelicityAmplitudeCalculator::HadS2(int Dhel, double w) const
257  {
258  // sanity check
259  assert(chkDhel(Dhel));
260 
261  if (Dhel == 2) return HadS1(2, w);
262  else return -HadS1(Dhel, w);
263  }
264 
265 // Tensor
266  double EvtBSemiTauonicHelicityAmplitudeCalculator::HadT(int Dhel, int whel1, int whel2, double w) const
267  {
268  // sanity check
269  assert(chkDhel(Dhel) && chkwhel(whel1) && chkwhel(whel2));
270 
271  if (whel1 == whel2)return 0.;
272  if (whel1 > whel2)return -HadT(Dhel, whel2, whel1, w);
273 
274  const double r0 = r(Dhel);
275  if (Dhel == 2 && whel1 == -1 && whel2 == +1)return m_mB * sqrt(r(2)) * sqrt(w * w - 1) * hT(w);
276  if (Dhel == 2 && whel1 == 0 && whel2 == 2) return -HadT(2, -1, +1, w);
277  if (Dhel == -1 && whel1 == -1 && whel2 == 0)
278  return -m_mB * sqrt(r0 / qh2(-1, w)) * (1 - r0 * (w + sqrt(w * w - 1))) *
279  (hT1(w) + hT2(w) + (w - sqrt(w * w - 1)) * (hT1(w) - hT2(w)));
280  if (Dhel == -1 && whel1 == -1 && whel2 == 2) return -HadT(-1, -1, 0, w);
281  if (Dhel == 0 && whel1 == -1 && whel2 == +1)
282  return m_mB * sqrt(r0) * ((w + 1) * hT1(w) + (w - 1) * hT2(w) + 2 * (w * w - 1) * hT3(w));
283  if (Dhel == 0 && whel1 == 0 && whel2 == 2) return -HadT(0, -1, +1, w);
284  if (Dhel == +1 && whel1 == 0 && whel2 == +1)
285  return -m_mB * sqrt(r0 / qh2(+1, w)) * (1 - r0 * (w - sqrt(w * w - 1))) *
286  (hT1(w) + hT2(w) + (w + sqrt(w * w - 1)) * (hT1(w) - hT2(w)));
287 
288  if (Dhel == +1 && whel1 == +1 && whel2 == 2) return -HadT(+1, 0, +1, w);
289 
290  // other cases
291  return 0.;
292  }
293 
294 // Helicity Amplitudes
295 // overall factor GF/sqrt(2) Vcb omitted
296 // Wilson coefficients cXX ommited
297 
298 // SM
299  double EvtBSemiTauonicHelicityAmplitudeCalculator::helampSM(double mtau, int tauhel, int Dhel, double w, double costau) const
300  {
301  double amp(0.);
302  for (int whel = -1; whel <= 2; whel++) {
303  amp += eta(whel) * Lep(mtau, tauhel, whel, q2(Dhel, w), costau)
304  * HadV1(Dhel, whel, w);
305  }
306  return amp;
307  }
308 
309 // V-A
310  double EvtBSemiTauonicHelicityAmplitudeCalculator::helampV1(double mtau, int tauhel, int Dhel, double w, double costau) const
311  {
312  return helampSM(mtau, tauhel, Dhel, w, costau);
313  }
314 
315 // V+A
316  double EvtBSemiTauonicHelicityAmplitudeCalculator::helampV2(double mtau, int tauhel, int Dhel, double w, double costau) const
317  {
318  double amp(0.);
319  for (int whel = -1; whel <= 2; whel++) {
320  amp += eta(whel) * Lep(mtau, tauhel, whel, q2(Dhel, w), costau)
321  * HadV2(Dhel, whel, w);
322  }
323  return amp;
324  }
325 
326 // S+P
327  double EvtBSemiTauonicHelicityAmplitudeCalculator::helampS1(double mtau, int tauhel, int Dhel, double w, double costau) const
328  {
329  return -Lep(mtau, tauhel, q2(Dhel, w), costau) * HadS1(Dhel, w);
330  }
331 
332 // S-P
333  double EvtBSemiTauonicHelicityAmplitudeCalculator::helampS2(double mtau, int tauhel, int Dhel, double w, double costau) const
334  {
335  return -Lep(mtau, tauhel, q2(Dhel, w), costau) * HadS2(Dhel, w);
336  }
337 
338 // Tensor
339  double EvtBSemiTauonicHelicityAmplitudeCalculator::helampT(double mtau, int tauhel, int Dhel, double w, double costau) const
340  {
341  double amp(0.);
342  for (int whel1 = -1; whel1 <= 2; whel1++) {
343  for (int whel2 = -1; whel2 <= 2; whel2++) {
344  amp += -1 * eta(whel1) * eta(whel2) * Lep(mtau, tauhel, whel1, whel2, q2(Dhel, w), costau)
345  * HadT(Dhel, whel1, whel2, w);
346  }
347  }
348  return amp;
349  }
350 
351 
352 // HQET form factors
353 
354 // Vector and axial-vector form factors in terms of CLN form factors
355 // D vector form factor h_+(w)
356  double EvtBSemiTauonicHelicityAmplitudeCalculator::hp(double w) const
357  {
358  const double r0 = r(2);
359  return -((1 + r0) * (1 + r0) * (w - 1) * ffV1(w)
360  - (1 - r0) * (1 - r0) * (w + 1) * ffS1(w)) / (2 * qh2(2, w));
361  }
362 // D vector form factor h_-(w)
363  double EvtBSemiTauonicHelicityAmplitudeCalculator::hm(double w) const
364  {
365  return - (1 - r(2) * r(2)) * (w + 1) * (ffV1(w) - ffS1(w)) / (2 * qh2(2, w));
366  }
367 
368 // D* axial vector form factor h_{A1}(w)
369  double EvtBSemiTauonicHelicityAmplitudeCalculator::hA1(double w) const
370  {
371  return ffA1(w);
372  }
373 
374 // D* axial vector form factor h_V(w)
375  double EvtBSemiTauonicHelicityAmplitudeCalculator::hV(double w) const
376  {
377  return ffR1(w) * ffA1(w);
378  }
379 
380 // D* axial vector form factor h_{A2}(w)
381  double EvtBSemiTauonicHelicityAmplitudeCalculator::hA2(double w) const
382  {
383  return (ffR2(w) - ffR3(w)) * ffA1(w) / (2 * r(1));
384  }
385 
386 // D* axial vector form factor h_{A3}(w)
387  double EvtBSemiTauonicHelicityAmplitudeCalculator::hA3(double w) const
388  {
389  return (ffR2(w) + ffR3(w)) * ffA1(w) / 2;
390  }
391 
392 // Scalar and pseudo-scalar form factors in terms of V and A form factors
393 // D scalar form factor h_S(w)
394  double EvtBSemiTauonicHelicityAmplitudeCalculator::hS(double w) const
395  {
396  // M. Tanaka, private communication, without approximating quark masses to the meson mass
397  const double r0 = r(2);
398  return m_mB / m_mBottom * ((1 - r0) / (1 - rq()) * hp(w)
399  - (1 + r0) / (1 - rq()) * (w - 1) / (w + 1) * hm(w));
400 
401  // when quark masses are approximated to the meson masses
402  //return ffS1(w);
403  }
404 
405 // D* pseudo scalar form factor h_P(w)
406  double EvtBSemiTauonicHelicityAmplitudeCalculator::hP(double w) const
407  {
408  // M. Tanaka, private communication, without approximating quark masses to the meson mass
409  const double r0 = r(1);
410  return m_mB / m_mBottom * ((w + 1) * hA1(w) - (1 - r0 * w) * hA2(w) - (w - r0) * hA3(w)) / (1 + rq());
411 
412  // when quark masses are approximated to the meson masses
413  //return ( (w+1) * hA1(w) - (1-r0*w) * hA2(w) - (w-r0) * hA3(w) ) / (1+r0); // no Lambda/mQ
414  }
415 
416 // Tensor form factors in terms of V and A form factors
417 // D tensor form factor h_T(w)
418  double EvtBSemiTauonicHelicityAmplitudeCalculator::hT(double w) const
419  {
420  const double r0 = r(2);
421  return hp(w) - (1 + r0) * hm(w) / (1 - r0);
422  }
423 
424 // D* tensor form factor h_{T1}(w)
425  double EvtBSemiTauonicHelicityAmplitudeCalculator::hT1(double w) const
426  {
427  const double r0 = r(1);
428  return -((1 + r0) * (1 + r0) * (w - 1) * hV(w)
429  - (1 - r0) * (1 - r0) * (w + 1) * hA1(w))
430  / (2 * qh2(1, w));
431  }
432 
433 // D* tensor form factor h_{T2}(w)
434  double EvtBSemiTauonicHelicityAmplitudeCalculator::hT2(double w) const
435  {
436  const double r0 = r(1);
437  return -(1 - r0 * r0) * (w + 1) * (hV(w) - hA1(w))
438  / (2 * qh2(1, w));
439  }
440 
441 // D* tensor form factor h_{T3}(w)
442  double EvtBSemiTauonicHelicityAmplitudeCalculator::hT3(double w) const
443  {
444  const double r0 = r(1);
445  return ((1 + r0) * (1 + r0) * hV(w) - 2 * r0 * (w + 1) * hA1(w)
446  + qh2(1, w) * (r0 * hA2(w) - hA3(w)))
447  / (2 * qh2(1, w) * (1 + r0));
448  }
449 
450 // CLN form factors
451  double EvtBSemiTauonicHelicityAmplitudeCalculator::z(double w) const
452  {
453  return (sqrt(w + 1) - sqrt(2)) / (sqrt(w + 1) + sqrt(2));
454  }
455 
456  double EvtBSemiTauonicHelicityAmplitudeCalculator::ffV1(double w) const
457  {
458  return ffV11() * (1 - 8 * m_rho12 * z(w)
459  + (51 * m_rho12 - 10) * z(w) * z(w)
460  - (252 * m_rho12 - 84) * z(w) * z(w) * z(w));
461  }
462 
463  double EvtBSemiTauonicHelicityAmplitudeCalculator::ffS1(double w) const
464  {
465  return (1 + aS1() * dS1(w)) * ffV1(w);
466  }
467 
468  double EvtBSemiTauonicHelicityAmplitudeCalculator::ffA1(double w) const
469  {
470  return ffA11() * (1 - 8 * m_rhoA12 * z(w)
471  + (53 * m_rhoA12 - 15) * z(w) * z(w)
472  - (231 * m_rhoA12 - 91) * z(w) * z(w) * z(w));
473  }
474 
475  double EvtBSemiTauonicHelicityAmplitudeCalculator::ffR1(double w) const
476  {
477  return m_ffR11 - 0.12 * (w - 1) + 0.05 * (w - 1) * (w - 1);
478  }
479 
480  double EvtBSemiTauonicHelicityAmplitudeCalculator::ffR2(double w) const
481  {
482  return m_ffR21 + 0.11 * (w - 1) - 0.06 * (w - 1) * (w - 1);
483  }
484 
485  double EvtBSemiTauonicHelicityAmplitudeCalculator::ffR3(double w) const
486  {
487  return 1 + aR3() * dR3(w);
488  }
489 
490  double EvtBSemiTauonicHelicityAmplitudeCalculator::dS1(double w) const
491  {
492  return -0.019 + 0.041 * (w - 1.) - 0.015 * (w - 1.) * (w - 1.);
493  }
494 
495  double EvtBSemiTauonicHelicityAmplitudeCalculator::dR3(double w) const
496  {
497  return 0.22 - 0.052 * (w - 1.) + 0.026 * (w - 1.) * (w - 1.);
498  }
499 
501  double EvtBSemiTauonicHelicityAmplitudeCalculator::mD(int Dhel) const
502  {
503  assert(chkDhel(Dhel));
504  double mesonMass(-1.);
505  if (Dhel == 2)mesonMass = m_mD;
506  else mesonMass = m_mDst;
507  assert(mesonMass >= 0.);
508  return mesonMass;
509  }
510 
511 // tau velocity
512  double EvtBSemiTauonicHelicityAmplitudeCalculator::v(double mtau, double q2) const
513  {
514  return sqrt(1 - mtau * mtau / q2);
515  }
516 
517 // q^2/mB^2
518  double EvtBSemiTauonicHelicityAmplitudeCalculator::qh2(int Dhel, double w) const
519  {
520  return 1 - 2 * r(Dhel) * w + r(Dhel) * r(Dhel);
521  }
522 
523 // q^2
524  double EvtBSemiTauonicHelicityAmplitudeCalculator::q2(int Dhel, double w) const
525  {
526  return m_mB * m_mB * qh2(Dhel, w);
527  }
528 
529 // sanity checker
530  bool EvtBSemiTauonicHelicityAmplitudeCalculator::chkDhel(int Dhel) const
531  {
532  if (Dhel == -1 || Dhel == 0 || Dhel == 1 || Dhel == 2)return true;
533  else return false;
534  }
535 
536  bool EvtBSemiTauonicHelicityAmplitudeCalculator::chkwhel(int whel) const
537  {
538  if (whel == -1 || whel == 0 || whel == 1 || whel == 2)return true;
539  else return false;
540  }
541 
542  bool EvtBSemiTauonicHelicityAmplitudeCalculator::chktauhel(int tauhel) const
543  {
544  if (tauhel == -1 || tauhel == 1)return true;
545  else return false;
546  }
547 
548 //bool EvtBSemiTauonicHelicityAmplitudeCalculator::chkcostau(double costau) const
549 //{
550 // if (costau >= -1.0 && costau <= 1.0)return true;
551 // else return false;
552 //}
554 } // Belle 2 Namespace
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hT2
double hT2(double w) const
D* tensor form factor h_{T2}(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:442
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::dS1
double dS1(double w) const
HQET correction factor for the scalar form factor for B->Dtaunu.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:498
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::HadV1
double HadV1(int Dhel, int whel, double w) const
The function to calculate the Hadronic Amplitudes of left handed (V-A) type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:207
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::aR3
double aR3() const
HQET correction factor for the uncertainty of 1/m_Q correction.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:373
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hA1
double hA1(double w) const
HQET D* axial vector form factor h_{A1}(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:377
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::z
double z(double w) const
CLN form factor z.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:459
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hT
double hT(double w) const
D tensor form factor h_T(w) in terms of vector form factors.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:426
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_rhoA12
double m_rhoA12
Form factor slope parameters rho_A1^2.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:556
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::HadV2
double HadV2(int Dhel, int whel, double w) const
The function to calculate the Hadronic Amplitudes of right handed (V+A) type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:239
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helampT
double helampT(double mtau, int tauhel, int Dhel, double w, double costau) const
Helicity Amplitudes of tensor type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:347
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::EvtBSemiTauonicHelicityAmplitudeCalculator
EvtBSemiTauonicHelicityAmplitudeCalculator()
The default constructor.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:31
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_mDst
double m_mDst
daughter vector (D*) meson mass.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:577
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_ffR11
double m_ffR11
Form factor parameter R_1(1).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:559
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_mB
double m_mB
parent (B) meson mass.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:571
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffS1
double ffS1(double w) const
CLN form factor S1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:471
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hT1
double hT1(double w) const
D* tensor form factor h_{T1}(w) in terms of axial vector form factors.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:433
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_CV1
EvtComplex m_CV1
Wilson coefficient CV1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:586
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffR3
double ffR3(double w) const
CLN form factor R3.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:493
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::qh2
double qh2(int Dhel, double w) const
Function to calculate the q^2 divided by the square of parent mass (m_B^2).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:526
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::q2
double q2(int Dhel, double w) const
Function to calculate the q^2 of the decay (square of l+nu invariant mass).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:532
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::v
double v(double mtau, double q2) const
Function to calculate the tau velocity.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:520
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hA3
double hA3(double w) const
HQET D* axial vector form factor h_{A3}(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:395
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffV1
double ffV1(double w) const
CLN form factor V1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:464
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::rq
double rq() const
Ratio of the charm quark mass to the charm quark mass.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:390
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::r
double r(int Dhel) const
Ratio of the daughter meson mass to the parent meson.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:385
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::dR3
double dR3(double w) const
HQET correction factor for the scalar form factor for B->D*taunu.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:503
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_ffR21
double m_ffR21
Form factor parameter R_2(1).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:562
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hm
double hm(double w) const
HQET D vector form factor h_-(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:371
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::aS1
double aS1() const
HQET correction factor for the uncertainty of 1/m_Q correction.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:368
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hV
double hV(double w) const
HQET D* axial vector form factor h_V(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:383
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helampS2
double helampS2(double mtau, int tauhel, int Dhel, double w, double costau) const
Helicity Amplitudes of scalar (S-P) type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:341
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hS
double hS(double w) const
D scalar form factor h_S(w) in terms of vector form factors.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:402
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffV11
double ffV11() const
Form factor normalization factor for B->Dlnu.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:345
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_mD
double m_mD
daughter scalar (D) meson mass.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:574
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::eta
double eta(int whel) const
The metric factor.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:252
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::Lep
double Lep(const double mtau, int tauhel, int whel, double q2, double costau) const
The function to calculate the Leptonic Amplitudes for B->D*taunu decay of the vector type contributio...
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:137
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_aR3
double m_aR3
1/mQ correcion factor a_R3.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:568
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::HadS2
double HadS2(int Dhel, double w) const
The function to calculate the Hadronic Amplitudes of scalar (S-P) type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:264
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffR1
double ffR1(double w) const
CLN form factor R1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:483
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_aS1
double m_aS1
1/mQ correcion factor a_S1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:565
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_CS1
EvtComplex m_CS1
Wilson coefficient CS1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:592
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helampS1
double helampS1(double mtau, int tauhel, int Dhel, double w, double costau) const
Helicity Amplitudes of scalar (S+P) type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:335
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::HadT
double HadT(int Dhel, int whel1, int whel2, double w) const
The function to calculate the Hadronic Amplitudes of tensor type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:274
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_mBottom
double m_mBottom
b quark mass (running mass at m_b scale), used for scalar form factor term
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:580
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffA1
double ffA1(double w) const
CLN form factor A1.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:476
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::HadS1
double HadS1(int Dhel, double w) const
The function to calculate the Hadronic Amplitudes of scalar (S+P) type contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:252
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hT3
double hT3(double w) const
D* tensor form factor h_{T3}(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:450
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helampSM
double helampSM(double mtau, int tauhel, int Dhel, double w, double costau) const
Helicity Amplitudes of SM (left handed) contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:307
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::chkDhel
bool chkDhel(int Dhel) const
sanity checkers
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:538
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helampV2
double helampV2(double mtau, int tauhel, int Dhel, double w, double costau) const
Helicity Amplitudes of right handed (V+A) contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:324
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::mD
double mD(int Dhel) const
Daughter D(*) meson mass.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:509
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_CS2
EvtComplex m_CS2
Wilson coefficient CS2.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:595
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffA11
double ffA11() const
Form factor normalization factor for B->D*lnu.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:351
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_mCharm
double m_mCharm
c quark mass (running mass at m_b scale), used for scalar form factor term )
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:583
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helAmp
EvtComplex helAmp(double mtau, int tauhel, int Dhel, double w, double costau) const
The function calculates the helicity amplitude.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:111
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::helampV1
double helampV1(double mtau, int tauhel, int Dhel, double w, double costau) const
Helicity Amplitudes of left handed (V-A) contribution.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:318
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::chktauhel
bool chktauhel(int tauhel) const
Function to check if tauhel is in the valid range.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:550
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hp
double hp(double w) const
HQET D vector form factor h_+(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:364
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::chkwhel
bool chkwhel(int whel) const
Function to check if whel is in the valid range.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:544
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hP
double hP(double w) const
D* pseudo scalar form factor h_P(w) in terms of axial vector form factors.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:414
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::hA2
double hA2(double w) const
HQET D* axial vector form factor h_{A2}(w).
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:389
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_CT
EvtComplex m_CT
Wilson coefficient CT.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:598
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::ffR2
double ffR2(double w) const
CLN form factor R2.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.cc:488
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_CV2
EvtComplex m_CV2
Wilson coefficient CV2.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:589
Belle2::EvtBSemiTauonicHelicityAmplitudeCalculator::m_rho12
double m_rho12
Form factor slope parameters rho_1^2.
Definition: EvtBSemiTauonicHelicityAmplitudeCalculator.h:553