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) 2014 Torbjorn Sjostrand.
3 // PYTHIA is licenced under the GNU GPL version 2, 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() {}
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() {}
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() {}
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() {}
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() {}
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() {}
194 
195  // Initialize process.
196  virtual void initProc();
197 
198  // Calculate flavour-independent parts of cross section.
199  virtual void sigmaKin();
200 
201  // Evaluate sigmaHat(sHat).
202  virtual double sigmaHat();
203 
204  // Select flavour, colour and anticolour.
205  virtual void setIdColAcol();
206 
207  // Info on the subprocess.
208  virtual string name() const {return "f f' -> f f' (t-channel gamma*/Z0)";}
209  virtual int code() const {return 211;}
210  virtual string inFlux() const {return "ff";}
211 
212 private:
213 
214  // Z parameters for propagator.
215  int gmZmode;
216  double mZ, mZS, thetaWRat, sigmagmgm, sigmagmZ, sigmaZZ;
217 
218 };
219 
220 //==========================================================================
221 
222 // A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange.
223 
224 class Sigma2ff2fftW : public Sigma2Process {
225 
226 public:
227 
228  // Constructor.
229  Sigma2ff2fftW() {}
230 
231  // Initialize process.
232  virtual void initProc();
233 
234  // Calculate flavour-independent parts of cross section.
235  virtual void sigmaKin();
236 
237  // Evaluate sigmaHat(sHat).
238  virtual double sigmaHat();
239 
240  // Select flavour, colour and anticolour.
241  virtual void setIdColAcol();
242 
243  // Info on the subprocess.
244  virtual string name() const {return "f_1 f_2 -> f_3 f_4 (t-channel W+-)";}
245  virtual int code() const {return 212;}
246  virtual string inFlux() const {return "ff";}
247 
248 private:
249 
250  // W parameters for propagator.
251  double mW, mWS, thetaWRat, sigma0;
252 
253 };
254 
255 //==========================================================================
256 
257 // A derived class for q q' -> Q q" via t-channel W+- exchange.
258 // Related to Sigma2ff2fftW class, but with massive matrix elements.
259 
260 class Sigma2qq2QqtW : public Sigma2Process {
261 
262 public:
263 
264  // Constructor.
265  Sigma2qq2QqtW(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
266 
267  // Initialize process.
268  virtual void initProc();
269 
270  // Calculate flavour-independent parts of cross section.
271  virtual void sigmaKin();
272 
273  // Evaluate sigmaHat(sHat).
274  virtual double sigmaHat();
275 
276  // Select flavour, colour and anticolour.
277  virtual void setIdColAcol();
278 
279  // Evaluate weight for W decay angles in top decay (else inactive).
280  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
281 
282  // Info on the subprocess.
283  virtual string name() const {return nameSave;}
284  virtual int code() const {return codeSave;}
285  virtual string inFlux() const {return "ff";}
286  virtual int id3Mass() const {return idNew;}
287 
288 private:
289 
290  // Values stored for process type. W parameters for propagator.
291  int idNew, codeSave;
292  string nameSave;
293  double mW, mWS, thetaWRat, sigma0, openFracPos, openFracNeg;
294 
295 };
296 
297 //==========================================================================
298 
299 // A derived class for f fbar -> gamma*/Z0.
300 
301 class Sigma1ffbar2gmZ : public Sigma1Process {
302 
303 public:
304 
305  // Constructor.
306  Sigma1ffbar2gmZ() {}
307 
308  // Initialize process.
309  virtual void initProc();
310 
311  // Calculate flavour-independent parts of cross section.
312  virtual void sigmaKin();
313 
314  // Evaluate sigmaHat(sHat).
315  virtual double sigmaHat();
316 
317  // Select flavour, colour and anticolour.
318  virtual void setIdColAcol();
319 
320  // Evaluate weight for Z decay angle.
321  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
322 
323  // Info on the subprocess.
324  virtual string name() const {return "f fbar -> gamma*/Z0";}
325  virtual int code() const {return 221;}
326  virtual string inFlux() const {return "ffbarSame";}
327  virtual int resonanceA() const {return 23;}
328 
329 private:
330 
331  // Parameters set at initialization or for each new event.
332  int gmZmode;
333  double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
334  gamSum, intSum, resSum, gamProp, intProp, resProp;
335 
336  // Pointer to properties of the particle species, to access decay channels.
337  ParticleDataEntry* particlePtr;
338 
339 };
340 
341 //==========================================================================
342 
343 // A derived class for f fbar' -> W+-.
344 
345 class Sigma1ffbar2W : public Sigma1Process {
346 
347 public:
348 
349  // Constructor.
350  Sigma1ffbar2W() {}
351 
352  // Initialize process.
353  virtual void initProc();
354 
355  // Calculate flavour-independent parts of cross section.
356  virtual void sigmaKin();
357 
358  // Evaluate sigmaHat(sHat).
359  virtual double sigmaHat();
360 
361  // Select flavour, colour and anticolour.
362  virtual void setIdColAcol();
363 
364  // Evaluate weight for W decay angle.
365  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
366 
367  // Info on the subprocess.
368  virtual string name() const {return "f fbar' -> W+-";}
369  virtual int code() const {return 222;}
370  virtual string inFlux() const {return "ffbarChg";}
371  virtual int resonanceA() const {return 24;}
372 
373 private:
374 
375  // Parameters set at initialization.
376  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
377 
378  // Pointer to properties of the particle species, to access decay channels.
379  ParticleDataEntry* particlePtr;
380 
381 };
382 
383 //==========================================================================
384 
385 // A derived class for f fbar -> gamma* -> f' fbar', summed over light f'.
386 // Allows pT-ordered evolution for multiparton interactions.
387 
388 class Sigma2ffbar2ffbarsgm : public Sigma2Process {
389 
390 public:
391 
392  // Constructor.
393  Sigma2ffbar2ffbarsgm() {}
394 
395  // Calculate flavour-independent parts of cross section.
396  virtual void sigmaKin();
397 
398  // Evaluate sigmaHat(sHat).
399  virtual double sigmaHat();
400 
401  // Select flavour, colour and anticolour.
402  virtual void setIdColAcol();
403 
404  // Info on the subprocess.
405  virtual string name() const {
406  return "f fbar -> f' fbar' (s-channel gamma*)";}
407  virtual int code() const {return 223;}
408  virtual string inFlux() const {return "ffbarSame";}
409  virtual bool isSChannel() const {return true;}
410 
411 private:
412 
413  // Values stored for later use.
414  int idNew;
415  double sigma0;
416 
417 };
418 
419 //==========================================================================
420 
421 // A derived class for f fbar -> gamma*/Z0 -> f' fbar', summed over light f.
422 
424 
425 public:
426 
427  // Constructor.
429 
430  // Initialize process.
431  virtual void initProc();
432 
433  // Calculate flavour-independent parts of cross section.
434  virtual void sigmaKin();
435 
436  // Evaluate sigmaHat(sHat).
437  virtual double sigmaHat();
438 
439  // Select flavour, colour and anticolour.
440  virtual void setIdColAcol();
441 
442  // Info on the subprocess.
443  virtual string name() const {
444  return "f fbar -> f' fbar' (s-channel gamma*/Z0)";}
445  virtual int code() const {return 224;}
446  virtual string inFlux() const {return "ffbarSame";}
447  virtual bool isSChannel() const {return true;}
448  virtual int idSChannel() const {return 23;}
449  virtual int resonanceA() const {return 23;}
450 
451 private:
452 
453  // Parameters set at initialization or for each new event.
454  int gmZmode;
455  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, colQ,
456  gamSumT, gamSumL, intSumT, intSumL, intSumA, resSumT, resSumL,
457  resSumA, gamProp, intProp, resProp, cThe;
458  vector<int> idVec;
459  vector<double> gamT, gamL, intT, intL, intA, resT, resL, resA, sigTLA;
460 
461  // Pointer to properties of the particle species, to access decay channels.
462  ParticleDataEntry* particlePtr;
463 
464 };
465 
466 //==========================================================================
467 
468 // A derived class for f_1 fbar_2 -> W+- -> f_3 fbar_4, summed over light f.
469 
471 
472 public:
473 
474  // Constructor.
476 
477  // Initialize process.
478  virtual void initProc();
479 
480  // Calculate flavour-independent parts of cross section.
481  virtual void sigmaKin();
482 
483  // Evaluate sigmaHat(sHat).
484  virtual double sigmaHat();
485 
486  // Select flavour, colour and anticolour.
487  virtual void setIdColAcol();
488 
489  // Info on the subprocess.
490  virtual string name() const {
491  return "f_1 fbar_2 -> f_3 fbar_4 (s-channel W+-)";}
492  virtual int code() const {return 225;}
493  virtual string inFlux() const {return "ffbarChg";}
494  virtual bool isSChannel() const {return true;}
495  virtual int idSChannel() const {return 24;}
496  virtual int resonanceA() const {return 24;}
497 
498 private:
499 
500  // Parameters set at initialization or stored for later use.
501  int id3New, id4New;
502  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0;
503 
504  // Pointer to properties of the particle species, to access decay channels.
505  ParticleDataEntry* particlePtr;
506 
507 };
508 
509 //==========================================================================
510 
511 // A derived class for f fbar -> gamma*/Z0 -> F Fbar, for one heavy F.
512 // Allows pT cuts as for other 2 -> 2 processes.
513 
514 class Sigma2ffbar2FFbarsgmZ : public Sigma2Process {
515 
516 public:
517 
518  // Constructor.
519  Sigma2ffbar2FFbarsgmZ(int idIn, int codeIn) : idNew(idIn),
520  codeSave(codeIn) {}
521 
522  // Initialize process.
523  virtual void initProc();
524 
525  // Calculate flavour-independent parts of cross section.
526  virtual void sigmaKin();
527 
528  // Evaluate sigmaHat(sHat).
529  virtual double sigmaHat();
530 
531  // Select flavour, colour and anticolour.
532  virtual void setIdColAcol();
533 
534  // Evaluate weight for W decay angles in top decay (else inactive).
535  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
536 
537  // Info on the subprocess.
538  virtual string name() const {return nameSave;}
539  virtual int code() const {return codeSave;}
540  virtual string inFlux() const {return "ffbarSame";}
541  virtual bool isSChannel() const {return true;}
542  virtual int id3Mass() const {return idNew;}
543  virtual int id4Mass() const {return idNew;}
544  virtual int resonanceA() const {return 23;}
545 
546 private:
547 
548  // Values stored for process type. Z parameters for propagator.
549  int idNew, codeSave, gmZmode;
550  string nameSave;
551  bool isPhysical;
552  double ef, vf, af, mRes, GammaRes, m2Res, GamMRat, thetaWRat,
553  mr, betaf, cosThe, gamProp, intProp, resProp, openFracPair;
554 
555 };
556 
557 //==========================================================================
558 
559 // A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
560 // Allows pT cuts as for other 2 -> 2 processes.
561 
562 class Sigma2ffbar2FfbarsW : public Sigma2Process {
563 
564 public:
565 
566  // Constructor.
567  Sigma2ffbar2FfbarsW(int idIn, int idIn2, int codeIn) : idNew(idIn),
568  idNew2(idIn2), codeSave(codeIn) {}
569 
570  // Initialize process.
571  virtual void initProc();
572 
573  // Calculate flavour-independent parts of cross section.
574  virtual void sigmaKin();
575 
576  // Evaluate sigmaHat(sHat).
577  virtual double sigmaHat();
578 
579  // Select flavour, colour and anticolour.
580  virtual void setIdColAcol();
581 
582  // Evaluate weight for W decay angles in top decay (else inactive).
583  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
584 
585  // Info on the subprocess.
586  virtual string name() const {return nameSave;}
587  virtual int code() const {return codeSave;}
588  virtual string inFlux() const {return "ffbarChg";}
589  virtual bool isSChannel() const {return true;}
590  virtual int id3Mass() const {return idNew;}
591  virtual int id4Mass() const {return idPartner;}
592  virtual int resonanceA() const {return 24;}
593 
594 private:
595 
596  // Values stored for process type. W parameters for propagator.
597  int idNew, idNew2, codeSave, idPartner;
598  string nameSave;
599  bool isPhysical;
600  double V2New, mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
601  openFracPos, openFracNeg;
602 
603 };
604 
605 //==========================================================================
606 
607 // An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
608 
609 class Sigma2ffbargmZWgmZW : public Sigma2Process {
610 
611 public:
612 
613  // Constructor.
614  Sigma2ffbargmZWgmZW() {}
615 
616 protected:
617 
618  // Internal products.
619  Vec4 pRot[7];
620  complex hA[7][7];
621  complex hC[7][7];
622 
623  // Calculate and store internal products.
624  void setupProd( Event& process, int i1, int i2, int i3, int i4,
625  int i5, int i6);
626 
627  // Evaluate the F function of Gunion and Kunszt.
628  complex fGK(int i1, int i2, int i3, int i4, int i5, int i6);
629 
630  // Evaluate the Xi function of Gunion and Kunszt.
631  double xiGK( double tHnow, double uHnow);
632 
633  // Evaluate the Xj function of Gunion and Kunszt.
634  double xjGK( double tHnow, double uHnow);
635 
636 private:
637 
638 };
639 
640 //==========================================================================
641 
642 // A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
643 
644 class Sigma2ffbar2gmZgmZ : public Sigma2ffbargmZWgmZW {
645 
646 public:
647 
648  // Constructor.
649  Sigma2ffbar2gmZgmZ() {}
650 
651  // Initialize process.
652  virtual void initProc();
653 
654  // Calculate flavour-independent parts of cross section.
655  virtual void sigmaKin();
656 
657  // Evaluate d(sigmaHat)/d(tHat).
658  virtual double sigmaHat();
659 
660  // Select flavour, colour and anticolour.
661  virtual void setIdColAcol();
662 
663  // Evaluate weight for simultaneous flavour choices.
664  virtual double weightDecayFlav( Event& process);
665 
666  // Evaluate weight for decay angles of the two gamma*/Z0.
667  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
668 
669  // Info on the subprocess.
670  virtual string name() const {return "f fbar -> gamma*/Z0 gamma*/Z0";}
671  virtual int code() const {return 231;}
672  virtual string inFlux() const {return "ffbarSame";}
673  virtual int id3Mass() const {return 23;}
674  virtual int id4Mass() const {return 23;}
675 
676 private:
677 
678  // Parameters set at initialization or for each new event.
679  int gmZmode, i1, i2, i3, i4, i5, i6;
680  double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
681  gamSum3, intSum3, resSum3, gamProp3, intProp3, resProp3,
682  gamSum4, intSum4, resSum4, gamProp4, intProp4, resProp4,
683  c3LL, c3LR, c3RL, c3RR, c4LL, c4LR, c4RL, c4RR, flavWt;
684 
685  // Pointer to properties of the particle species, to access decay channels.
686  ParticleDataEntry* particlePtr;
687 
688 };
689 
690 //==========================================================================
691 
692 // A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
693 
694 class Sigma2ffbar2ZW : public Sigma2ffbargmZWgmZW {
695 
696 public:
697 
698  // Constructor.
699  Sigma2ffbar2ZW() {}
700 
701  // Initialize process.
702  virtual void initProc();
703 
704  // Calculate flavour-independent parts of cross section.
705  virtual void sigmaKin();
706 
707  // Evaluate d(sigmaHat)/d(tHat).
708  virtual double sigmaHat();
709 
710  // Select flavour, colour and anticolour.
711  virtual void setIdColAcol();
712 
713  // Evaluate weight for Z0 and W+- decay angles.
714  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
715 
716  // Info on the subprocess.
717  virtual string name() const {return "f fbar' -> Z0 W+- (no gamma*!)";}
718  virtual int code() const {return 232;}
719  virtual string inFlux() const {return "ffbarChg";}
720  virtual int id3Mass() const {return 23;}
721  virtual int id4Mass() const {return 24;}
722  virtual int resonanceA() const {return 24;}
723 
724 private:
725 
726  // Store W+- mass and width, and couplings.
727  double mW, widW, mWS, mwWS, sin2thetaW, cos2thetaW, thetaWRat, cotT,
728  thetaWpt, thetaWmm, lun, lde, sigma0, openFracPos, openFracNeg;
729 
730 };
731 
732 //==========================================================================
733 
734 // A derived class for f fbar -> W+ W-.
735 
736 class Sigma2ffbar2WW : public Sigma2ffbargmZWgmZW {
737 
738 public:
739 
740  // Constructor.
741  Sigma2ffbar2WW() {}
742 
743  // Initialize process.
744  virtual void initProc();
745 
746  // Calculate flavour-independent parts of cross section.
747  virtual void sigmaKin();
748 
749  // Evaluate d(sigmaHat)/d(tHat).
750  virtual double sigmaHat();
751 
752  // Select flavour, colour and anticolour.
753  virtual void setIdColAcol();
754 
755  // Evaluate weight for W+ and W- decay angles.
756  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
757 
758  // Info on the subprocess.
759  virtual string name() const {return "f fbar -> W+ W-";}
760  virtual int code() const {return 233;}
761  virtual string inFlux() const {return "ffbarSame";}
762  virtual int id3Mass() const {return 24;}
763  virtual int id4Mass() const {return -24;}
764  virtual int resonanceA() const {return 23;}
765 
766 private:
767 
768  // Store Z0 mass and width.
769  double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, cgg, cgZ, cZZ, cfg,
770  cfZ, cff, gSS, gTT, gST, gUU, gSU, openFracPair;
771 
772 };
773 
774 //==========================================================================
775 
776 // An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
777 
778 class Sigma2ffbargmZggm : public Sigma2Process {
779 
780 public:
781 
782  // Constructor.
783  Sigma2ffbargmZggm() {}
784 
785  // Initialize process.
786  virtual void initProc();
787 
788  // Evaluate weight for gamma&/Z0 decay angle.
789  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
790 
791 protected:
792 
793  // Parameters set at initialization or for each new event.
794  int gmZmode;
795  double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
796  gamSum, intSum, resSum, gamProp, intProp, resProp;
797 
798  // Evaluate current sum of flavour couplings times phase space.
799  void flavSum();
800 
801  // Evaluate current propagator terms of cross section.
802  void propTerm();
803 
804 private:
805 
806  // Pointer to properties of the particle species, to access decay channels.
807  ParticleDataEntry* particlePtr;
808 
809 };
810 
811 //==========================================================================
812 
813 // A derived class for q qbar -> gamma*/Z0 g.
814 
815 class Sigma2qqbar2gmZg : public Sigma2ffbargmZggm {
816 
817 public:
818 
819  // Constructor.
820  Sigma2qqbar2gmZg() {}
821 
822  // Calculate flavour-independent parts of cross section.
823  virtual void sigmaKin();
824 
825  // Evaluate d(sigmaHat)/d(tHat).
826  virtual double sigmaHat();
827 
828  // Select flavour, colour and anticolour.
829  virtual void setIdColAcol();
830 
831  // Info on the subprocess.
832  virtual string name() const {return "q qbar -> gamma*/Z0 g";}
833  virtual int code() const {return 241;}
834  virtual string inFlux() const {return "qqbarSame";}
835  virtual int id3Mass() const {return 23;}
836 
837 private:
838 
839  // Values stored for later use.
840  double sigma0;
841 
842 };
843 
844 //==========================================================================
845 
846 // A derived class for q g -> gamma*/Z0 q.
847 
848 class Sigma2qg2gmZq : public Sigma2ffbargmZggm {
849 
850 public:
851 
852  // Constructor.
853  Sigma2qg2gmZq() {}
854 
855  // Calculate flavour-independent parts of cross section.
856  virtual void sigmaKin();
857 
858  // Evaluate d(sigmaHat)/d(tHat).
859  virtual double sigmaHat();
860 
861  // Select flavour, colour and anticolour.
862  virtual void setIdColAcol();
863 
864  // Info on the subprocess.
865  virtual string name() const {return "q g-> gamma*/Z0 q";}
866  virtual int code() const {return 242;}
867  virtual string inFlux() const {return "qg";}
868  virtual int id3Mass() const {return 23;}
869 
870 private:
871 
872  // Values stored for later use.
873  double sigma0;
874 
875 };
876 
877 //==========================================================================
878 
879 // A derived class for f fbar' -> gamma*/Z0 gamma.
880 
881 class Sigma2ffbar2gmZgm : public Sigma2ffbargmZggm {
882 
883 public:
884 
885  // Constructor.
886  Sigma2ffbar2gmZgm() {}
887 
888  // Calculate flavour-independent parts of cross section.
889  virtual void sigmaKin();
890 
891  // Evaluate d(sigmaHat)/d(tHat).
892  virtual double sigmaHat();
893 
894  // Select flavour, colour and anticolour.
895  virtual void setIdColAcol();
896 
897  // Info on the subprocess.
898  virtual string name() const {return "f fbar -> gamma*/Z0 gamma";}
899  virtual int code() const {return 243;}
900  virtual string inFlux() const {return "ffbarSame";}
901  virtual int id3Mass() const {return 23;}
902 
903 private:
904 
905  // Values stored for later use.
906  double sigma0;
907 
908 };
909 
910 //==========================================================================
911 
912 // A derived class for f gamma -> gamma*/Z0 f.
913 
914 class Sigma2fgm2gmZf : public Sigma2ffbargmZggm {
915 
916 public:
917 
918  // Constructor.
919  Sigma2fgm2gmZf() {}
920 
921  // Calculate flavour-independent parts of cross section.
922  virtual void sigmaKin();
923 
924  // Evaluate d(sigmaHat)/d(tHat).
925  virtual double sigmaHat();
926 
927  // Select flavour, colour and anticolour.
928  virtual void setIdColAcol();
929 
930  // Info on the subprocess.
931  virtual string name() const {return "f gamma -> gamma*/Z0 f";}
932  virtual int code() const {return 244;}
933  virtual string inFlux() const {return "fgm";}
934  virtual int id3Mass() const {return 23;}
935 
936 private:
937 
938  // Values stored for later use.
939  double sigma0;
940 
941 };
942 
943 //==========================================================================
944 
945 // An intermediate class for f fbar -> W+- g/gamma and permutations.
946 
947 class Sigma2ffbarWggm : public Sigma2Process {
948 
949 public:
950 
951  // Constructor.
952  Sigma2ffbarWggm() {}
953 
954  // Evaluate weight for gamma&/Z0 decay angle.
955  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
956 
957 private:
958 
959 };
960 
961 //==========================================================================
962 
963 // A derived class for q qbar' -> W+- g.
964 
965 class Sigma2qqbar2Wg : public Sigma2ffbarWggm {
966 
967 public:
968 
969  // Constructor.
970  Sigma2qqbar2Wg() {}
971 
972  // Initialize process.
973  virtual void initProc();
974 
975  // Calculate flavour-independent parts of cross section.
976  virtual void sigmaKin();
977 
978  // Evaluate d(sigmaHat)/d(tHat).
979  virtual double sigmaHat();
980 
981  // Select flavour, colour and anticolour.
982  virtual void setIdColAcol();
983 
984  // Info on the subprocess.
985  virtual string name() const {return "q qbar' -> W+- g";}
986  virtual int code() const {return 251;}
987  virtual string inFlux() const {return "ffbarChg";}
988  virtual int id3Mass() const {return 24;}
989 
990 private:
991 
992  // Values stored for later use.
993  double sigma0, openFracPos, openFracNeg;
994 
995 };
996 
997 //==========================================================================
998 
999 // A derived class for q g -> W+- q'.
1000 
1001 class Sigma2qg2Wq : public Sigma2ffbarWggm {
1002 
1003 public:
1004 
1005  // Constructor.
1006  Sigma2qg2Wq() {}
1007 
1008  // Initialize process.
1009  virtual void initProc();
1010 
1011  // Calculate flavour-independent parts of cross section.
1012  virtual void sigmaKin();
1013 
1014  // Evaluate d(sigmaHat)/d(tHat).
1015  virtual double sigmaHat();
1016 
1017  // Select flavour, colour and anticolour.
1018  virtual void setIdColAcol();
1019 
1020  // Info on the subprocess.
1021  virtual string name() const {return "q g-> W+- q'";}
1022  virtual int code() const {return 252;}
1023  virtual string inFlux() const {return "qg";}
1024  virtual int id3Mass() const {return 24;}
1025 
1026 private:
1027 
1028  // Values stored for later use.
1029  double sigma0, openFracPos, openFracNeg;
1030 
1031 };
1032 
1033 //==========================================================================
1034 
1035 // A derived class for f fbar' -> W+- gamma.
1036 
1037 class Sigma2ffbar2Wgm : public Sigma2ffbarWggm {
1038 
1039 public:
1040 
1041  // Constructor.
1042  Sigma2ffbar2Wgm() {}
1043 
1044  // Initialize process.
1045  virtual void initProc();
1046 
1047  // Calculate flavour-independent parts of cross section.
1048  virtual void sigmaKin();
1049 
1050  // Evaluate d(sigmaHat)/d(tHat).
1051  virtual double sigmaHat();
1052 
1053  // Select flavour, colour and anticolour.
1054  virtual void setIdColAcol();
1055 
1056  // Info on the subprocess.
1057  virtual string name() const {return "f fbar' -> W+- gamma";}
1058  virtual int code() const {return 253;}
1059  virtual string inFlux() const {return "ffbarChg";}
1060  virtual int id3Mass() const {return 24;}
1061 
1062 private:
1063 
1064  // Values stored for later use.
1065  double sigma0, openFracPos, openFracNeg;
1066 
1067 };
1068 
1069 //==========================================================================
1070 
1071 // A derived class for f gamma -> W+- f'.
1072 
1073 class Sigma2fgm2Wf : public Sigma2ffbarWggm {
1074 
1075 public:
1076 
1077  // Constructor.
1078  Sigma2fgm2Wf() {}
1079 
1080  // Initialize process.
1081  virtual void initProc();
1082 
1083  // Calculate flavour-independent parts of cross section.
1084  virtual void sigmaKin();
1085 
1086  // Evaluate d(sigmaHat)/d(tHat).
1087  virtual double sigmaHat();
1088 
1089  // Select flavour, colour and anticolour.
1090  virtual void setIdColAcol();
1091 
1092  // Info on the subprocess.
1093  virtual string name() const {return "f gamma -> W+- f'";}
1094  virtual int code() const {return 254;}
1095  virtual string inFlux() const {return "fgm";}
1096  virtual int id3Mass() const {return 24;}
1097 
1098 private:
1099 
1100  // Values stored for later use.
1101  double sigma0, openFracPos, openFracNeg;
1102 
1103 };
1104 //==========================================================================
1105 
1106 // A derived class for gamma gamma -> f fbar.
1107 
1108 class Sigma2gmgm2ffbar : public Sigma2Process {
1109 
1110 public:
1111 
1112  // Constructor.
1113  Sigma2gmgm2ffbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
1114 
1115  // Initialize process.
1116  virtual void initProc();
1117 
1118  // Calculate flavour-independent parts of cross section.
1119  virtual void sigmaKin();
1120 
1121  // Evaluate d(sigmaHat)/d(tHat).
1122  virtual double sigmaHat() {return sigma;}
1123 
1124  // Select flavour, colour and anticolour.
1125  virtual void setIdColAcol();
1126 
1127  // Info on the subprocess.
1128  virtual string name() const {return nameSave;}
1129  virtual int code() const {return codeSave;}
1130  virtual string inFlux() const {return "gmgm";}
1131  virtual int id3Mass() const {return idMass;}
1132  virtual int id4Mass() const {return idMass;}
1133 
1134 private:
1135 
1136  // Member variables.
1137  int idNew, codeSave, idMass, idNow;
1138  string nameSave;
1139  double ef4, s34Avg, sigTU, sigma, openFracPair;
1140 
1141 };
1142 
1143 //==========================================================================
1144 
1145 } // end namespace Pythia8
1146 
1147 #endif // Pythia8_SigmaEW_H
Definition: AgUStep.h:26