a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
OptimizedObservablesSMEFTd6.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2018 HEPfit Collaboration
3  *
4  *
5  * For the licensing terms see doc/COPYING.
6  */
7 
8 #include "OptimizedObservablesSMEFTd6.h"
9 #include "StandardModel.h"
10 #include "HeffDB1.h"
11 
12 eeWW::eeWW(const StandardModel& SM_i)
13 : ThObservable(SM_i)
14 {
15 };
16 
17 double eeWW::computeThValue()
18 {
19 // double energy = 1500;
20 // double weight;
21 
22  // Get phase space point
23 // std::vector<double*> p = get_momenta(ninitial, energy, getMasses(), weight);
24  std::vector<double*> pp(1, new double[4]);
25  pp[0][0] = 7.500000e+02;
26  pp[0][1] = 0.;
27  pp[0][2] = 0.;
28  pp[0][3] = 7.500000e+02;
29  pp.push_back(new double[4]);
30  pp[1][0] = 7.500000e+02;
31  pp[1][1] = 0.;
32  pp[1][2] = 0.;
33  pp[1][3] = -7.500000e+02;
34  pp.push_back(new double[4]);
35  pp[2][0] = 1.328270e+02;
36  pp[2][1] = -3.315104e+01;
37  pp[2][2] = 6.012053e+01;
38  pp[2][3] = -1.137081e+02;
39  pp.push_back(new double[4]);
40  pp[3][0] = 4.924941e+02;
41  pp[3][1] = -1.557744e+02;
42  pp[3][2] = -4.529006e+02;
43  pp[3][3] = 1.147424e+02;
44  pp.push_back(new double[4]);
45  pp[4][0] = 2.285372e+02;
46  pp[4][1] = -1.588214e+02;
47  pp[4][2] = -1.465645e+02;
48  pp[4][3] = 7.432258e+01;
49  pp.push_back(new double[4]);
50  pp[5][0] = 6.461417e+02;
51  pp[5][1] = 3.477469e+02;
52  pp[5][2] = 5.393446e+02;
53  pp[5][3] = -7.535681e+01;
54  updateParameters();
55 
56  for (int i = 0; i < 1000000; i++) {
57 
58 
59  // Set momenta for this event
60  setMomenta(pp);
61 
62  // Evaluate matrix element
63  sigmaKin();
64  }
65  return *getMatrixElements();
66 }
67 
68 void eeWW::updateParameters()
69 {
70 
71  zero = 0;
72  ZERO = 0;
73 
74  std::vector<int> indices(2, 0);
75  Gamma_H = 6.382339e-03;
76  Gamma_W = 2.047600e+00;
77  Gamma_Z = 2.441404e+00;
78  Gamma_T = 1.491500e+00;
79  ymtau = 1.777000e+00;
80  ymt = 1.730000e+02;
81  ymb = 4.700000e+00;
82  aS = 1.180000e-01;
83  Gf = 1.166390e-05;
84  aEWM1 = 1.325070e+02;
85  MH = 1.250000e+02;
86  MZ = 9.118800e+01;
87  MTA = 1.777000e+00;
88  MT = 1.730000e+02;
89  MB = 4.700000e+00;
90  conjg__CKM3x3 = 1.;
91  CKM3x3 = 1.;
92  conjg__CKM1x1 = 1.;
93  complexi = std::complex<double> (0., 1.);
94  MZ2 = MZ*MZ;
95  MZ4 = MZ2*MZ2;
96  MH2 = MH*MH;
97  aEW = 1. / aEWM1;
98  MW = sqrt(MZ2 / 2. + sqrt(MZ4 / 4. - (aEW * M_PI * MZ2) / (Gf * M_SQRT2)));
99  sqrt__aEW = sqrt(aEW);
100  ee = 2. * sqrt__aEW * sqrt(M_PI);
101  MW2 = MW*MW;
102  sw2 = 1. - MW2 / MZ2;
103  cw = sqrt(1. - sw2);
104  sqrt__sw2 = sqrt(sw2);
105  sw = sqrt__sw2;
106  g1 = ee / cw;
107  gw = ee / sw;
108  vev = (2. * MW * sw) / ee;
109  vev2 = vev * vev;
110  lam = MH2 / (2. * vev2);
111  yb = (ymb * M_SQRT2) / vev;
112  yt = (ymt * M_SQRT2) / vev;
113  ytau = (ymtau * M_SQRT2) / vev;
114  muH = sqrt(lam * vev2);
115  I1x33 = yb * conjg__CKM3x3;
116  I2x33 = yt * conjg__CKM3x3;
117  I3x33 = CKM3x3 * yt;
118  I4x33 = CKM3x3 * yb;
119  ee2 = ee*ee;
120  cw2 = 1. - sw2;
121 
122 
123  GC_3 = -(ee * complexi);
124  GC_51 = (cw * ee * complexi) / (2. * sw);
125  GC_53 = (cw * ee * complexi) / sw;
126  GC_59 = (ee * complexi * sw) / (2. * cw);
127  GC_100 = (ee * complexi * conjg__CKM1x1) / (sw * M_SQRT2);
128 
129  sqrt__aS = sqrt(aS);
130  G = 2. * sqrt__aS * sqrt(M_PI);
131  G2 = G*G;
132 
133  mME.assign(6, 0.);
134  jamp2[0] = new double[1];
135 
136 }
137 
138 void eeWW::ixxxxx(double p[4], double fmass, int nhel, int nsf, std::complex<double> fi[6])
139 {
140  std::complex<double> chi[2];
141  double sf[2], sfomega[2], omega[2], pp, pp3, sqp0p3, sqm[2];
142  int ip, im, nh;
143  fi[0] = std::complex<double> (-p[0] * nsf, -p[3] * nsf);
144  fi[1] = std::complex<double> (-p[1] * nsf, -p[2] * nsf);
145  nh = nhel * nsf;
146  if (fmass != 0.0) {
147  pp = std::min(p[0], sqrt(p[1] * p[1] + p[2] * p[2] + p[3] * p[3]));
148  if (pp == 0.0) {
149  sqm[0] = sqrt(std::abs(fmass));
150  sqm[1] = Sgn(sqm[0], fmass);
151  ip = (1 + nh) / 2;
152  im = (1 - nh) / 2;
153  fi[2] = ip * sqm[ip];
154  fi[3] = im * nsf * sqm[ip];
155  fi[4] = ip * nsf * sqm[im];
156  fi[5] = im * sqm[im];
157  } else {
158  sf[0] = (1 + nsf + (1 - nsf) * nh) * 0.5;
159  sf[1] = (1 + nsf - (1 - nsf) * nh) * 0.5;
160  omega[0] = sqrt(p[0] + pp);
161  omega[1] = fmass / omega[0];
162  ip = (1 + nh) / 2;
163  im = (1 - nh) / 2;
164  sfomega[0] = sf[0] * omega[ip];
165  sfomega[1] = sf[1] * omega[im];
166  pp3 = std::max(pp + p[3], 0.0);
167  chi[0] = std::complex<double> (sqrt(pp3 * 0.5 / pp), 0);
168  if (pp3 == 0.0) {
169  chi[1] = std::complex<double> (-nh, 0);
170  } else {
171  chi[1] = std::complex<double> (nh * p[1], p[2]) / sqrt(2.0 * pp * pp3);
172  }
173  fi[2] = sfomega[0] * chi[im];
174  fi[3] = sfomega[0] * chi[ip];
175  fi[4] = sfomega[1] * chi[im];
176  fi[5] = sfomega[1] * chi[ip];
177  }
178  } else {
179  if (p[1] == 0.0 and p[2] == 0.0 and p[3] < 0.0) {
180  sqp0p3 = 0.0;
181  } else {
182  sqp0p3 = sqrt(std::max(p[0] + p[3], 0.0)) * nsf;
183  }
184  chi[0] = std::complex<double> (sqp0p3, 0.0);
185  if (sqp0p3 == 0.0) {
186  chi[1] = std::complex<double> (-nhel * sqrt(2.0 * p[0]), 0.0);
187  } else {
188  chi[1] = std::complex<double> (nh * p[1], p[2]) / sqp0p3;
189  }
190  if (nh == 1) {
191  fi[2] = std::complex<double> (0.0, 0.0);
192  fi[3] = std::complex<double> (0.0, 0.0);
193  fi[4] = chi[0];
194  fi[5] = chi[1];
195  } else {
196  fi[2] = chi[1];
197  fi[3] = chi[0];
198  fi[4] = std::complex<double> (0.0, 0.0);
199  fi[5] = std::complex<double> (0.0, 0.0);
200  }
201  }
202  return;
203 }
204 
205 double eeWW::Sgn(double a, double b)
206 {
207  return (b < 0) ? - abs(a) : abs(a);
208 }
209 
210 void eeWW::txxxxx(double p[4], double tmass, int nhel, int nst, std::complex<double>
211  tc[18])
212 {
213  std::complex<double> ft[6][4], ep[4], em[4], e0[4];
214  double pt, pt2, pp, pzpt, emp, sqh, sqs;
215  int i, j;
216 
217  sqh = sqrt(0.5);
218  sqs = sqrt(0.5 / 3);
219 
220  pt2 = p[1] * p[1] + p[2] * p[2];
221  pp = std::min(p[0], sqrt(pt2 + p[3] * p[3]));
222  pt = std::min(pp, sqrt(pt2));
223 
224  ft[4][0] = std::complex<double> (p[0] * nst, p[3] * nst);
225  ft[5][0] = std::complex<double> (p[1] * nst, p[2] * nst);
226 
227  // construct eps+
228  if (nhel >= 0) {
229  if (pp == 0) {
230  ep[0] = std::complex<double> (0, 0);
231  ep[1] = std::complex<double> (-sqh, 0);
232  ep[2] = std::complex<double> (0, nst * sqh);
233  ep[3] = std::complex<double> (0, 0);
234  } else {
235  ep[0] = std::complex<double> (0, 0);
236  ep[3] = std::complex<double> (pt / pp * sqh, 0);
237 
238  if (pt != 0) {
239  pzpt = p[3] / (pp * pt) * sqh;
240  ep[1] = std::complex<double> (-p[1] * pzpt, -nst * p[2] / pt * sqh);
241  ep[2] = std::complex<double> (-p[2] * pzpt, nst * p[1] / pt * sqh);
242  } else {
243  ep[1] = std::complex<double> (-sqh, 0);
244  ep[2] = std::complex<double> (0, nst * Sgn(sqh, p[3]));
245  }
246  }
247 
248  }
249 
250  // construct eps-
251  if (nhel <= 0) {
252  if (pp == 0) {
253  em[0] = std::complex<double> (0, 0);
254  em[1] = std::complex<double> (sqh, 0);
255  em[2] = std::complex<double> (0, nst * sqh);
256  em[3] = std::complex<double> (0, 0);
257  } else {
258  em[0] = std::complex<double> (0, 0);
259  em[3] = std::complex<double> (-pt / pp * sqh, 0);
260 
261  if (pt != 0) {
262  pzpt = -p[3] / (pp * pt) * sqh;
263  em[1] = std::complex<double> (-p[1] * pzpt, -nst * p[2] / pt * sqh);
264  em[2] = std::complex<double> (-p[2] * pzpt, nst * p[1] / pt * sqh);
265  } else {
266  em[1] = std::complex<double> (sqh, 0);
267  em[2] = std::complex<double> (0, nst * Sgn(sqh, p[3]));
268  }
269  }
270  }
271 
272  // construct eps0
273  if (std::labs(nhel) <= 1) {
274  if (pp == 0) {
275  e0[0] = std::complex<double> (0, 0);
276  e0[1] = std::complex<double> (0, 0);
277  e0[2] = std::complex<double> (0, 0);
278  e0[3] = std::complex<double> (1, 0);
279  } else {
280  emp = p[0] / (tmass * pp);
281  e0[0] = std::complex<double> (pp / tmass, 0);
282  e0[3] = std::complex<double> (p[3] * emp, 0);
283 
284  if (pt != 0) {
285  e0[1] = std::complex<double> (p[1] * emp, 0);
286  e0[2] = std::complex<double> (p[2] * emp, 0);
287  } else {
288  e0[1] = std::complex<double> (0, 0);
289  e0[2] = std::complex<double> (0, 0);
290  }
291  }
292  }
293 
294  if (nhel == 2) {
295  for (j = 0; j < 4; j++) {
296  for (i = 0; i < 4; i++)
297  ft[i][j] = ep[i] * ep[j];
298  }
299  } else if (nhel == -2) {
300  for (j = 0; j < 4; j++) {
301  for (i = 0; i < 4; i++)
302  ft[i][j] = em[i] * em[j];
303  }
304  } else if (tmass == 0) {
305  for (j = 0; j < 4; j++) {
306  for (i = 0; i < 4; i++)
307  ft[i][j] = 0;
308  }
309  } else if (tmass != 0) {
310  if (nhel == 1) {
311  for (j = 0; j < 4; j++) {
312  for (i = 0; i < 4; i++)
313  ft[i][j] = sqh * (ep[i] * e0[j] + e0[i] * ep[j]);
314  }
315  } else if (nhel == 0) {
316  for (j = 0; j < 4; j++) {
317  for (i = 0; i < 4; i++)
318  ft[i][j] = sqs * (ep[i] * em[j] + em[i] * ep[j]
319  + 2.0 * e0[i] * e0[j]);
320  }
321  } else if (nhel == -1) {
322  for (j = 0; j < 4; j++) {
323  for (i = 0; i < 4; i++)
324  ft[i][j] = sqh * (em[i] * e0[j] + e0[i] * em[j]);
325  }
326  } else {
327  std::cerr << "Invalid helicity in txxxxx.\n";
328  std::exit(1);
329  }
330  }
331 
332  tc[0] = ft[4][0];
333  tc[1] = ft[5][0];
334 
335  for (j = 0; j < 4; j++) {
336  for (i = 0; i < 4; i++)
337  tc[j * 4 + i + 2] = ft[j][i];
338  }
339 }
340 
341 void eeWW::vxxxxx(double p[4], double vmass, int nhel, int nsv, std::complex<double> vc[6])
342 {
343  double hel, hel0, pt, pt2, pp, pzpt, emp, sqh;
344  int nsvahl;
345  sqh = sqrt(0.5);
346  hel = double(nhel);
347  nsvahl = nsv * std::abs(hel);
348  pt2 = (p[1] * p[1]) + (p[2] * p[2]);
349  pp = std::min(p[0], sqrt(pt2 + (p[3] * p[3])));
350  pt = std::min(pp, sqrt(pt2));
351  vc[0] = std::complex<double> (p[0] * nsv, p[3] * nsv);
352  vc[1] = std::complex<double> (p[1] * nsv, p[2] * nsv);
353  if (vmass != 0.0) {
354  hel0 = 1.0 - std::abs(hel);
355  if (pp == 0.0) {
356  vc[2] = std::complex<double> (0.0, 0.0);
357  vc[3] = std::complex<double> (-hel * sqh, 0.0);
358  vc[4] = std::complex<double> (0.0, nsvahl * sqh);
359  vc[5] = std::complex<double> (hel0, 0.0);
360  } else {
361  emp = p[0] / (vmass * pp);
362  vc[2] = std::complex<double> (hel0 * pp / vmass, 0.0);
363  vc[5] = std::complex<double> (hel0 * p[3] * emp + hel * pt / pp * sqh, 0.0);
364  if (pt != 0.0) {
365  pzpt = p[3] / (pp * pt) * sqh * hel;
366  vc[3] = std::complex<double> (hel0 * p[1] * emp - p[1] * pzpt, -nsvahl *
367  p[2] / pt * sqh);
368  vc[4] = std::complex<double> (hel0 * p[2] * emp - p[2] * pzpt, nsvahl *
369  p[1] / pt * sqh);
370  } else {
371  vc[3] = std::complex<double> (-hel * sqh, 0.0);
372  vc[4] = std::complex<double> (0.0, nsvahl * Sgn(sqh, p[3]));
373  }
374  }
375  } else {
376  pp = p[0];
377  pt = sqrt((p[1] * p[1]) + (p[2] * p[2]));
378  vc[2] = std::complex<double> (0.0, 0.0);
379  vc[5] = std::complex<double> (hel * pt / pp * sqh, 0.0);
380  if (pt != 0.0) {
381  pzpt = p[3] / (pp * pt) * sqh * hel;
382  vc[3] = std::complex<double> (-p[1] * pzpt, -nsv * p[2] / pt * sqh);
383  vc[4] = std::complex<double> (-p[2] * pzpt, nsv * p[1] / pt * sqh);
384  } else {
385  vc[3] = std::complex<double> (-hel * sqh, 0.0);
386  vc[4] = std::complex<double> (0.0, nsv * Sgn(sqh, p[3]));
387  }
388  }
389  return;
390 }
391 
392 void eeWW::sxxxxx(double p[4], int nss, std::complex<double> sc[3])
393 {
394  sc[2] = std::complex<double> (1.00, 0.00);
395  sc[0] = std::complex<double> (p[0] * nss, p[3] * nss);
396  sc[1] = std::complex<double> (p[1] * nss, p[2] * nss);
397  return;
398 }
399 
400 void eeWW::oxxxxx(double p[4], double fmass, int nhel, int nsf, std::complex<double> fo[6])
401 {
402  std::complex<double> chi[2];
403  double sf[2], sfomeg[2], omega[2], pp, pp3, sqp0p3, sqm[2];
404  int nh, ip, im;
405  fo[0] = std::complex<double> (p[0] * nsf, p[3] * nsf);
406  fo[1] = std::complex<double> (p[1] * nsf, p[2] * nsf);
407  nh = nhel * nsf;
408  if (fmass != 0.000) {
409  pp = std::min(p[0], sqrt((p[1] * p[1]) + (p[2] * p[2]) + (p[3] * p[3])));
410  if (pp == 0.000) {
411  sqm[0] = sqrt(std::abs(fmass));
412  sqm[1] = Sgn(sqm[0], fmass);
413  ip = -((1 - nh) / 2) * nhel;
414  im = (1 + nh) / 2 * nhel;
415  fo[2] = im * sqm[std::abs(ip)];
416  fo[3] = ip * nsf * sqm[std::abs(ip)];
417  fo[4] = im * nsf * sqm[std::abs(im)];
418  fo[5] = ip * sqm[std::abs(im)];
419  } else {
420  pp = std::min(p[0], sqrt((p[1] * p[1]) + (p[2] * p[2]) + (p[3] * p[3])));
421  sf[0] = double(1 + nsf + (1 - nsf) * nh) * 0.5;
422  sf[1] = double(1 + nsf - (1 - nsf) * nh) * 0.5;
423  omega[0] = sqrt(p[0] + pp);
424  omega[1] = fmass / omega[0];
425  ip = (1 + nh) / 2;
426  im = (1 - nh) / 2;
427  sfomeg[0] = sf[0] * omega[ip];
428  sfomeg[1] = sf[1] * omega[im];
429  pp3 = std::max(pp + p[3], 0.00);
430  chi[0] = std::complex<double> (sqrt(pp3 * 0.5 / pp), 0.00);
431  if (pp3 == 0.00) {
432  chi[1] = std::complex<double> (-nh, 0.00);
433  } else {
434  chi[1] = std::complex<double> (nh * p[1], -p[2]) / sqrt(2.0 * pp * pp3);
435  }
436  fo[2] = sfomeg[1] * chi[im];
437  fo[3] = sfomeg[1] * chi[ip];
438  fo[4] = sfomeg[0] * chi[im];
439  fo[5] = sfomeg[0] * chi[ip];
440  }
441  } else {
442  if ((p[1] == 0.00) and (p[2] == 0.00) and (p[3] < 0.00)) {
443  sqp0p3 = 0.00;
444  } else {
445  sqp0p3 = sqrt(std::max(p[0] + p[3], 0.00)) * nsf;
446  }
447  chi[0] = std::complex<double> (sqp0p3, 0.00);
448  if (sqp0p3 == 0.000) {
449  chi[1] = std::complex<double> (-nhel, 0.00) * sqrt(2.0 * p[0]);
450  } else {
451  chi[1] = std::complex<double> (nh * p[1], -p[2]) / sqp0p3;
452  }
453  if (nh == 1) {
454  fo[2] = chi[0];
455  fo[3] = chi[1];
456  fo[4] = std::complex<double> (0.00, 0.00);
457  fo[5] = std::complex<double> (0.00, 0.00);
458  } else {
459  fo[2] = std::complex<double> (0.00, 0.00);
460  fo[3] = std::complex<double> (0.00, 0.00);
461  fo[4] = chi[1];
462  fo[5] = chi[0];
463  }
464  }
465  return;
466 }
467 
468 void eeWW::VVV1_0(std::complex<double> V1[], std::complex<double> V2[],
469  std::complex<double> V3[], std::complex<double> COUP, std::complex<double>
470  & vertex)
471 {
472  static std::complex<double> cI = std::complex<double> (0., 1.);
473  std::complex<double> TMP2;
474  double P1[4];
475  std::complex<double> TMP10;
476  double P2[4];
477  std::complex<double> TMP7;
478  double P3[4];
479  std::complex<double> TMP6;
480  std::complex<double> TMP5;
481  std::complex<double> TMP4;
482  std::complex<double> TMP9;
483  std::complex<double> TMP3;
484  std::complex<double> TMP8;
485  P1[0] = V1[0].real();
486  P1[1] = V1[1].real();
487  P1[2] = V1[1].imag();
488  P1[3] = V1[0].imag();
489  P2[0] = V2[0].real();
490  P2[1] = V2[1].real();
491  P2[2] = V2[1].imag();
492  P2[3] = V2[0].imag();
493  P3[0] = V3[0].real();
494  P3[1] = V3[1].real();
495  P3[2] = V3[1].imag();
496  P3[3] = V3[0].imag();
497  TMP9 = (V1[2] * P2[0] - V1[3] * P2[1] - V1[4] * P2[2] - V1[5] * P2[3]);
498  TMP8 = (V3[2] * V2[2] - V3[3] * V2[3] - V3[4] * V2[4] - V3[5] * V2[5]);
499  TMP5 = (P1[0] * V2[2] - P1[1] * V2[3] - P1[2] * V2[4] - P1[3] * V2[5]);
500  TMP4 = (V3[2] * P2[0] - V3[3] * P2[1] - V3[4] * P2[2] - V3[5] * P2[3]);
501  TMP7 = (P3[0] * V2[2] - P3[1] * V2[3] - P3[2] * V2[4] - P3[3] * V2[5]);
502  TMP6 = (V3[2] * V1[2] - V3[3] * V1[3] - V3[4] * V1[4] - V3[5] * V1[5]);
503  TMP10 = (P3[0] * V1[2] - P3[1] * V1[3] - P3[2] * V1[4] - P3[3] * V1[5]);
504  TMP3 = (V3[2] * P1[0] - V3[3] * P1[1] - V3[4] * P1[2] - V3[5] * P1[3]);
505  TMP2 = (V2[2] * V1[2] - V2[3] * V1[3] - V2[4] * V1[4] - V2[5] * V1[5]);
506  vertex = COUP * (TMP2 * (-cI * (TMP3) + cI * (TMP4)) + (TMP6 * (-cI * (TMP7)
507  + cI * (TMP5)) + TMP8 * (-cI * (TMP9) + cI * (TMP10))));
508 }
509 
510 void eeWW::FFV4_3(std::complex<double> F1[], std::complex<double> F2[],
511  std::complex<double> COUP, double M3, double W3, std::complex<double> V3[])
512 {
513  static std::complex<double> cI = std::complex<double> (0., 1.);
514  std::complex<double> denom;
515  std::complex<double> TMP11;
516  double P3[4];
517  double OM3;
518  std::complex<double> TMP1;
519  OM3 = 0.;
520  if (M3 != 0.)
521  OM3 = 1. / (M3 * M3);
522  V3[0] = +F1[0] + F2[0];
523  V3[1] = +F1[1] + F2[1];
524  P3[0] = -V3[0].real();
525  P3[1] = -V3[1].real();
526  P3[2] = -V3[1].imag();
527  P3[3] = -V3[0].imag();
528  TMP1 = (F1[2] * (F2[4] * (P3[0] + P3[3]) + F2[5] * (P3[1] + cI * (P3[2]))) +
529  F1[3] * (F2[4] * (P3[1] - cI * (P3[2])) + F2[5] * (P3[0] - P3[3])));
530  TMP11 = (F1[4] * (F2[2] * (P3[0] - P3[3]) - F2[3] * (P3[1] + cI * (P3[2]))) +
531  F1[5] * (F2[2] * (+cI * (P3[2]) - P3[1]) + F2[3] * (P3[0] + P3[3])));
532  denom = COUP / ((P3[0] * P3[0]) - (P3[1] * P3[1]) - (P3[2] * P3[2]) - (P3[3] *
533  P3[3]) - M3 * (M3 - cI * W3));
534  V3[2] = denom * (-2. * cI) * (OM3 * -1. / 2. * P3[0] * (TMP1 + 2. * (TMP11)) +
535  (+1. / 2. * (F1[2] * F2[4] + F1[3] * F2[5]) + F1[4] * F2[2] + F1[5] *
536  F2[3]));
537  V3[3] = denom * (-2. * cI) * (OM3 * -1. / 2. * P3[1] * (TMP1 + 2. * (TMP11)) +
538  (-1. / 2. * (F1[2] * F2[5] + F1[3] * F2[4]) + F1[4] * F2[3] + F1[5] *
539  F2[2]));
540  V3[4] = denom * 2. * cI * (OM3 * 1. / 2. * P3[2] * (TMP1 + 2. * (TMP11)) +
541  (+1. / 2. * cI * (F1[2] * F2[5]) - 1. / 2. * cI * (F1[3] * F2[4]) - cI *
542  (F1[4] * F2[3]) + cI * (F1[5] * F2[2])));
543  V3[5] = denom * 2. * cI * (OM3 * 1. / 2. * P3[3] * (TMP1 + 2. * (TMP11)) +
544  (+1. / 2. * (F1[2] * F2[4]) - 1. / 2. * (F1[3] * F2[5]) - F1[4] * F2[2] +
545  F1[5] * F2[3]));
546 }
547 
548 void eeWW::FFV2_3(std::complex<double> F1[], std::complex<double> F2[],
549  std::complex<double> COUP, double M3, double W3, std::complex<double> V3[])
550 {
551  static std::complex<double> cI = std::complex<double> (0., 1.);
552  std::complex<double> denom;
553  std::complex<double> TMP1;
554  double P3[4];
555  double OM3;
556  OM3 = 0.;
557  if (M3 != 0.)
558  OM3 = 1. / (M3 * M3);
559  V3[0] = +F1[0] + F2[0];
560  V3[1] = +F1[1] + F2[1];
561  P3[0] = -V3[0].real();
562  P3[1] = -V3[1].real();
563  P3[2] = -V3[1].imag();
564  P3[3] = -V3[0].imag();
565  TMP1 = (F1[2] * (F2[4] * (P3[0] + P3[3]) + F2[5] * (P3[1] + cI * (P3[2]))) +
566  F1[3] * (F2[4] * (P3[1] - cI * (P3[2])) + F2[5] * (P3[0] - P3[3])));
567  denom = COUP / ((P3[0] * P3[0]) - (P3[1] * P3[1]) - (P3[2] * P3[2]) - (P3[3] *
568  P3[3]) - M3 * (M3 - cI * W3));
569  V3[2] = denom * (-cI) * (F1[2] * F2[4] + F1[3] * F2[5] - P3[0] * OM3 * TMP1);
570  V3[3] = denom * (-cI) * (-F1[2] * F2[5] - F1[3] * F2[4] - P3[1] * OM3 *
571  TMP1);
572  V3[4] = denom * (-cI) * (-cI * (F1[2] * F2[5]) + cI * (F1[3] * F2[4]) - P3[2]
573  * OM3 * TMP1);
574  V3[5] = denom * (-cI) * (F1[3] * F2[5] - F1[2] * F2[4] - P3[3] * OM3 * TMP1);
575 }
576 
577 void eeWW::FFV2_4_3(std::complex<double> F1[], std::complex<double> F2[],
578  std::complex<double> COUP1, std::complex<double> COUP2, double M3, double
579  W3, std::complex<double> V3[])
580 {
581  int i;
582  std::complex<double> Vtmp[6];
583  FFV2_3(F1, F2, COUP1, M3, W3, V3);
584  FFV4_3(F1, F2, COUP2, M3, W3, Vtmp);
585  i = 2;
586  while (i < 6) {
587  V3[i] = V3[i] + Vtmp[i];
588  i++;
589  }
590 }
591 
592 void eeWW::FFV1P0_3(std::complex<double> F1[], std::complex<double> F2[],
593  std::complex<double> COUP, double M3, double W3, std::complex<double> V3[])
594 {
595  static std::complex<double> cI = std::complex<double> (0., 1.);
596  double P3[4];
597  std::complex<double> denom;
598  V3[0] = +F1[0] + F2[0];
599  V3[1] = +F1[1] + F2[1];
600  P3[0] = -V3[0].real();
601  P3[1] = -V3[1].real();
602  P3[2] = -V3[1].imag();
603  P3[3] = -V3[0].imag();
604  denom = COUP / ((P3[0] * P3[0]) - (P3[1] * P3[1]) - (P3[2] * P3[2]) - (P3[3] *
605  P3[3]) - M3 * (M3 - cI * W3));
606  V3[2] = denom * (-cI) * (F1[2] * F2[4] + F1[3] * F2[5] + F1[4] * F2[2] +
607  F1[5] * F2[3]);
608  V3[3] = denom * (-cI) * (F1[4] * F2[3] + F1[5] * F2[2] - F1[2] * F2[5] -
609  F1[3] * F2[4]);
610  V3[4] = denom * (-cI) * (-cI * (F1[2] * F2[5] + F1[5] * F2[2]) + cI * (F1[3]
611  * F2[4] + F1[4] * F2[3]));
612  V3[5] = denom * (-cI) * (F1[3] * F2[5] + F1[4] * F2[2] - F1[2] * F2[4] -
613  F1[5] * F2[3]);
614 }
615 
616 void eeWW::FFV2_1(std::complex<double> F2[], std::complex<double> V3[],
617  std::complex<double> COUP, double M1, double W1, std::complex<double> F1[])
618 {
619  static std::complex<double> cI = std::complex<double> (0., 1.);
620  double P1[4];
621  std::complex<double> denom;
622  F1[0] = +F2[0] + V3[0];
623  F1[1] = +F2[1] + V3[1];
624  P1[0] = -F1[0].real();
625  P1[1] = -F1[1].real();
626  P1[2] = -F1[1].imag();
627  P1[3] = -F1[0].imag();
628  denom = COUP / ((P1[0] * P1[0]) - (P1[1] * P1[1]) - (P1[2] * P1[2]) - (P1[3] *
629  P1[3]) - M1 * (M1 - cI * W1));
630  F1[2] = denom * cI * M1 * (F2[4] * (V3[2] + V3[5]) + F2[5] * (V3[3] + cI *
631  (V3[4])));
632  F1[3] = denom * - cI * M1 * (F2[4] * (+cI * (V3[4]) - V3[3]) + F2[5] * (V3[5]
633  - V3[2]));
634  F1[4] = denom * (-cI) * (F2[4] * (P1[0] * (V3[2] + V3[5]) + (P1[1] * (+cI *
635  (V3[4]) - V3[3]) + (P1[2] * (-1.) * (V3[4] + cI * (V3[3])) - P1[3] *
636  (V3[2] + V3[5])))) + F2[5] * (P1[0] * (V3[3] + cI * (V3[4])) + (P1[1] *
637  (V3[5] - V3[2]) + (P1[2] * (-cI * (V3[2]) + cI * (V3[5])) - P1[3] *
638  (V3[3] + cI * (V3[4]))))));
639  F1[5] = denom * (-cI) * (F2[4] * (P1[0] * (V3[3] - cI * (V3[4])) + (P1[1] *
640  (-1.) * (V3[2] + V3[5]) + (P1[2] * (+cI * (V3[2] + V3[5])) + P1[3] *
641  (V3[3] - cI * (V3[4]))))) + F2[5] * (P1[0] * (V3[2] - V3[5]) + (P1[1] *
642  (-1.) * (V3[3] + cI * (V3[4])) + (P1[2] * (+cI * (V3[3]) - V3[4]) + P1[3]
643  * (V3[2] - V3[5])))));
644 }
645 
646 void eeWW::FFV2_0(std::complex<double> F1[], std::complex<double> F2[],
647  std::complex<double> V3[], std::complex<double> COUP, std::complex<double>
648  & vertex)
649 {
650  static std::complex<double> cI = std::complex<double> (0., 1.);
651  std::complex<double> TMP0;
652  TMP0 = (F1[2] * (F2[4] * (V3[2] + V3[5]) + F2[5] * (V3[3] + cI * (V3[4]))) +
653  F1[3] * (F2[4] * (V3[3] - cI * (V3[4])) + F2[5] * (V3[2] - V3[5])));
654  vertex = COUP * - cI * TMP0;
655 }
656 
657 //==========================================================================
658 // Class member functions for calculating the matrix elements for
659 // Process: e+ e- > w+ w- WEIGHTED<=4 @1
660 // * Decay: w+ > mu+ vm WEIGHTED<=2
661 // * Decay: w- > u~ d WEIGHTED<=2
662 
663 //--------------------------------------------------------------------------
664 
665 //--------------------------------------------------------------------------
666 // Evaluate |M|^2, part independent of incoming flavour.
667 
668 void eeWW::sigmaKin()
669 {
670  // Set the parameters which change event by event
671 
672  // Reset color flows
673  for (int i = 0; i < 1; i++)
674  jamp2[0][i] = 0.;
675 
676  // Local variables and constants
677  const int ncomb = 64;
678  static bool goodhel[ncomb] = {ncomb * false};
679  static int ntry = 0, sum_hel = 0, ngood = 0;
680  static int igood[ncomb];
681  static int jhel;
682  // std::complex<double> * * wfs;
683  double t[nprocesses];
684 
685  // Helicities for the process
686  static const int helicities[ncomb][nexternal] = {
687  {-1, -1, -1, -1, -1, -1},
688  {-1, -1, -1, -1, -1, 1},
689  {-1, -1, -1, -1, 1, -1},
690  {-1, -1, -1, -1, 1, 1},
691  {-1, -1, -1, 1, -1, -1},
692  {-1, -1, -1, 1, -1, 1},
693  {-1, -1, -1, 1, 1, -1},
694  {-1, -1, -1, 1, 1, 1},
695  {-1, -1, 1, -1, -1, -1},
696  {-1, -1, 1, -1, -1, 1},
697  {-1, -1, 1, -1, 1, -1},
698  {-1, -1, 1, -1, 1, 1},
699  {-1, -1, 1, 1, -1, -1},
700  {-1, -1, 1, 1, -1, 1},
701  {-1, -1, 1, 1, 1, -1},
702  {-1, -1, 1, 1, 1, 1},
703  {-1,1, -1, -1, -1, -1},
704  {-1, 1, -1, -1, -1, 1},
705  {-1, 1, -1, -1, 1, -1},
706  {-1, 1, -1, -1, 1, 1},
707  {-1, 1, -1, 1, -1, -1},
708  {-1, 1, -1, 1, -1, 1},
709  {-1, 1, -1, 1, 1, -1},
710  {-1, 1, -1, 1, 1, 1},
711  {-1, 1, 1, -1, -1, -1},
712  {-1, 1, 1, -1, -1, 1},
713  {-1, 1, 1, -1, 1, -1},
714  {-1, 1, 1, -1, 1, 1},
715  {-1, 1, 1, 1, -1, -1},
716  {-1, 1, 1, 1, -1, 1},
717  {-1, 1, 1, 1, 1, -1},
718  {-1, 1, 1, 1, 1, 1},
719  {1, -1, -1, -1, -1, -1},
720  {1, -1, -1, -1, -1, 1},
721  {1, -1, -1, -1, 1, -1},
722  {1, -1, -1, -1, 1, 1},
723  {1, -1, -1, 1, -1, -1},
724  {1, -1, -1, 1, -1, 1},
725  {1, -1, -1, 1, 1, -1},
726  {1, -1, -1, 1, 1, 1},
727  {1, -1, 1, -1, -1, -1},
728  {1, -1, 1, -1, -1, 1},
729  {1, -1, 1, -1, 1, -1},
730  {1, -1, 1, -1, 1, 1},
731  {1, -1, 1, 1, -1, -1},
732  {1, -1, 1, 1, -1, 1},
733  {1, -1, 1, 1, 1, -1},
734  {1, -1, 1, 1, 1, 1},
735  {1, 1, -1, -1, -1, -1},
736  {1, 1, -1, -1, -1, 1},
737  {1, 1, -1, -1, 1, -1},
738  {1, 1, -1, -1, 1, 1},
739  {1, 1, -1, 1, -1, -1},
740  {1, 1, -1, 1, -1, 1},
741  {1, 1, -1, 1, 1, -1},
742  {1, 1, -1, 1, 1, 1},
743  {1, 1, 1, -1, -1, -1},
744  {1, 1, 1, -1, -1, 1},
745  {1, 1, 1, -1, 1, -1},
746  {1, 1, 1, -1, 1, 1},
747  {1, 1, 1, 1, -1, -1},
748  {1,1, 1, 1, -1, 1},
749  {1, 1, 1, 1, 1, -1},
750  {1, 1, 1, 1, 1, 1}};
751  // Denominators: spins, colors and identical particles
752  const int denominators[nprocesses] = {4};
753 
754  ntry = ntry + 1;
755 
756  // Reset the matrix elements
757  for (int i = 0; i < nprocesses; i++) {
758  matrix_element[i] = 0.;
759  }
760 
761  // Define permutation
762  for (int i = 0; i < nexternal; i++) {
763  perm[i] = i;
764  }
765 
766  if (sum_hel == 0 || ntry < 10) {
767  // Calculate the matrix element for all helicities
768  for (int ihel = 0; ihel < ncomb; ihel++) {
769  if (goodhel[ihel] || ntry < 2) {
770  calculate_wavefunctions(perm, helicities[ihel]);
771  t[0] = matrix_1_epem_wpwm_wp_mupvm_wm_uxd();
772  double tsum = 0;
773  for (int iproc = 0; iproc < nprocesses; iproc++) {
774  matrix_element[iproc] += t[iproc];
775  tsum += t[iproc];
776  }
777  // Store which helicities give non-zero result
778  if (tsum != 0. && !goodhel[ihel]) {
779  goodhel[ihel] = true;
780  ngood++;
781  igood[ngood] = ihel;
782  }
783  }
784  }
785  jhel = 0;
786  sum_hel = std::min(sum_hel, ngood);
787  } else {
788  // Only use the "good" helicities
789  for (int j = 0; j < sum_hel; j++) {
790  jhel++;
791  if (jhel >= ngood) jhel = 0;
792  double hwgt = double(ngood) / double(sum_hel);
793  int ihel = igood[jhel];
794  calculate_wavefunctions(perm, helicities[ihel]);
795  t[0] = matrix_1_epem_wpwm_wp_mupvm_wm_uxd();
796 
797  for (int iproc = 0; iproc < nprocesses; iproc++) {
798  matrix_element[iproc] += t[iproc] * hwgt;
799  }
800  }
801  }
802 
803  for (int i = 0; i < nprocesses; i++)
804  matrix_element[i] /= denominators[i];
805 }
806 
807 //--------------------------------------------------------------------------
808 // Evaluate |M|^2, including incoming flavour dependence.
809 
810 double eeWW::sigmaHat()
811 {
812  // Select between the different processes
813  if (id1 == -11 && id2 == 11) {
814  // Add matrix elements for processes with beams (-11, 11)
815  return matrix_element[0];
816  } else {
817  // Return 0 if not correct initial state assignment
818  return 0.;
819  }
820 }
821 
822 //==========================================================================
823 // Private class member functions
824 
825 //--------------------------------------------------------------------------
826 // Evaluate |M|^2 for each subprocess
827 
828 void eeWW::calculate_wavefunctions(const int perm[], const int hel[])
829 {
830  // Calculate wavefunctions for all processes
831 
832  // Calculate all wavefunctions
833  oxxxxx(p[perm[0]], mME[0], hel[0], -1, w[0]);
834  ixxxxx(p[perm[1]], mME[1], hel[1], +1, w[1]);
835  ixxxxx(p[perm[2]], mME[2], hel[2], -1, w[2]);
836  oxxxxx(p[perm[3]], mME[3], hel[3], +1, w[3]);
837  FFV2_3(w[2], w[3], GC_100, MW, Gamma_W, w[4]);
838  ixxxxx(p[perm[4]], mME[4], hel[4], -1, w[5]);
839  oxxxxx(p[perm[5]], mME[5], hel[5], +1, w[6]);
840  FFV2_3(w[5], w[6], GC_100, MW, Gamma_W, w[7]);
841  FFV1P0_3(w[1], w[0], GC_3, ZERO, ZERO, w[8]);
842  FFV2_4_3(w[1], w[0], -GC_51, GC_59, MZ, Gamma_Z,
843  w[9]);
844  FFV2_1(w[0], w[4], GC_100, ZERO, ZERO, w[10]);
845 
846  // Calculate all amplitudes
847  // Amplitude(s) for diagram number 0
848  VVV1_0(w[8], w[7], w[4], -GC_3, amp[0]);
849  VVV1_0(w[7], w[4], w[9], GC_53, amp[1]);
850  FFV2_0(w[1], w[10], w[7], GC_100, amp[2]);
851 
852 }
853 
854 double eeWW::matrix_1_epem_wpwm_wp_mupvm_wm_uxd()
855 {
856  int i, j;
857  // Local variables
858 // const int ngraphs = 3;
859  const int ncolor = 1;
860  std::complex<double> ztemp;
861  std::complex<double> jamp[ncolor];
862  // The color matrix;
863  static const double denom[ncolor] = {1};
864  static const double cf[ncolor][ncolor] = {
865  {3}
866  };
867 
868  // Calculate color flows
869  jamp[0] = -amp[0] - amp[1] - amp[2];
870 
871  // Sum and square the color flows to get the matrix element
872  double matrix = 0;
873  for (i = 0; i < ncolor; i++) {
874  ztemp = 0.;
875  for (j = 0; j < ncolor; j++)
876  ztemp = ztemp + cf[i][j] * jamp[j];
877  matrix = matrix + real(ztemp * conj(jamp[i])) / denom[i];
878  }
879 
880  // Store the leading color flows for choice of color
881  for (i = 0; i < ncolor; i++)
882  jamp2[0][i] += real(jamp[i] * conj(jamp[i]));
883 
884  return matrix;
885 }
eeWW::sxxxxx
void sxxxxx(double p[4], int nss, std::complex< double > sc[3])
Definition: OptimizedObservablesSMEFTd6.cpp:392
eeWW::sigmaKin
virtual void sigmaKin()
Definition: OptimizedObservablesSMEFTd6.cpp:668
eeWW::ZERO
double ZERO
Definition: OptimizedObservablesSMEFTd6.h:37
eeWW::complexi
std::complex< double > complexi
Definition: OptimizedObservablesSMEFTd6.h:47
eeWW::sw
double sw
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::MH
double MH
Definition: OptimizedObservablesSMEFTd6.h:42
eeWW::GC_51
std::complex< double > GC_51
Definition: OptimizedObservablesSMEFTd6.h:51
eeWW::Gamma_W
double Gamma_W
Definition: OptimizedObservablesSMEFTd6.h:39
eeWW::vev
double vev
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::matrix_1_epem_wpwm_wp_mupvm_wm_uxd
double matrix_1_epem_wpwm_wp_mupvm_wm_uxd()
Definition: OptimizedObservablesSMEFTd6.cpp:854
eeWW::G2
double G2
Definition: OptimizedObservablesSMEFTd6.h:49
eeWW::ee2
double ee2
Definition: OptimizedObservablesSMEFTd6.h:46
eeWW::conjg__CKM3x3
double conjg__CKM3x3
Definition: OptimizedObservablesSMEFTd6.h:43
eeWW::FFV2_4_3
void FFV2_4_3(std::complex< double > F1[], std::complex< double > F2[], std::complex< double > COUP1, std::complex< double > COUP2, double M3, double W3, std::complex< double > V3[])
Definition: OptimizedObservablesSMEFTd6.cpp:577
eeWW::FFV2_1
void FFV2_1(std::complex< double > F2[], std::complex< double > V3[], std::complex< double > COUP, double M1, double W1, std::complex< double > F1[])
Definition: OptimizedObservablesSMEFTd6.cpp:616
eeWW::Sgn
double Sgn(double e, double f)
Definition: OptimizedObservablesSMEFTd6.cpp:205
eeWW::MTA
double MTA
Definition: OptimizedObservablesSMEFTd6.h:42
eeWW::MT
double MT
Definition: OptimizedObservablesSMEFTd6.h:42
eeWW::Gamma_Z
double Gamma_Z
Definition: OptimizedObservablesSMEFTd6.h:39
eeWW::MB
double MB
Definition: OptimizedObservablesSMEFTd6.h:42
StandardModel.h
eeWW::id1
int id1
Definition: OptimizedObservablesSMEFTd6.h:131
eeWW::lam
double lam
Definition: OptimizedObservablesSMEFTd6.h:45
StandardModel
A model class for the Standard Model.
Definition: StandardModel.h:477
eeWW::GC_53
std::complex< double > GC_53
Definition: OptimizedObservablesSMEFTd6.h:51
eeWW::MZ4
double MZ4
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::MW2
double MW2
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::computeThValue
double computeThValue()
hep-ph/9512380v2
Definition: OptimizedObservablesSMEFTd6.cpp:17
eeWW::nprocesses
static const int nprocesses
Definition: OptimizedObservablesSMEFTd6.h:103
eeWW::VVV1_0
void VVV1_0(std::complex< double > V1[], std::complex< double > V2[], std::complex< double > V3[], std::complex< double > COUP, std::complex< double > &vertex)
Definition: OptimizedObservablesSMEFTd6.cpp:468
eeWW::G
double G
Definition: OptimizedObservablesSMEFTd6.h:49
eeWW::ee
double ee
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::MZ2
double MZ2
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::vev2
double vev2
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::Gf
double Gf
Definition: OptimizedObservablesSMEFTd6.h:41
eeWW::calculate_wavefunctions
void calculate_wavefunctions(const int perm[], const int hel[])
Definition: OptimizedObservablesSMEFTd6.cpp:828
eeWW::GC_59
std::complex< double > GC_59
Definition: OptimizedObservablesSMEFTd6.h:51
eeWW::sqrt__sw2
double sqrt__sw2
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::perm
int perm[nexternal]
Definition: OptimizedObservablesSMEFTd6.h:107
eeWW::jamp2
double * jamp2[nprocesses]
Definition: OptimizedObservablesSMEFTd6.h:122
eeWW::ymb
double ymb
Definition: OptimizedObservablesSMEFTd6.h:40
eeWW::nexternal
static const int nexternal
Definition: OptimizedObservablesSMEFTd6.h:102
eeWW::g1
double g1
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::updateParameters
void updateParameters()
Definition: OptimizedObservablesSMEFTd6.cpp:68
gslpp::sqrt
complex sqrt(const complex &z)
Definition: gslpp_complex.cpp:385
HeffDB1.h
eeWW::ymtau
double ymtau
Definition: OptimizedObservablesSMEFTd6.h:40
eeWW::aEW
double aEW
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::FFV1P0_3
void FFV1P0_3(std::complex< double > F1[], std::complex< double > F2[], std::complex< double > COUP, double M3, double W3, std::complex< double > V3[])
Definition: OptimizedObservablesSMEFTd6.cpp:592
eeWW::gw
double gw
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::oxxxxx
void oxxxxx(double p[4], double fmass, int nhel, int nsf, std::complex< double > fo[6])
Definition: OptimizedObservablesSMEFTd6.cpp:400
eeWW::MH2
double MH2
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::I1x33
std::complex< double > I1x33
Definition: OptimizedObservablesSMEFTd6.h:47
eeWW::w
std::complex< double > w[nwavefuncs][18]
Definition: OptimizedObservablesSMEFTd6.h:113
eeWW::sqrt__aEW
double sqrt__aEW
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::I3x33
std::complex< double > I3x33
Definition: OptimizedObservablesSMEFTd6.h:47
eeWW::ymt
double ymt
Definition: OptimizedObservablesSMEFTd6.h:40
indices
unsigned int indices
Definition: EvolDF1.h:21
eeWW::sigmaHat
virtual double sigmaHat()
Definition: OptimizedObservablesSMEFTd6.cpp:810
eeWW::txxxxx
void txxxxx(double p[4], double tmass, int nhel, int nst, std::complex< double > fi[18])
Definition: OptimizedObservablesSMEFTd6.cpp:210
eeWW::yt
double yt
Definition: OptimizedObservablesSMEFTd6.h:46
eeWW::p
std::vector< double * > p
Definition: OptimizedObservablesSMEFTd6.h:128
eeWW::GC_3
std::complex< double > GC_3
Definition: OptimizedObservablesSMEFTd6.h:51
eeWW::mME
std::vector< double > mME
Definition: OptimizedObservablesSMEFTd6.h:125
eeWW::muH
double muH
Definition: OptimizedObservablesSMEFTd6.h:46
eeWW::cw
double cw
Definition: OptimizedObservablesSMEFTd6.h:45
eeWW::setMomenta
void setMomenta(std::vector< double * > &momenta)
Definition: OptimizedObservablesSMEFTd6.h:83
eeWW::cw2
double cw2
Definition: OptimizedObservablesSMEFTd6.h:46
eeWW::ixxxxx
void ixxxxx(double p[4], double fmass, int nhel, int nsf, std::complex< double > fi[6])
Definition: OptimizedObservablesSMEFTd6.cpp:138
eeWW::FFV4_3
void FFV4_3(std::complex< double > F1[], std::complex< double > F2[], std::complex< double > COUP, double M3, double W3, std::complex< double > V3[])
Definition: OptimizedObservablesSMEFTd6.cpp:510
eeWW::id2
int id2
Definition: OptimizedObservablesSMEFTd6.h:131
eeWW::ytau
double ytau
Definition: OptimizedObservablesSMEFTd6.h:46
eeWW::aS
double aS
Definition: OptimizedObservablesSMEFTd6.h:41
ThObservable
A class for a model prediction of an observable.
Definition: ThObservable.h:25
eeWW::FFV2_0
void FFV2_0(std::complex< double > F1[], std::complex< double > F2[], std::complex< double > V3[], std::complex< double > COUP, std::complex< double > &vertex)
Definition: OptimizedObservablesSMEFTd6.cpp:646
eeWW::getMatrixElements
const double * getMatrixElements() const
Definition: OptimizedObservablesSMEFTd6.h:95
eeWW::MW
double MW
Definition: OptimizedObservablesSMEFTd6.h:44
eeWW::zero
double zero
Definition: OptimizedObservablesSMEFTd6.h:37
eeWW::matrix_element
double matrix_element[nprocesses]
Definition: OptimizedObservablesSMEFTd6.h:119
eeWW::FFV2_3
void FFV2_3(std::complex< double > F1[], std::complex< double > F2[], std::complex< double > COUP, double M3, double W3, std::complex< double > V3[])
Definition: OptimizedObservablesSMEFTd6.cpp:548
eeWW::vxxxxx
void vxxxxx(double p[4], double vmass, int nhel, int nsv, std::complex< double > v[6])
Definition: OptimizedObservablesSMEFTd6.cpp:341
eeWW::I2x33
std::complex< double > I2x33
Definition: OptimizedObservablesSMEFTd6.h:47
eeWW::CKM3x3
double CKM3x3
Definition: OptimizedObservablesSMEFTd6.h:43
eeWW::sqrt__aS
double sqrt__aS
Definition: OptimizedObservablesSMEFTd6.h:49
eeWW::conjg__CKM1x1
double conjg__CKM1x1
Definition: OptimizedObservablesSMEFTd6.h:43
eeWW::sw2
double sw2
Definition: OptimizedObservablesSMEFTd6.h:45
OptimizedObservablesSMEFTd6.h
eeWW::aEWM1
double aEWM1
Definition: OptimizedObservablesSMEFTd6.h:41
eeWW::eeWW
eeWW(const StandardModel &SM_i)
Definition: OptimizedObservablesSMEFTd6.cpp:12
eeWW::yb
double yb
Definition: OptimizedObservablesSMEFTd6.h:46
eeWW::GC_100
std::complex< double > GC_100
Definition: OptimizedObservablesSMEFTd6.h:51
eeWW::I4x33
std::complex< double > I4x33
Definition: OptimizedObservablesSMEFTd6.h:47
eeWW::Gamma_T
double Gamma_T
Definition: OptimizedObservablesSMEFTd6.h:39
eeWW::Gamma_H
double Gamma_H
Definition: OptimizedObservablesSMEFTd6.h:39
eeWW::amp
std::complex< double > amp[namplitudes]
Definition: OptimizedObservablesSMEFTd6.h:114
eeWW::MZ
double MZ
Definition: OptimizedObservablesSMEFTd6.h:42