StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
SigmaEW.h
1 // SigmaEW.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2020 Torbjorn Sjostrand.
3 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
4 // Please respect the MCnet Guidelines, see GUIDELINES for details.
5 
6 // Header file for electroweak process differential cross sections.
7 // Contains classes derived from SigmaProcess via Sigma(1/2)Process.
8 
9 #ifndef Pythia8_SigmaEW_H
10 #define Pythia8_SigmaEW_H
11 
12 #include "Pythia8/PythiaComplex.h"
13 #include "Pythia8/SigmaProcess.h"
14 
15 namespace Pythia8 {
16 
17 
18 //==========================================================================
19 
20 // A derived class for q g -> q gamma (q = u, d, s, c, b).
21 // Use massless approximation also for Q since no alternative.
22 
23 class Sigma2qg2qgamma : public Sigma2Process {
24 
25 public:
26 
27  // Constructor.
28  Sigma2qg2qgamma() : sigUS(), sigma0() {}
29 
30  // Calculate flavour-independent parts of cross section.
31  virtual void sigmaKin();
32 
33  // Evaluate d(sigmaHat)/d(tHat).
34  virtual double sigmaHat();
35 
36  // Select flavour, colour and anticolour.
37  virtual void setIdColAcol();
38 
39  // Info on the subprocess.
40  virtual string name() const {return "q g -> q gamma (udscb)";}
41  virtual int code() const {return 201;}
42  virtual string inFlux() const {return "qg";}
43 
44 private:
45 
46  // Values stored for later use.
47  double sigUS, sigma0;
48 
49 };
50 
51 //==========================================================================
52 
53 // A derived class for q qbar -> g gamma.
54 
55 class Sigma2qqbar2ggamma : public Sigma2Process {
56 
57 public:
58 
59  // Constructor.
60  Sigma2qqbar2ggamma() : sigma0() {}
61 
62  // Calculate flavour-independent parts of cross section.
63  virtual void sigmaKin();
64 
65  // Evaluate d(sigmaHat)/d(tHat).
66  virtual double sigmaHat();
67 
68  // Select flavour, colour and anticolour.
69  virtual void setIdColAcol();
70 
71  // Info on the subprocess.
72  virtual string name() const {return "q qbar -> g gamma";}
73  virtual int code() const {return 202;}
74  virtual string inFlux() const {return "qqbarSame";}
75 
76 private:
77 
78  // Values stored for later use.
79  double sigma0;
80 
81 };
82 
83 //==========================================================================
84 
85 // A derived class for g g -> g gamma.
86 
87 class Sigma2gg2ggamma : public Sigma2Process {
88 
89 public:
90 
91  // Constructor.
92  Sigma2gg2ggamma() : chargeSum(), sigma() {}
93 
94  // Initialize process.
95  virtual void initProc();
96 
97  // Calculate flavour-independent parts of cross section.
98  virtual void sigmaKin();
99 
100  // Evaluate d(sigmaHat)/d(tHat).
101  virtual double sigmaHat() {return sigma;}
102 
103  // Select flavour, colour and anticolour.
104  virtual void setIdColAcol();
105 
106  // Info on the subprocess.
107  virtual string name() const {return "g g -> g gamma";}
108  virtual int code() const {return 203;}
109  virtual string inFlux() const {return "gg";}
110 
111 private:
112 
113  // Values stored for later use.
114  double chargeSum, sigma;
115 
116 };
117 
118 //==========================================================================
119 
120 // A derived class for f fbar -> gamma gamma.
121 
122 class Sigma2ffbar2gammagamma : public Sigma2Process {
123 
124 public:
125 
126  // Constructor.
127  Sigma2ffbar2gammagamma() : sigTU(), sigma0() {}
128 
129  // Calculate flavour-independent parts of cross section.
130  virtual void sigmaKin();
131 
132  // Evaluate d(sigmaHat)/d(tHat).
133  virtual double sigmaHat();
134 
135  // Select flavour, colour and anticolour.
136  virtual void setIdColAcol();
137 
138  // Info on the subprocess.
139  virtual string name() const {return "f fbar -> gamma gamma";}
140  virtual int code() const {return 204;}
141  virtual string inFlux() const {return "ffbarSame";}
142 
143 private:
144 
145  // Values stored for later use.
146  double sigTU, sigma0;
147 
148 };
149 
150 //==========================================================================
151 
152 // A derived class for g g -> gamma gamma.
153 
154 class Sigma2gg2gammagamma : public Sigma2Process {
155 
156 public:
157 
158  // Constructor.
159  Sigma2gg2gammagamma() : charge2Sum(), sigma() {}
160 
161  // Initialize process.
162  virtual void initProc();
163 
164  // Calculate flavour-independent parts of cross section.
165  virtual void sigmaKin();
166 
167  // Evaluate d(sigmaHat)/d(tHat).
168  virtual double sigmaHat() {return sigma;}
169 
170  // Select flavour, colour and anticolour.
171  virtual void setIdColAcol();
172 
173  // Info on the subprocess.
174  virtual string name() const {return "g g -> gamma gamma";}
175  virtual int code() const {return 205;}
176  virtual string inFlux() const {return "gg";}
177 
178 private:
179 
180  double charge2Sum, sigma;
181 
182 };
183 
184 //==========================================================================
185 
186 // A derived class for f f' -> f f' via t-channel gamma*/Z0 exchange.
187 
188 class Sigma2ff2fftgmZ : public Sigma2Process {
189 
190 public:
191 
192  // Constructor.
193  Sigma2ff2fftgmZ() : gmZmode(), mZ(), mZS(), thetaWRat(), sigmagmgm(),
194  sigmagmZ(), sigmaZZ() {}
195 
196  // Initialize process.
197  virtual void initProc();
198 
199  // Calculate flavour-independent parts of cross section.
200  virtual void sigmaKin();
201 
202  // Evaluate sigmaHat(sHat).
203  virtual double sigmaHat();
204 
205  // Select flavour, colour and anticolour.
206  virtual void setIdColAcol();
207 
208  // Info on the subprocess.
209  virtual string name() const {return "f f' -> f f' (t-channel gamma*/Z0)";}
210  virtual int code() const {return 211;}
211  virtual string inFlux() const {return "ff";}
212 
213 private:
214 
215  // Z parameters for propagator.
216  int gmZmode;
217  double mZ, mZS, thetaWRat, sigmagmgm, sigmagmZ, sigmaZZ;
218 
219 };
220 
221 //==========================================================================
222 
223 // A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange.
224 
225 class Sigma2ff2fftW : public Sigma2Process {
226 
227 public:
228 
229  // Constructor.
230  Sigma2ff2fftW() : mW(), mWS(), thetaWRat(), sigma0() {}
231 
232  // Initialize process.
233  virtual void initProc();
234 
235  // Calculate flavour-independent parts of cross section.
236  virtual void sigmaKin();
237 
238  // Evaluate sigmaHat(sHat).
239  virtual double sigmaHat();
240 
241  // Select flavour, colour and anticolour.
242  virtual void setIdColAcol();
243 
244  // Info on the subprocess.
245  virtual string name() const {return "f_1 f_2 -> f_3 f_4 (t-channel W+-)";}
246  virtual int code() const {return 212;}
247  virtual string inFlux() const {return "ff";}
248 
249 private:
250 
251  // W parameters for propagator.
252  double mW, mWS, thetaWRat, sigma0;
253 
254 };
255 
256 //==========================================================================
257 
258 // A derived class for q q' -> Q q" via t-channel W+- exchange.
259 // Related to Sigma2ff2fftW class, but with massive matrix elements.
260 
261 class Sigma2qq2QqtW : public Sigma2Process {
262 
263 public:
264 
265  // Constructor.
266  Sigma2qq2QqtW(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn), mW(),
267  mWS(), thetaWRat(), sigma0(), openFracPos(), openFracNeg() {}
268 
269  // Initialize process.
270  virtual void initProc();
271 
272  // Calculate flavour-independent parts of cross section.
273  virtual void sigmaKin();
274 
275  // Evaluate sigmaHat(sHat).
276  virtual double sigmaHat();
277 
278  // Select flavour, colour and anticolour.
279  virtual void setIdColAcol();
280 
281  // Evaluate weight for W decay angles in top decay (else inactive).
282  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
283 
284  // Info on the subprocess.
285  virtual string name() const {return nameSave;}
286  virtual int code() const {return codeSave;}
287  virtual string inFlux() const {return "ff";}
288  virtual int id3Mass() const {return idNew;}
289 
290 private:
291 
292  // Values stored for process type. W parameters for propagator.
293  int idNew, codeSave;
294  string nameSave;
295  double mW, mWS, thetaWRat, sigma0, openFracPos, openFracNeg;
296 
297 };
298 
299 //==========================================================================
300 
301 // A derived class for f fbar -> gamma*/Z0.
302 
303 class Sigma1ffbar2gmZ : public Sigma1Process {
304 
305 public:
306 
307  // Constructor.
308  Sigma1ffbar2gmZ() : gmZmode(), mRes(), GammaRes(), m2Res(), GamMRat(),
309  thetaWRat(), gamSum(), intSum(), resSum(), gamProp(), intProp(),
310  resProp(), particlePtr() {}
311 
312  // Initialize process.
313  virtual void initProc();
314 
315  // Calculate flavour-independent parts of cross section.
316  virtual void sigmaKin();
317 
318  // Evaluate sigmaHat(sHat).
319  virtual double sigmaHat();
320 
321  // Select flavour, colour and anticolour.
322  virtual void setIdColAcol();
323 
324  // Evaluate weight for Z decay angle.
325  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
326 
327  // Info on the subprocess.
328  virtual string name() const {return "f fbar -> gamma*/Z0";}
329  virtual int code() const {return 221;}
330  virtual string inFlux() const {return "ffbarSame";}
331  virtual int resonanceA() const {return 23;}
332 
333 private:
334 
335  // Parameters set at initialization or for each new event.
336  int gmZmode;
337  double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
338  gamSum, intSum, resSum, gamProp, intProp, resProp;
339 
340  // Pointer to properties of the particle species, to access decay channels.
341  ParticleDataEntry* particlePtr;
342 
343 };
344 
345 //==========================================================================
346 
347 // A derived class for f fbar' -> W+-.
348 
349 class Sigma1ffbar2W : public Sigma1Process {
350 
351 public:
352 
353  // Constructor.
354  Sigma1ffbar2W() : mRes(), GammaRes(), m2Res(), GamMRat(), thetaWRat(),
355  sigma0Pos(), sigma0Neg(), particlePtr() {}
356 
357  // Initialize process.
358  virtual void initProc();
359 
360  // Calculate flavour-independent parts of cross section.
361  virtual void sigmaKin();
362 
363  // Evaluate sigmaHat(sHat).
364  virtual double sigmaHat();
365 
366  // Select flavour, colour and anticolour.
367  virtual void setIdColAcol();
368 
369  // Evaluate weight for W decay angle.
370  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
371 
372  // Info on the subprocess.
373  virtual string name() const {return "f fbar' -> W+-";}
374  virtual int code() const {return 222;}
375  virtual string inFlux() const {return "ffbarChg";}
376  virtual int resonanceA() const {return 24;}
377 
378 private:
379 
380  // Parameters set at initialization.
381  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
382 
383  // Pointer to properties of the particle species, to access decay channels.
384  ParticleDataEntry* particlePtr;
385 
386 };
387 
388 //==========================================================================
389 
390 // A derived class for f fbar -> gamma* -> f' fbar', summed over light f'.
391 // Allows pT-ordered evolution for multiparton interactions.
392 
393 class Sigma2ffbar2ffbarsgm : public Sigma2Process {
394 
395 public:
396 
397  // Constructor.
398  Sigma2ffbar2ffbarsgm() : idNew(), sigma0() {}
399 
400  // Calculate flavour-independent parts of cross section.
401  virtual void sigmaKin();
402 
403  // Evaluate sigmaHat(sHat).
404  virtual double sigmaHat();
405 
406  // Select flavour, colour and anticolour.
407  virtual void setIdColAcol();
408 
409  // Info on the subprocess.
410  virtual string name() const {
411  return "f fbar -> f' fbar' (s-channel gamma*)";}
412  virtual int code() const {return 223;}
413  virtual string inFlux() const {return "ffbarSame";}
414  virtual bool isSChannel() const {return true;}
415 
416 private:
417 
418  // Values stored for later use.
419  int idNew;
420  double sigma0;
421 
422 };
423 
424 //==========================================================================
425 
426 // A derived class for f fbar -> gamma*/Z0 -> f' fbar', summed over light f.
427 
428 class Sigma2ffbar2ffbarsgmZ : public Sigma2Process {
429 
430 public:
431 
432  // Constructor.
433  Sigma2ffbar2ffbarsgmZ() : gmZmode(), mRes(), GammaRes(), m2Res(),
434  GamMRat(), thetaWRat(), colQ(), gamSumT(), gamSumL(), intSumT(),
435  intSumL(), intSumA(), resSumT(), resSumL(), resSumA(), gamProp(),
436  intProp(), resProp(), cThe(), particlePtr() {}
437 
438  // Initialize process.
439  virtual void initProc();
440 
441  // Calculate flavour-independent parts of cross section.
442  virtual void sigmaKin();
443 
444  // Evaluate sigmaHat(sHat).
445  virtual double sigmaHat();
446 
447  // Select flavour, colour and anticolour.
448  virtual void setIdColAcol();
449 
450  // Info on the subprocess.
451  virtual string name() const {
452  return "f fbar -> f' fbar' (s-channel gamma*/Z0)";}
453  virtual int code() const {return 224;}
454  virtual string inFlux() const {return "ffbarSame";}
455  virtual bool isSChannel() const {return true;}
456  virtual int idSChannel() const {return 23;}
457  virtual int resonanceA() const {return 23;}
458 
459 private:
460 
461  // Parameters set at initialization or for each new event.
462  int gmZmode;
463  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, colQ,
464  gamSumT, gamSumL, intSumT, intSumL, intSumA, resSumT, resSumL,
465  resSumA, gamProp, intProp, resProp, cThe;
466  vector<int> idVec;
467  vector<double> gamT, gamL, intT, intL, intA, resT, resL, resA, sigTLA;
468 
469  // Pointer to properties of the particle species, to access decay channels.
470  ParticleDataEntry* particlePtr;
471 
472 };
473 
474 //==========================================================================
475 
476 // A derived class for f_1 fbar_2 -> W+- -> f_3 fbar_4, summed over light f.
477 
478 class Sigma2ffbar2ffbarsW : public Sigma2Process {
479 
480 public:
481 
482  // Constructor.
483  Sigma2ffbar2ffbarsW() : id3New(), id4New(), mRes(), GammaRes(), m2Res(),
484  GamMRat(), thetaWRat(), sigma0(), particlePtr() {}
485 
486  // Initialize process.
487  virtual void initProc();
488 
489  // Calculate flavour-independent parts of cross section.
490  virtual void sigmaKin();
491 
492  // Evaluate sigmaHat(sHat).
493  virtual double sigmaHat();
494 
495  // Select flavour, colour and anticolour.
496  virtual void setIdColAcol();
497 
498  // Info on the subprocess.
499  virtual string name() const {
500  return "f_1 fbar_2 -> f_3 fbar_4 (s-channel W+-)";}
501  virtual int code() const {return 225;}
502  virtual string inFlux() const {return "ffbarChg";}
503  virtual bool isSChannel() const {return true;}
504  virtual int idSChannel() const {return 24;}
505  virtual int resonanceA() const {return 24;}
506 
507 private:
508 
509  // Parameters set at initialization or stored for later use.
510  int id3New, id4New;
511  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0;
512 
513  // Pointer to properties of the particle species, to access decay channels.
514  ParticleDataEntry* particlePtr;
515 
516 };
517 
518 //==========================================================================
519 
520 // A derived class for f fbar -> gamma*/Z0 -> F Fbar, for one heavy F.
521 // Allows pT cuts as for other 2 -> 2 processes.
522 
523 class Sigma2ffbar2FFbarsgmZ : public Sigma2Process {
524 
525 public:
526 
527  // Constructor.
528  Sigma2ffbar2FFbarsgmZ(int idIn, int codeIn) : idNew(idIn),
529  codeSave(codeIn), gmZmode(), isPhysical(), ef(), vf(), af(), mRes(),
530  GammaRes(), m2Res(), GamMRat(), thetaWRat(), mr(), betaf(), cosThe(),
531  gamProp(), intProp(), resProp(), openFracPair() {}
532 
533  // Initialize process.
534  virtual void initProc();
535 
536  // Calculate flavour-independent parts of cross section.
537  virtual void sigmaKin();
538 
539  // Evaluate sigmaHat(sHat).
540  virtual double sigmaHat();
541 
542  // Select flavour, colour and anticolour.
543  virtual void setIdColAcol();
544 
545  // Evaluate weight for W decay angles in top decay (else inactive).
546  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
547 
548  // Info on the subprocess.
549  virtual string name() const {return nameSave;}
550  virtual int code() const {return codeSave;}
551  virtual string inFlux() const {return "ffbarSame";}
552  virtual bool isSChannel() const {return true;}
553  virtual int id3Mass() const {return idNew;}
554  virtual int id4Mass() const {return idNew;}
555  virtual int resonanceA() const {return 23;}
556 
557 private:
558 
559  // Values stored for process type. Z parameters for propagator.
560  int idNew, codeSave, gmZmode;
561  string nameSave;
562  bool isPhysical;
563  double ef, vf, af, mRes, GammaRes, m2Res, GamMRat, thetaWRat,
564  mr, betaf, cosThe, gamProp, intProp, resProp, openFracPair;
565 
566 };
567 
568 //==========================================================================
569 
570 // A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
571 // Allows pT cuts as for other 2 -> 2 processes.
572 
573 class Sigma2ffbar2FfbarsW : public Sigma2Process {
574 
575 public:
576 
577  // Constructor.
578  Sigma2ffbar2FfbarsW(int idIn, int idIn2, int codeIn) : idNew(idIn),
579  idNew2(idIn2), codeSave(codeIn), idPartner(), isPhysical(), V2New(),
580  mRes(), GammaRes(), m2Res(), GamMRat(), thetaWRat(), sigma0(),
581  openFracPos(), openFracNeg() {}
582 
583  // Initialize process.
584  virtual void initProc();
585 
586  // Calculate flavour-independent parts of cross section.
587  virtual void sigmaKin();
588 
589  // Evaluate sigmaHat(sHat).
590  virtual double sigmaHat();
591 
592  // Select flavour, colour and anticolour.
593  virtual void setIdColAcol();
594 
595  // Evaluate weight for W decay angles in top decay (else inactive).
596  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
597 
598  // Info on the subprocess.
599  virtual string name() const {return nameSave;}
600  virtual int code() const {return codeSave;}
601  virtual string inFlux() const {return "ffbarChg";}
602  virtual bool isSChannel() const {return true;}
603  virtual int id3Mass() const {return idNew;}
604  virtual int id4Mass() const {return idPartner;}
605  virtual int resonanceA() const {return 24;}
606 
607 private:
608 
609  // Values stored for process type. W parameters for propagator.
610  int idNew, idNew2, codeSave, idPartner;
611  string nameSave;
612  bool isPhysical;
613  double V2New, mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
614  openFracPos, openFracNeg;
615 
616 };
617 
618 //==========================================================================
619 
620 // An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
621 
622 class Sigma2ffbargmZWgmZW : public Sigma2Process {
623 
624 public:
625 
626  // Constructor.
627  Sigma2ffbargmZWgmZW() {}
628 
629 protected:
630 
631  // Internal products.
632  Vec4 pRot[7];
633  complex hA[7][7];
634  complex hC[7][7];
635 
636  // Calculate and store internal products.
637  void setupProd( Event& process, int i1, int i2, int i3, int i4,
638  int i5, int i6);
639 
640  // Evaluate the F function of Gunion and Kunszt.
641  complex fGK(int i1, int i2, int i3, int i4, int i5, int i6);
642 
643  // Evaluate the Xi function of Gunion and Kunszt.
644  double xiGK( double tHnow, double uHnow);
645 
646  // Evaluate the Xj function of Gunion and Kunszt.
647  double xjGK( double tHnow, double uHnow);
648 
649 private:
650 
651 };
652 
653 //==========================================================================
654 
655 // A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
656 
657 class Sigma2ffbar2gmZgmZ : public Sigma2ffbargmZWgmZW {
658 
659 public:
660 
661  // Constructor.
662  Sigma2ffbar2gmZgmZ() : gmZmode(), i1(), i2(), i3(), i4(), i5(), i6(),
663  mRes(), GammaRes(), m2Res(), GamMRat(), thetaWRat(), sigma0(), gamSum3(),
664  intSum3(), resSum3(), gamProp3(), intProp3(), resProp3(), gamSum4(),
665  intSum4(), resSum4(), gamProp4(), intProp4(), resProp4(), c3LL(), c3LR(),
666  c3RL(), c3RR(), c4LL(), c4LR(), c4RL(), c4RR(), flavWt(),
667  particlePtr() {}
668 
669  // Initialize process.
670  virtual void initProc();
671 
672  // Calculate flavour-independent parts of cross section.
673  virtual void sigmaKin();
674 
675  // Evaluate d(sigmaHat)/d(tHat).
676  virtual double sigmaHat();
677 
678  // Select flavour, colour and anticolour.
679  virtual void setIdColAcol();
680 
681  // Evaluate weight for simultaneous flavour choices.
682  virtual double weightDecayFlav( Event& process);
683 
684  // Evaluate weight for decay angles of the two gamma*/Z0.
685  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
686 
687  // Info on the subprocess.
688  virtual string name() const {return "f fbar -> gamma*/Z0 gamma*/Z0";}
689  virtual int code() const {return 231;}
690  virtual string inFlux() const {return "ffbarSame";}
691  virtual int id3Mass() const {return 23;}
692  virtual int id4Mass() const {return 23;}
693 
694 private:
695 
696  // Parameters set at initialization or for each new event.
697  int gmZmode, i1, i2, i3, i4, i5, i6;
698  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
699  gamSum3, intSum3, resSum3, gamProp3, intProp3, resProp3,
700  gamSum4, intSum4, resSum4, gamProp4, intProp4, resProp4,
701  c3LL, c3LR, c3RL, c3RR, c4LL, c4LR, c4RL, c4RR, flavWt;
702 
703  // Pointer to properties of the particle species, to access decay channels.
704  ParticleDataEntry* particlePtr;
705 
706 };
707 
708 //==========================================================================
709 
710 // A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
711 
712 class Sigma2ffbar2ZW : public Sigma2ffbargmZWgmZW {
713 
714 public:
715 
716  // Constructor.
717  Sigma2ffbar2ZW() : mW(), widW(), mWS(), mwWS(), sin2thetaW(), cos2thetaW(),
718  thetaWRat(), cotT(), thetaWpt(), thetaWmm(), lun(), lde(), sigma0(),
719  openFracPos(), openFracNeg() {}
720 
721  // Initialize process.
722  virtual void initProc();
723 
724  // Calculate flavour-independent parts of cross section.
725  virtual void sigmaKin();
726 
727  // Evaluate d(sigmaHat)/d(tHat).
728  virtual double sigmaHat();
729 
730  // Select flavour, colour and anticolour.
731  virtual void setIdColAcol();
732 
733  // Evaluate weight for Z0 and W+- decay angles.
734  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
735 
736  // Info on the subprocess.
737  virtual string name() const {return "f fbar' -> Z0 W+- (no gamma*!)";}
738  virtual int code() const {return 232;}
739  virtual string inFlux() const {return "ffbarChg";}
740  virtual int id3Mass() const {return 23;}
741  virtual int id4Mass() const {return 24;}
742  virtual int resonanceA() const {return 24;}
743 
744 private:
745 
746  // Store W+- mass and width, and couplings.
747  double mW, widW, mWS, mwWS, sin2thetaW, cos2thetaW, thetaWRat, cotT,
748  thetaWpt, thetaWmm, lun, lde, sigma0, openFracPos, openFracNeg;
749 
750 };
751 
752 //==========================================================================
753 
754 // A derived class for f fbar -> W+ W-.
755 
756 class Sigma2ffbar2WW : public Sigma2ffbargmZWgmZW {
757 
758 public:
759 
760  // Constructor.
761  Sigma2ffbar2WW() : mZ(), widZ(), mZS(), mwZS(), thetaWRat(), sigma0(),
762  cgg(), cgZ(), cZZ(), cfg(), cfZ(), cff(), gSS(), gTT(), gST(), gUU(),
763  gSU(), openFracPair() {}
764 
765  // Initialize process.
766  virtual void initProc();
767 
768  // Calculate flavour-independent parts of cross section.
769  virtual void sigmaKin();
770 
771  // Evaluate d(sigmaHat)/d(tHat).
772  virtual double sigmaHat();
773 
774  // Select flavour, colour and anticolour.
775  virtual void setIdColAcol();
776 
777  // Evaluate weight for W+ and W- decay angles.
778  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
779 
780  // Info on the subprocess.
781  virtual string name() const {return "f fbar -> W+ W-";}
782  virtual int code() const {return 233;}
783  virtual string inFlux() const {return "ffbarSame";}
784  virtual int id3Mass() const {return 24;}
785  virtual int id4Mass() const {return -24;}
786  virtual int resonanceA() const {return 23;}
787 
788 private:
789 
790  // Store Z0 mass and width.
791  double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, cgg, cgZ, cZZ, cfg,
792  cfZ, cff, gSS, gTT, gST, gUU, gSU, openFracPair;
793 
794 };
795 
796 //==========================================================================
797 
798 // An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
799 
800 class Sigma2ffbargmZggm : public Sigma2Process {
801 
802 public:
803 
804  // Constructor.
805  Sigma2ffbargmZggm() : gmZmode(), mRes(), GammaRes(), m2Res(), GamMRat(),
806  thetaWRat(), gamSum(), intSum(), resSum(), gamProp(), intProp(), resProp(),
807  particlePtr() {}
808 
809  // Initialize process.
810  virtual void initProc();
811 
812  // Evaluate weight for gamma&/Z0 decay angle.
813  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
814 
815 protected:
816 
817  // Parameters set at initialization or for each new event.
818  int gmZmode;
819  double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
820  gamSum, intSum, resSum, gamProp, intProp, resProp;
821 
822  // Evaluate current sum of flavour couplings times phase space.
823  void flavSum();
824 
825  // Evaluate current propagator terms of cross section.
826  void propTerm();
827 
828 private:
829 
830  // Pointer to properties of the particle species, to access decay channels.
831  ParticleDataEntry* particlePtr;
832 
833 };
834 
835 //==========================================================================
836 
837 // A derived class for q qbar -> gamma*/Z0 g.
838 
839 class Sigma2qqbar2gmZg : public Sigma2ffbargmZggm {
840 
841 public:
842 
843  // Constructor.
844  Sigma2qqbar2gmZg() : sigma0() {}
845 
846  // Calculate flavour-independent parts of cross section.
847  virtual void sigmaKin();
848 
849  // Evaluate d(sigmaHat)/d(tHat).
850  virtual double sigmaHat();
851 
852  // Select flavour, colour and anticolour.
853  virtual void setIdColAcol();
854 
855  // Info on the subprocess.
856  virtual string name() const {return "q qbar -> gamma*/Z0 g";}
857  virtual int code() const {return 241;}
858  virtual string inFlux() const {return "qqbarSame";}
859  virtual int id3Mass() const {return 23;}
860 
861 private:
862 
863  // Values stored for later use.
864  double sigma0;
865 
866 };
867 
868 //==========================================================================
869 
870 // A derived class for q g -> gamma*/Z0 q.
871 
872 class Sigma2qg2gmZq : public Sigma2ffbargmZggm {
873 
874 public:
875 
876  // Constructor.
877  Sigma2qg2gmZq() : sigma0() {}
878 
879  // Calculate flavour-independent parts of cross section.
880  virtual void sigmaKin();
881 
882  // Evaluate d(sigmaHat)/d(tHat).
883  virtual double sigmaHat();
884 
885  // Select flavour, colour and anticolour.
886  virtual void setIdColAcol();
887 
888  // Info on the subprocess.
889  virtual string name() const {return "q g-> gamma*/Z0 q";}
890  virtual int code() const {return 242;}
891  virtual string inFlux() const {return "qg";}
892  virtual int id3Mass() const {return 23;}
893 
894 private:
895 
896  // Values stored for later use.
897  double sigma0;
898 
899 };
900 
901 //==========================================================================
902 
903 // A derived class for f fbar' -> gamma*/Z0 gamma.
904 
905 class Sigma2ffbar2gmZgm : public Sigma2ffbargmZggm {
906 
907 public:
908 
909  // Constructor.
910  Sigma2ffbar2gmZgm() : sigma0() {}
911 
912  // Calculate flavour-independent parts of cross section.
913  virtual void sigmaKin();
914 
915  // Evaluate d(sigmaHat)/d(tHat).
916  virtual double sigmaHat();
917 
918  // Select flavour, colour and anticolour.
919  virtual void setIdColAcol();
920 
921  // Info on the subprocess.
922  virtual string name() const {return "f fbar -> gamma*/Z0 gamma";}
923  virtual int code() const {return 243;}
924  virtual string inFlux() const {return "ffbarSame";}
925  virtual int id3Mass() const {return 23;}
926 
927 private:
928 
929  // Values stored for later use.
930  double sigma0;
931 
932 };
933 
934 //==========================================================================
935 
936 // A derived class for f gamma -> gamma*/Z0 f.
937 
938 class Sigma2fgm2gmZf : public Sigma2ffbargmZggm {
939 
940 public:
941 
942  // Constructor.
943  Sigma2fgm2gmZf() : sigma0() {}
944 
945  // Calculate flavour-independent parts of cross section.
946  virtual void sigmaKin();
947 
948  // Evaluate d(sigmaHat)/d(tHat).
949  virtual double sigmaHat();
950 
951  // Select flavour, colour and anticolour.
952  virtual void setIdColAcol();
953 
954  // Info on the subprocess.
955  virtual string name() const {return "f gamma -> gamma*/Z0 f";}
956  virtual int code() const {return 244;}
957  virtual string inFlux() const {return "fgm";}
958  virtual int id3Mass() const {return 23;}
959 
960 private:
961 
962  // Values stored for later use.
963  double sigma0;
964 
965 };
966 
967 //==========================================================================
968 
969 // An intermediate class for f fbar -> W+- g/gamma and permutations.
970 
971 class Sigma2ffbarWggm : public Sigma2Process {
972 
973 public:
974 
975  // Constructor.
976  Sigma2ffbarWggm() {}
977 
978  // Evaluate weight for gamma&/Z0 decay angle.
979  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
980 
981 private:
982 
983 };
984 
985 //==========================================================================
986 
987 // A derived class for q qbar' -> W+- g.
988 
989 class Sigma2qqbar2Wg : public Sigma2ffbarWggm {
990 
991 public:
992 
993  // Constructor.
994  Sigma2qqbar2Wg() : sigma0(), openFracPos(), openFracNeg() {}
995 
996  // Initialize process.
997  virtual void initProc();
998 
999  // Calculate flavour-independent parts of cross section.
1000  virtual void sigmaKin();
1001 
1002  // Evaluate d(sigmaHat)/d(tHat).
1003  virtual double sigmaHat();
1004 
1005  // Select flavour, colour and anticolour.
1006  virtual void setIdColAcol();
1007 
1008  // Info on the subprocess.
1009  virtual string name() const {return "q qbar' -> W+- g";}
1010  virtual int code() const {return 251;}
1011  virtual string inFlux() const {return "ffbarChg";}
1012  virtual int id3Mass() const {return 24;}
1013 
1014 private:
1015 
1016  // Values stored for later use.
1017  double sigma0, openFracPos, openFracNeg;
1018 
1019 };
1020 
1021 //==========================================================================
1022 
1023 // A derived class for q g -> W+- q'.
1024 
1025 class Sigma2qg2Wq : public Sigma2ffbarWggm {
1026 
1027 public:
1028 
1029  // Constructor.
1030  Sigma2qg2Wq() : sigma0(), openFracPos(), openFracNeg() {}
1031 
1032  // Initialize process.
1033  virtual void initProc();
1034 
1035  // Calculate flavour-independent parts of cross section.
1036  virtual void sigmaKin();
1037 
1038  // Evaluate d(sigmaHat)/d(tHat).
1039  virtual double sigmaHat();
1040 
1041  // Select flavour, colour and anticolour.
1042  virtual void setIdColAcol();
1043 
1044  // Info on the subprocess.
1045  virtual string name() const {return "q g-> W+- q'";}
1046  virtual int code() const {return 252;}
1047  virtual string inFlux() const {return "qg";}
1048  virtual int id3Mass() const {return 24;}
1049 
1050 private:
1051 
1052  // Values stored for later use.
1053  double sigma0, openFracPos, openFracNeg;
1054 
1055 };
1056 
1057 //==========================================================================
1058 
1059 // A derived class for f fbar' -> W+- gamma.
1060 
1061 class Sigma2ffbar2Wgm : public Sigma2ffbarWggm {
1062 
1063 public:
1064 
1065  // Constructor.
1066  Sigma2ffbar2Wgm() : sigma0(), openFracPos(), openFracNeg() {}
1067 
1068  // Initialize process.
1069  virtual void initProc();
1070 
1071  // Calculate flavour-independent parts of cross section.
1072  virtual void sigmaKin();
1073 
1074  // Evaluate d(sigmaHat)/d(tHat).
1075  virtual double sigmaHat();
1076 
1077  // Select flavour, colour and anticolour.
1078  virtual void setIdColAcol();
1079 
1080  // Info on the subprocess.
1081  virtual string name() const {return "f fbar' -> W+- gamma";}
1082  virtual int code() const {return 253;}
1083  virtual string inFlux() const {return "ffbarChg";}
1084  virtual int id3Mass() const {return 24;}
1085 
1086 private:
1087 
1088  // Values stored for later use.
1089  double sigma0, openFracPos, openFracNeg;
1090 
1091 };
1092 
1093 //==========================================================================
1094 
1095 // A derived class for f gamma -> W+- f'.
1096 
1097 class Sigma2fgm2Wf : public Sigma2ffbarWggm {
1098 
1099 public:
1100 
1101  // Constructor.
1102  Sigma2fgm2Wf() : sigma0(), openFracPos(), openFracNeg() {}
1103 
1104  // Initialize process.
1105  virtual void initProc();
1106 
1107  // Calculate flavour-independent parts of cross section.
1108  virtual void sigmaKin();
1109 
1110  // Evaluate d(sigmaHat)/d(tHat).
1111  virtual double sigmaHat();
1112 
1113  // Select flavour, colour and anticolour.
1114  virtual void setIdColAcol();
1115 
1116  // Info on the subprocess.
1117  virtual string name() const {return "f gamma -> W+- f'";}
1118  virtual int code() const {return 254;}
1119  virtual string inFlux() const {return "fgm";}
1120  virtual int id3Mass() const {return 24;}
1121 
1122 private:
1123 
1124  // Values stored for later use.
1125  double sigma0, openFracPos, openFracNeg;
1126 
1127 };
1128 //==========================================================================
1129 
1130 // A derived class for gamma gamma -> f fbar.
1131 
1132 class Sigma2gmgm2ffbar : public Sigma2Process {
1133 
1134 public:
1135 
1136  // Constructor.
1137  Sigma2gmgm2ffbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn),
1138  idMass(), idNow(), ef4(), s34Avg(), sigTU(), sigma(), openFracPair() {}
1139 
1140  // Initialize process.
1141  virtual void initProc();
1142 
1143  // Calculate flavour-independent parts of cross section.
1144  virtual void sigmaKin();
1145 
1146  // Evaluate d(sigmaHat)/d(tHat).
1147  virtual double sigmaHat() {return sigma;}
1148 
1149  // Select flavour, colour and anticolour.
1150  virtual void setIdColAcol();
1151 
1152  // Info on the subprocess.
1153  virtual string name() const {return nameSave;}
1154  virtual int code() const {return codeSave;}
1155  virtual string inFlux() const {return "gmgm";}
1156  virtual int id3Mass() const {return idMass;}
1157  virtual int id4Mass() const {return idMass;}
1158 
1159 private:
1160 
1161  // Member variables.
1162  int idNew, codeSave, idMass, idNow;
1163  string nameSave;
1164  double ef4, s34Avg, sigTU, sigma, openFracPair;
1165 
1166 };
1167 
1168 //==========================================================================
1169 
1170 // A derived class for g gamma -> q qbar (q = u, d, s, c, b).
1171 
1172 class Sigma2ggm2qqbar : public Sigma2Process {
1173 
1174 public:
1175 
1176  // Constructor.
1177  Sigma2ggm2qqbar(int idIn, int codeIn, string inFluxIn = "ggm")
1178  : idNew(idIn), codeSave(codeIn), idMass(), idNow(), inFluxSave(inFluxIn),
1179  ef2(), s34Avg(), sigTU(), sigma(), openFracPair() {}
1180 
1181  // Initialize process.
1182  virtual void initProc();
1183 
1184  // Calculate flavour-independent parts of cross section.
1185  virtual void sigmaKin();
1186 
1187  // Evaluate d(sigmaHat)/d(tHat).
1188  virtual double sigmaHat() {return sigma;}
1189 
1190  // Select flavour, colour and anticolour.
1191  virtual void setIdColAcol();
1192 
1193  // Info on the subprocess.
1194  virtual string name() const {return nameSave;}
1195  virtual int code() const {return codeSave;}
1196  virtual string inFlux() const {return inFluxSave;}
1197  virtual int id3Mass() const {return idMass;}
1198  virtual int id4Mass() const {return idMass;}
1199 
1200 private:
1201 
1202  // Member variables.
1203  int idNew, codeSave, idMass, idNow;
1204  string nameSave, inFluxSave;
1205  double ef2, s34Avg, sigTU, sigma, openFracPair;
1206 
1207 };
1208 
1209 //==========================================================================
1210 
1211 // A derived class for q gamma -> q g (q = u, d, s, c, b).
1212 // Use massless approximation also for Q since no alternative.
1213 
1214 class Sigma2qgm2qg : public Sigma2Process {
1215 
1216 public:
1217 
1218  // Constructor.
1219  Sigma2qgm2qg(int codeIn, string inFluxIn = "qgm")
1220  : codeSave(codeIn), sigUS(), sigma0(), inFluxSave(inFluxIn) {}
1221 
1222  // Initialize process according to in flux.
1223  virtual void initProc();
1224 
1225  // Calculate flavour-independent parts of cross section.
1226  virtual void sigmaKin();
1227 
1228  // Evaluate d(sigmaHat)/d(tHat).
1229  virtual double sigmaHat();
1230 
1231  // Select flavour, colour and anticolour.
1232  virtual void setIdColAcol();
1233 
1234  // Info on the subprocess.
1235  virtual string name() const {return nameSave;}
1236  virtual int code() const {return codeSave;}
1237  virtual string inFlux() const {return inFluxSave;}
1238 
1239 private:
1240 
1241  // Values stored for later use.
1242  int codeSave;
1243  double sigUS, sigma0;
1244  string nameSave, inFluxSave;
1245 
1246 };
1247 
1248 //==========================================================================
1249 
1250 // A derived class for q gamma -> q gamma (q = u, d, s, c, b).
1251 // Use massless approximation also for Q since no alternative.
1252 
1253 class Sigma2qgm2qgm : public Sigma2Process {
1254 
1255 public:
1256 
1257  // Constructor.
1258  Sigma2qgm2qgm(int codeIn, string inFluxIn = "qgm")
1259  : codeSave(codeIn), sigUS(), sigma0(), inFluxSave(inFluxIn) {}
1260 
1261  // Initialize process.
1262  virtual void initProc();
1263 
1264  // Calculate flavour-independent parts of cross section.
1265  virtual void sigmaKin();
1266 
1267  // Evaluate d(sigmaHat)/d(tHat).
1268  virtual double sigmaHat();
1269 
1270  // Select flavour, colour and anticolour.
1271  virtual void setIdColAcol();
1272 
1273  // Info on the subprocess.
1274  virtual string name() const {return nameSave;}
1275  virtual int code() const {return codeSave;}
1276  virtual string inFlux() const {return inFluxSave;}
1277 
1278 private:
1279 
1280  // Values stored for later use.
1281  int codeSave;
1282  double sigUS, sigma0;
1283  string nameSave, inFluxSave;
1284 
1285 };
1286 
1287 //==========================================================================
1288 
1289 } // end namespace Pythia8
1290 
1291 #endif // Pythia8_SigmaEW_H
Definition: AgUStep.h:26