Belle II Software  release-05-01-25
EvtLLSWFF.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2016 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Florian Bernlochner *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include "EvtGenBase/EvtReport.hh"
12 #include "EvtGenBase/EvtId.hh"
13 #include <string>
14 #include "EvtGenBase/EvtPDL.hh"
15 #include <math.h>
16 #include <stdlib.h>
17 
18 #include "generators/evtgen/models/EvtLLSWFF.h"
19 
20 
21 EvtLLSWFF::EvtLLSWFF(double _tau_w1, double _tau_wp, double _zeta_1)
22 {
23 
24  tau_w1 = _tau_w1;
25  tau_wp = _tau_wp;
26 
27  zeta_1 = _zeta_1;
28 
29  mb = 4.2; mc = 1.4; L = 0.40; Lp = 0.80; Ls = 0.76;
30 
31  eta_1 = eta_2 = eta_3 = eta_b = 0.;
32  chi_1 = chi_2 = chi_b = 0.;
33 
34  return;
35 }
36 
37 EvtLLSWFF::EvtLLSWFF(double _tau_w1, double _tau_wp, double _tau_1, double _tau_2)
38 {
39 
40  tau_w1 = _tau_w1;
41  tau_wp = _tau_wp;
42 
43  tau_1 = _tau_1;
44  tau_2 = _tau_2;
45 
46  mb = 4.2; mc = 1.4; L = 0.40; Lp = 0.80; Ls = 0.76;
47 
48  eta_1 = eta_2 = eta_3 = eta_b = 0.;
49  chi_1 = chi_2 = chi_b = 0.;
50 
51  return;
52 }
53 
54 
55 void EvtLLSWFF::getscalarff(EvtId parent, EvtId,
56  double t, double mass, double* fp, double* f0)
57 {
58 
59  // std::cerr << "Called EvtLLSWFF::getscalarff" << std::endl;
60 
61 
62  double m = EvtPDL::getMeanMass(parent);
63  double w = ((m * m) + (mass * mass) - t) / (2.0 * m * mass);
64 
65  *fp = ((m + mass) * gpD0(w) - (m - mass) * gmD0(w)) / (2 * sqrt(mass * m));
66  *f0 = ((m - mass) * (pow(m + mass, 2.) - t) * gpD0(w) - (mass + m) * (pow(m - mass,
67  2.) - t) * gmD0(w)) / (2 * (m - mass) * sqrt(m * mass) * (mass + m));
68 
69  return;
70 }
71 
72 void EvtLLSWFF::getvectorff(EvtId parent, EvtId daughter,
73  double t, double mass, double* a1f,
74  double* a2f, double* vf, double* a0f)
75 {
76 
77  double m = EvtPDL::getMeanMass(parent);
78  double w = ((m * m) + (mass * mass) - t) / (2.0 * m * mass);
79 
80  static EvtId D3P1P = EvtPDL::getId("D'_1+");
81  static EvtId D3P1N = EvtPDL::getId("D'_1-");
82  static EvtId D3P10 = EvtPDL::getId("D'_10");
83  static EvtId D3P1B = EvtPDL::getId("anti-D'_10");
84  static EvtId D3P1SP = EvtPDL::getId("D'_s1+");
85  static EvtId D3P1SN = EvtPDL::getId("D'_s1-");
86 
87  // Form factors have a general form, with parameters passed in
88  // from the arguements.
89 
90  if (daughter == D3P1P || daughter == D3P1N || daughter == D3P10 || daughter == D3P1B || daughter == D3P1SP || daughter == D3P1SN) {
91 
92  *a1f = sqrt(mass * m) / (mass + m) * gV1D1p(w);
93  *a2f = -(mass + m) * (gV3D1p(w) + mass / m * gV2D1p(w)) / (2 * sqrt(mass * m));
94  *vf = 0.5 * (mass + m) * 1. / sqrt(mass * m) * gAD1p(w);
95 
96  double a3f = (m + mass) / (2 * mass) * (*a1f) - (m - mass) / (2 * mass) * (*a2f);
97  *a0f = -t * (gV3D1p(w) - mass / m * gV2D1p(w)) / (4.*mass * sqrt(m * mass)) + a3f;
98 
99 
100  } else {
101 
102  *a1f = sqrt(mass * m) / (mass + m) * fV1D1(w);
103  *a2f = -(mass + m) * (fV3D1(w) + mass / m * fV2D1(w)) / (2 * sqrt(mass * m));
104  *vf = 0.5 * (mass + m) * 1. / sqrt(mass * m) * fAD1(w);
105 
106  double a3f = (m + mass) / (2 * mass) * (*a1f) - (m - mass) / (2 * mass) * (*a2f);
107  *a0f = -t * (fV3D1(w) - mass / m * fV2D1(w)) / (4.*mass * sqrt(m * mass)) + a3f;
108 
109  }
110 
111 
112  return;
113 }
114 
115 void EvtLLSWFF::gettensorff(EvtId parent, EvtId,
116  double t, double mass, double* hf,
117  double* kf, double* bpf, double* bmf)
118 {
119 
120  double m = EvtPDL::getMeanMass(parent);
121  double w = ((m * m) + (mass * mass) - t) / (2.0 * m * mass);
122 
123  *hf = -sqrt(mass * m) / (mass * m * m) / 2.*kVD2(w);
124  *kf = sqrt(mass * m) / m * kA1D2(w);
125 
126  *bpf = sqrt(mass * m) * (kA3D2(w) * m + kA2D2(w) * mass) / (2 * pow(m, 3.) * mass);
127  *bmf = kA2D2(w) * sqrt(mass * m) / (2 * pow(m, 3.)) - kA3D2(w) * sqrt(mass * m) / (2 * pow(m, 2.) * mass);
128 
129  return;
130 
131 }
132 
133 
134 void EvtLLSWFF::getbaryonff(EvtId, EvtId, double, double, double*,
135  double*, double*, double*)
136 {
137 
138  EvtGenReport(EVTGEN_ERROR, "EvtGen") << "Not implemented :getbaryonff in EvtLLSWFF.\n";
139  ::abort();
140 
141 }
142 
143 void EvtLLSWFF::getdiracff(EvtId, EvtId, double, double, double*, double*,
144  double*, double*, double*, double*)
145 {
146 
147  EvtGenReport(EVTGEN_ERROR, "EvtGen") << "Not implemented :getdiracff in EvtLLSWFF.\n";
148  ::abort();
149 
150 }
151 
152 void EvtLLSWFF::getraritaff(EvtId, EvtId, double, double, double*, double*,
153  double*, double*, double*, double*, double*, double*)
154 {
155 
156  EvtGenReport(EVTGEN_ERROR, "EvtGen") << "Not implemented :getraritaff in EvtLLSWFF.\n";
157  ::abort();
158 
159 }
160 
161 // Isgur-Wise Function
162 //-------------------------------------------------------------------------------------------
163 
164 double EvtLLSWFF::IsgurWiseFunction(double w)
165 {
166 
167  double value = 0;
168 
169  value += tau_w1;
170  value += tau_w1 * (w - 1.) * tau_wp;
171 
172  return value;
173 
174 }
175 
176 // Form Factors for D0
177 //-------------------------------------------------------------------------------------------
178 
179 double EvtLLSWFF::gpD0(double w)
180 {
181 
182  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
183 
184  // Leading IW function values
185  double z12 = IsgurWiseFunction(w);
186 
187  double gp = 0;
188 
189  gp += ec * (2.*(w - 1.) * zeta_1 * z12 - 3.*z12 * (w * Ls - L) / (w + 1.));
190  gp += -eb * ((Ls * (2.*w + 1.) - L * (w + 2.)) / (w + 1.) * z12 - 2.*(w - 1.) * zeta_1 * z12);
191 
192  return gp;
193 
194 }
195 
196 double EvtLLSWFF::gmD0(double w)
197 {
198 
199  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
200 
201  // Leading IW function values
202  double z12 = IsgurWiseFunction(w);
203 
204  double gm = 0;
205 
206  gm += z12;
207  gm += ec * (6 * chi_1 - 2 * (w + 1) * chi_2);
208  gm += eb * chi_b;
209 
210  return gm;
211 }
212 
213 // Form Factors for D1*
214 //-------------------------------------------------------------------------------------------
215 
216 
217 double EvtLLSWFF::gV1D1p(double w)
218 {
219 
220  double ec = 1 / (2 * mc), eb = 1 / (2 * mb);
221 
222  // Leading IW function values
223  double z12 = IsgurWiseFunction(w);
224 
225  double gv1 = 0;
226 
227  gv1 += (w - 1.) * z12;
228  gv1 += ec * ((w * Ls - L) * z12 + (w - 1.) * (-2 * chi_1));
229  gv1 -= eb * ((Ls * (2.*w + 1) - L * (w + 2.)) * z12 - 2 * (pow(w, 2.) - 1.) * zeta_1 * z12 - (w - 1.) * chi_b);
230 
231  return gv1;
232 
233 };
234 
235 double EvtLLSWFF::gV2D1p(double w)
236 {
237 
238  double ec = 1 / (2 * mc);
239 
240  // Leading IW function values
241  double z12 = IsgurWiseFunction(w);
242 
243  double gv2 = 0;
244 
245  gv2 += 2 * ec * (zeta_1 * z12 - chi_2);
246 
247  return gv2;
248 
249 };
250 
251 double EvtLLSWFF::gV3D1p(double w)
252 {
253 
254  double ec = 1 / (2 * mc), eb = 1 / (2 * mb);
255 
256  // Leading IW function values
257  double z12 = IsgurWiseFunction(w);
258 
259  double gv3 = 0;
260 
261  gv3 += eb * ((Ls * (2.*w + 1) - L * (w + 2.)) / (w + 1.) * z12 - 2 * (w - 1.) * zeta_1 * z12 - chi_b);
262  gv3 -= z12;
263  gv3 -= ec * ((w * Ls - L) / (w + 1) * z12 + 2.*zeta_1 * z12 - 2 * chi_1 + 2 * chi_2);
264 
265  return gv3;
266 
267 
268 };
269 
270 double EvtLLSWFF::gAD1p(double w)
271 {
272 
273  double ec = 1 / (2 * mc), eb = 1 / (2 * mb);
274 
275  // Leading IW function values
276  double z12 = IsgurWiseFunction(w);
277 
278  double ga = 0;
279 
280  ga += eb * (2.*(w - 1.) * zeta_1 * z12 - (Ls * (2.*w + 1.) - L * (w + 2.)) / (w + 1.) * z12 + chi_b);
281  ga += z12;
282  ga += ec * ((w * Ls - L) / (w + 1.) * z12 - 2 * chi_1);
283 
284  return ga;
285 
286 };
287 
288 // Form Factors for D1
289 //-------------------------------------------------------------------------------------------
290 
291 double EvtLLSWFF::fV1D1(double w)
292 {
293 
294  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
295 
296  // Leading IW function values
297  double t32 = IsgurWiseFunction(w);
298 
299  double fv1 = 0;
300 
301  fv1 += (1. - pow(w, 2.)) * t32;
302  fv1 -= eb * (pow(w, 2.) - 1.) * ((Lp + L) * t32 - (2.*w + 1) * tau_1 * t32 - tau_2 * t32 + eta_b);
303  fv1 -= ec * (4.*(w + 1.) * (w * Lp - L) * t32 - (pow(w, 2.) - 1) * (3.*tau_1 * t32 - 3.*tau_2 * t32 + 2 * eta_1 + 3 * eta_3));
304 
305  fv1 /= sqrt(6);
306 
307  return fv1;
308 
309 };
310 
311 double EvtLLSWFF::fV2D1(double w)
312 {
313 
314  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
315 
316  // Leading IW function values
317  double t32 = IsgurWiseFunction(w);
318 
319  double fv2 = 0;
320 
321  fv2 -= 3.*t32;
322  fv2 -= 3 * eb * ((Lp + L) * t32 - (2 * w + 1) * tau_1 * t32 - tau_2 * t32 + eta_b);
323  fv2 -= ec * ((4.*w - 1) * tau_1 * t32 + 5 * tau_2 * t32 + 10 * eta_1 + 4 * (w - 1.) * eta_2 - 5 * eta_3);
324 
325  fv2 /= sqrt(6);
326 
327  return fv2;
328 
329 };
330 
331 double EvtLLSWFF::fV3D1(double w)
332 {
333 
334  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
335 
336  // Leading IW function values
337  double t32 = IsgurWiseFunction(w);
338 
339  double fv3 = 0;
340 
341  fv3 += (w - 2.) * t32;
342  fv3 += eb * ((2. + w) * ((Lp + L) * t32 - (2.*w + 1.) * tau_1 * t32 - tau_2 * t32) - (2. - w) * eta_b);
343  fv3 += ec * (4.*(w * Lp - L) * t32 + (2. + w) * tau_1 * t32 + (2. + 3.*w) * tau_2 * t32 - 2.*(6. + w) * eta_1 - 4.*
344  (w - 1) * eta_2 - (3.*w - 2.) * eta_3);
345 
346  fv3 /= sqrt(6);
347 
348  return fv3;
349 
350 
351 };
352 
353 double EvtLLSWFF::fAD1(double w)
354 {
355 
356  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
357 
358  // Leading IW function values
359  double t32 = IsgurWiseFunction(w);
360 
361  double fa = 0;
362 
363  fa += -(w + 1.) * t32;
364  fa -= eb * ((w - 1.) * ((Lp + L) * t32 - (2.*w + 1.) * tau_1 * t32 - tau_2 * t32) + (w + 1.) * eta_b);
365  fa -= ec * (4.*(w * Lp - L) * t32 - 3.*(w - 1.) * (tau_1 * t32 - tau_2 * t32) + (w + 1.) * (-2 * eta_1 - 3 * eta_3));
366 
367  fa /= sqrt(6);
368 
369  return fa;
370 
371 };
372 
373 // Form Factors for D2
374 //-------------------------------------------------------------------------------------------
375 
376 double EvtLLSWFF::kA1D2(double w)
377 {
378 
379  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
380 
381  // Leading IW function values
382  double t32 = IsgurWiseFunction(w);
383 
384  double ka1 = 0;
385 
386  ka1 -= (1. + w) * t32;
387  ka1 -= eb * ((w - 1.) * ((Lp + L) * t32 - (2.*w + 1.) * tau_1 * t32 - tau_2 * t32) + (1. + w) * eta_b);
388  ka1 -= ec * ((w - 1.) * (tau_1 * t32 - tau_2 * t32) + (w + 1.) * (-2 * eta_1 + eta_3));
389 
390  return ka1;
391 
392 };
393 
394 double EvtLLSWFF::kA2D2(double w)
395 {
396 
397  double ec = 1. / (2.*mc);
398 
399  // Leading IW function values
400  double t32 = IsgurWiseFunction(w);
401 
402  double ka2 = 0;
403 
404  ka2 -= 2.*ec * (tau_1 * t32 + eta_2);
405 
406  return ka2;
407 
408 };
409 
410 double EvtLLSWFF::kA3D2(double w)
411 {
412 
413  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
414 
415  // Leading IW function values
416  double t32 = IsgurWiseFunction(w);
417 
418  double ka3 = 0;
419 
420  ka3 += t32;
421  ka3 += eb * ((Lp + L) * t32 - (2.*w + 1.) * tau_1 * t32 - tau_2 * t32 + eta_b);
422  ka3 -= ec * (tau_1 * t32 + tau_2 * t32 + 2 * eta_1 - 2 * eta_2 - eta_3);
423 
424  return ka3;
425 
426 };
427 
428 double EvtLLSWFF::kVD2(double w)
429 {
430 
431  double ec = 1. / (2.*mc), eb = 1. / (2.*mb);
432 
433  // Leading IW function values
434  double t32 = IsgurWiseFunction(w);
435 
436  double kv = 0;
437 
438  kv -= t32;
439  kv -= eb * ((Lp + L) * t32 - (2.*w + 1) * tau_1 * t32 - tau_2 * t32 + eta_b);
440  kv -= ec * (tau_1 * t32 - tau_2 * t32 - 2 * eta_1 + eta_3);
441 
442  return kv;
443 
444 };
EvtLLSWFF::chi_2
double chi_2
doubles to store chromomagnetic terms for broad states
Definition: EvtLLSWFF.h:141
EvtLLSWFF::gAD1p
double gAD1p(double w)
D1* form factor gA.
Definition: EvtLLSWFF.cc:270
EvtLLSWFF::fV2D1
double fV2D1(double w)
D1 form factor fV2.
Definition: EvtLLSWFF.cc:311
EvtLLSWFF::tau_w1
double tau_w1
doubles to store normalization of IW function
Definition: EvtLLSWFF.h:96
EvtLLSWFF::eta_2
double eta_2
doubles to store chromomagnetic terms for narrow states
Definition: EvtLLSWFF.h:129
EvtLLSWFF::chi_b
double chi_b
doubles to store chromomagnetic terms for broad states
Definition: EvtLLSWFF.h:144
EvtLLSWFF::tau_2
double tau_2
doubles to store normalizations of sub-leading IW functions
Definition: EvtLLSWFF.h:123
EvtLLSWFF::chi_1
double chi_1
doubles to store chromomagnetic terms for broad states
Definition: EvtLLSWFF.h:138
EvtLLSWFF::getdiracff
void getdiracff(EvtId, EvtId, double, double, double *, double *, double *, double *, double *, double *)
Returns dirac ffs.
Definition: EvtLLSWFF.cc:143
EvtLLSWFF::Lp
double Lp
doubles to store mass differences
Definition: EvtLLSWFF.h:114
EvtLLSWFF::fAD1
double fAD1(double w)
D1 form factor fA.
Definition: EvtLLSWFF.cc:353
EvtLLSWFF::tau_1
double tau_1
doubles to store normalizations of sub-leading IW functions
Definition: EvtLLSWFF.h:120
EvtLLSWFF::eta_3
double eta_3
doubles to store chromomagnetic terms for narrow states
Definition: EvtLLSWFF.h:132
EvtLLSWFF::zeta_1
double zeta_1
doubles to store normalizations of sub-leading IW functions
Definition: EvtLLSWFF.h:117
EvtLLSWFF::kA3D2
double kA3D2(double w)
D2 form factor kA3.
Definition: EvtLLSWFF.cc:410
EvtLLSWFF::gV2D1p
double gV2D1p(double w)
D1* form factor gV2.
Definition: EvtLLSWFF.cc:235
EvtLLSWFF::tau_wp
double tau_wp
doubles to slope of IW function
Definition: EvtLLSWFF.h:99
EvtLLSWFF::fV3D1
double fV3D1(double w)
D1 form factor fV3.
Definition: EvtLLSWFF.cc:331
EvtLLSWFF::getvectorff
void getvectorff(EvtId, EvtId, double t, double mass, double *a1f, double *a2f, double *vf, double *a0f)
Returns vector ffs.
Definition: EvtLLSWFF.cc:72
EvtLLSWFF::getraritaff
void getraritaff(EvtId, EvtId, double, double, double *, double *, double *, double *, double *, double *, double *, double *)
Returns rarita ffs.
Definition: EvtLLSWFF.cc:152
EvtLLSWFF::gmD0
double gmD0(double w)
D0 form factor g-.
Definition: EvtLLSWFF.cc:196
EvtLLSWFF::gV3D1p
double gV3D1p(double w)
D1* form factor gV3.
Definition: EvtLLSWFF.cc:251
EvtLLSWFF::kA1D2
double kA1D2(double w)
D2 form factor kA1.
Definition: EvtLLSWFF.cc:376
EvtLLSWFF::L
double L
doubles to store mass differences
Definition: EvtLLSWFF.h:108
EvtLLSWFF::eta_b
double eta_b
doubles to store chromomagnetic terms for narrow states
Definition: EvtLLSWFF.h:135
EvtLLSWFF::gettensorff
void gettensorff(EvtId, EvtId, double t, double mass, double *hf, double *kf, double *bpf, double *bmf)
Returns tensor ffs.
Definition: EvtLLSWFF.cc:115
EvtLLSWFF::kA2D2
double kA2D2(double w)
D2 form factor kA2.
Definition: EvtLLSWFF.cc:394
EvtLLSWFF::mb
double mb
doubles to store b quark mass
Definition: EvtLLSWFF.h:102
EvtLLSWFF::eta_1
double eta_1
doubles to store chromomagnetic terms for narrow states
Definition: EvtLLSWFF.h:126
EvtLLSWFF::fV1D1
double fV1D1(double w)
D1 form factor fV1.
Definition: EvtLLSWFF.cc:291
EvtLLSWFF::gV1D1p
double gV1D1p(double w)
D1* form factor gV1.
Definition: EvtLLSWFF.cc:217
EvtLLSWFF::EvtLLSWFF
EvtLLSWFF(double _tau_w1, double _tau_wp, double zeta_1)
Default constructor.
Definition: EvtLLSWFF.cc:21
EvtLLSWFF::getscalarff
void getscalarff(EvtId, EvtId, double t, double mass, double *fp, double *f0)
Returns scalar ffs.
Definition: EvtLLSWFF.cc:55
EvtLLSWFF::mc
double mc
doubles to store b quark mass
Definition: EvtLLSWFF.h:105
EvtLLSWFF::kVD2
double kVD2(double w)
D2 form factor kV.
Definition: EvtLLSWFF.cc:428
EvtLLSWFF::getbaryonff
void getbaryonff(EvtId, EvtId, double, double, double *, double *, double *, double *)
Returns baryon ffs.
Definition: EvtLLSWFF.cc:134
EvtLLSWFF::Ls
double Ls
doubles to store mass differences
Definition: EvtLLSWFF.h:111
EvtLLSWFF::IsgurWiseFunction
double IsgurWiseFunction(double w)
Isgur-Wise function.
Definition: EvtLLSWFF.cc:164
EvtLLSWFF::gpD0
double gpD0(double w)
D0 form factor g+.
Definition: EvtLLSWFF.cc:179