c816c143cec17c1af61137f940cce0ceb628ffa7
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8130 / include / SigmaEW.h
1 // SigmaEW.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2008 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 "PythiaComplex.h"
13 #include "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 mNew, m2New, 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 multiple 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, for one heavy F.
422 // Allows pT cuts as for other 2 -> 2 processes.
423
424 class Sigma2ffbar2FFbarsgmZ : public Sigma2Process {
425
426 public:
427
428   // Constructor.
429   Sigma2ffbar2FFbarsgmZ(int idIn, int codeIn) : idNew(idIn), 
430     codeSave(codeIn) {}
431
432   // Initialize process. 
433   virtual void initProc(); 
434
435   // Calculate flavour-independent parts of cross section.
436   virtual void sigmaKin();
437
438   // Evaluate sigmaHat(sHat). 
439   virtual double sigmaHat();
440
441   // Select flavour, colour and anticolour.
442   virtual void setIdColAcol();
443
444   // Evaluate weight for W decay angles in top decay (else inactive).
445   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
446
447   // Info on the subprocess.
448   virtual string name()       const {return nameSave;}
449   virtual int    code()       const {return codeSave;}
450   virtual string inFlux()     const {return "ffbarSame";}
451   virtual bool   isSChannel() const {return true;}
452   virtual int    id3Mass()    const {return idNew;}
453   virtual int    id4Mass()    const {return idNew;}
454   virtual int    resonanceA() const {return 23;}
455
456 private:
457
458   // Values stored for process type. Z parameters for propagator.
459   int    idNew, codeSave, gmZmode;
460   string nameSave;
461   bool   isPhysical;
462   double ef, vf, af, mRes, GammaRes, m2Res, GamMRat, thetaWRat,
463          mr, betaf, cosThe, gamProp, intProp, resProp, openFracPair; 
464
465 };
466
467 //**************************************************************************
468
469 // A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
470 // Allows pT cuts as for other 2 -> 2 processes.
471
472 class Sigma2ffbar2FfbarsW : public Sigma2Process {
473
474 public:
475
476   // Constructor.
477   Sigma2ffbar2FfbarsW(int idIn, int idIn2, int codeIn) : idNew(idIn), 
478     idNew2(idIn2), codeSave(codeIn) {}
479
480   // Initialize process. 
481   virtual void initProc(); 
482
483   // Calculate flavour-independent parts of cross section.
484   virtual void sigmaKin();
485
486   // Evaluate sigmaHat(sHat). 
487   virtual double sigmaHat();
488
489   // Select flavour, colour and anticolour.
490   virtual void setIdColAcol();
491
492   // Evaluate weight for W decay angles in top decay (else inactive).
493   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
494
495   // Info on the subprocess.
496   virtual string name()       const {return nameSave;}
497   virtual int    code()       const {return codeSave;}
498   virtual string inFlux()     const {return "ffbarChg";}
499   virtual bool   isSChannel() const {return true;}
500   virtual int    id3Mass()    const {return idNew;}
501   virtual int    id4Mass()    const {return idPartner;}
502   virtual int    resonanceA() const {return 24;}
503
504 private:
505
506   // Values stored for process type. W parameters for propagator.
507   int    idNew, idNew2, codeSave, idPartner;
508   string nameSave;
509   bool   isPhysical;
510   double V2New, mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
511          openFracPos, openFracNeg; 
512
513 };
514  
515 //**************************************************************************
516
517 // An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
518
519 class Sigma2ffbargmZWgmZW : public Sigma2Process {
520
521 public:
522
523   // Constructor.
524   Sigma2ffbargmZWgmZW() {}
525
526 protected:
527
528   // Internal products. 
529   Vec4    pRot[7];
530   complex hA[7][7];
531   complex hC[7][7];
532
533   // Calculate and store internal products.
534   void setupProd( Event& process, int i1, int i2, int i3, int i4, 
535     int i5, int i6);   
536
537   // Evaluate the F function of Gunion and Kunszt.
538   complex fGK(int i1, int i2, int i3, int i4, int i5, int i6); 
539
540   // Evaluate the Xi function of Gunion and Kunszt.
541   double xiGK( double tHnow, double uHnow);
542
543   // Evaluate the Xj function of Gunion and Kunszt.
544   double xjGK( double tHnow, double uHnow);
545
546 private:
547
548 };
549  
550 //**************************************************************************
551
552 // A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
553
554 class Sigma2ffbar2gmZgmZ : public Sigma2ffbargmZWgmZW {
555
556 public:
557
558   // Constructor.
559   Sigma2ffbar2gmZgmZ() {}
560
561   // Initialize process. 
562   virtual void initProc(); 
563
564   // Calculate flavour-independent parts of cross section.
565   virtual void sigmaKin();
566
567   // Evaluate d(sigmaHat)/d(tHat). 
568   virtual double sigmaHat();
569
570   // Select flavour, colour and anticolour.
571   virtual void setIdColAcol();
572
573   // Evaluate weight for simultaneous flavour choices.
574   virtual double weightDecayFlav( Event& process); 
575
576   // Evaluate weight for decay angles of the two gamma*/Z0.
577   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
578
579   // Info on the subprocess.
580   virtual string name()    const {return "f fbar -> gamma*/Z0 gamma*/Z0";}
581   virtual int    code()    const {return 231;}
582   virtual string inFlux()  const {return "ffbarSame";}
583   virtual int    id3Mass() const {return 23;}
584   virtual int    id4Mass() const {return 23;}
585
586 private:
587
588   // Parameters set at initialization or for each new event. 
589   int    gmZmode, i1, i2, i3, i4, i5, i6;
590   double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,  
591          gamSum3, intSum3, resSum3, gamProp3, intProp3, resProp3,
592          gamSum4, intSum4, resSum4, gamProp4, intProp4, resProp4,
593          c3LL, c3LR, c3RL, c3RR, c4LL, c4LR, c4RL, c4RR, flavWt;
594
595   // Pointer to properties of the particle species, to access decay channels.
596   ParticleDataEntry* particlePtr;
597
598 };
599  
600 //**************************************************************************
601
602 // A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
603
604 class Sigma2ffbar2ZW : public Sigma2ffbargmZWgmZW {
605
606 public:
607
608   // Constructor.
609   Sigma2ffbar2ZW() {}
610
611   // Initialize process. 
612   virtual void initProc(); 
613
614   // Calculate flavour-independent parts of cross section.
615   virtual void sigmaKin();
616
617   // Evaluate d(sigmaHat)/d(tHat). 
618   virtual double sigmaHat();
619
620   // Select flavour, colour and anticolour.
621   virtual void setIdColAcol();
622
623   // Evaluate weight for Z0 and W+- decay angles.
624   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
625
626   // Info on the subprocess.
627   virtual string name()       const {return "f fbar' -> Z0 W+- (no gamma*!)";}
628   virtual int    code()       const {return 232;}
629   virtual string inFlux()     const {return "ffbarChg";}
630   virtual int    id3Mass()    const {return 23;}
631   virtual int    id4Mass()    const {return 24;}
632   virtual int    resonanceA() const {return 24;}
633
634 private:
635
636   // Store W+- mass and width, and couplings.
637   double mW, widW, mWS, mwWS, sin2thetaW, cos2thetaW, thetaWRat, 
638          thetaWpt, thetaWmm, lun, lde, sigma0, openFracPos, openFracNeg;
639
640 };
641  
642 //**************************************************************************
643
644 // A derived class for f fbar -> W+ W-.
645
646 class Sigma2ffbar2WW : public Sigma2ffbargmZWgmZW {
647
648 public:
649
650   // Constructor.
651   Sigma2ffbar2WW() {}
652
653   // Initialize process. 
654   virtual void initProc(); 
655
656   // Calculate flavour-independent parts of cross section.
657   virtual void sigmaKin();
658
659   // Evaluate d(sigmaHat)/d(tHat). 
660   virtual double sigmaHat();
661
662   // Select flavour, colour and anticolour.
663   virtual void setIdColAcol();
664
665   // Evaluate weight for W+ and W- decay angles.
666   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
667
668   // Info on the subprocess.
669   virtual string name()       const {return "f fbar -> W+ W-";}
670   virtual int    code()       const {return 233;}
671   virtual int    id3Mass()    const {return 24;}
672   virtual string inFlux()     const {return "ffbarSame";}
673   virtual int    id4Mass()    const {return -24;}
674   virtual int    resonanceA() const {return 23;}
675
676 private:
677
678   // Store Z0 mass and width.
679   double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, cgg, cgZ, cZZ, cfg, 
680     cfZ, cff, gSS, gTT, gST, gUU, gSU, openFracPair;
681
682 };
683  
684 //**************************************************************************
685
686 // An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
687
688 class Sigma2ffbargmZggm : public Sigma2Process {
689
690 public:
691
692   // Constructor.
693   Sigma2ffbargmZggm() {}
694
695   // Initialize process. 
696   virtual void initProc(); 
697
698   // Evaluate weight for gamma&/Z0 decay angle.
699   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
700
701 protected:
702
703   // Parameters set at initialization or for each new event. 
704   int    gmZmode;
705   double mRes, GammaRes, m2Res, GamMRat, thetaWRat, 
706          gamSum, intSum, resSum, gamProp, intProp, resProp;
707
708   // Evaluate current sum of flavour couplings times phase space. 
709   void flavSum(); 
710
711   // Evaluate current propagator terms of cross section. 
712   void propTerm(); 
713
714 private:
715
716   // Pointer to properties of the particle species, to access decay channels.
717   ParticleDataEntry* particlePtr;
718
719 };
720  
721 //**************************************************************************
722
723 // A derived class for q qbar -> gamma*/Z0 g.
724
725 class Sigma2qqbar2gmZg : public Sigma2ffbargmZggm {
726
727 public:
728
729   // Constructor.
730   Sigma2qqbar2gmZg() {}
731
732   // Calculate flavour-independent parts of cross section.
733   virtual void sigmaKin();
734
735   // Evaluate d(sigmaHat)/d(tHat). 
736   virtual double sigmaHat();
737
738   // Select flavour, colour and anticolour.
739   virtual void setIdColAcol();
740
741   // Info on the subprocess.
742   virtual string name()    const {return "q qbar -> gamma*/Z0 g";}
743   virtual int    code()    const {return 241;}
744   virtual string inFlux()  const {return "qqbarSame";}
745   virtual int    id3Mass() const {return 23;}
746
747 private:
748
749   // Values stored for later use.
750   double sigma0;
751
752 };
753  
754 //**************************************************************************
755
756 // A derived class for q g -> gamma*/Z0 q.
757
758 class Sigma2qg2gmZq : public Sigma2ffbargmZggm {
759
760 public:
761
762   // Constructor.
763   Sigma2qg2gmZq() {}
764
765   // Calculate flavour-independent parts of cross section.
766   virtual void sigmaKin();
767
768   // Evaluate d(sigmaHat)/d(tHat). 
769   virtual double sigmaHat();
770
771   // Select flavour, colour and anticolour.
772   virtual void setIdColAcol();
773
774   // Info on the subprocess.
775   virtual string name()    const {return "q g-> gamma*/Z0 q";}
776   virtual int    code()    const {return 242;}
777   virtual string inFlux()  const {return "qg";}
778   virtual int    id3Mass() const {return 23;}
779
780 private:
781
782   // Values stored for later use.
783   double sigma0;
784
785 };
786  
787 //**************************************************************************
788
789 // A derived class for f fbar' -> gamma*/Z0 gamma.
790
791 class Sigma2ffbar2gmZgm : public Sigma2ffbargmZggm {
792
793 public:
794
795   // Constructor.
796   Sigma2ffbar2gmZgm() {}
797
798   // Calculate flavour-independent parts of cross section.
799   virtual void sigmaKin();
800
801   // Evaluate d(sigmaHat)/d(tHat). 
802   virtual double sigmaHat();
803
804   // Select flavour, colour and anticolour.
805   virtual void setIdColAcol();
806
807   // Info on the subprocess.
808   virtual string name()    const {return "f fbar -> gamma*/Z0 gamma";}
809   virtual int    code()    const {return 243;}
810   virtual string inFlux()  const {return "ffbarSame";}
811   virtual int    id3Mass() const {return 23;}
812
813 private:
814
815   // Values stored for later use.
816   double sigma0;
817
818 };
819  
820 //**************************************************************************
821
822 // A derived class for f gamma -> gamma*/Z0 f.
823
824 class Sigma2fgm2gmZf : public Sigma2ffbargmZggm {
825
826 public:
827
828   // Constructor.
829   Sigma2fgm2gmZf() {}
830
831   // Calculate flavour-independent parts of cross section.
832   virtual void sigmaKin();
833
834   // Evaluate d(sigmaHat)/d(tHat). 
835   virtual double sigmaHat();
836
837   // Select flavour, colour and anticolour.
838   virtual void setIdColAcol();
839
840   // Info on the subprocess.
841   virtual string name()    const {return "f gamma -> gamma*/Z0 f";}
842   virtual int    code()    const {return 244;}
843   virtual string inFlux()  const {return "fgm";}
844   virtual int    id3Mass() const {return 23;}
845
846 private:
847
848   // Values stored for later use.
849   double sigma0;
850
851 };
852  
853 //**************************************************************************
854
855 // An intermediate class for f fbar -> W+- g/gamma and permutations.
856
857 class Sigma2ffbarWggm : public Sigma2Process {
858
859 public:
860
861   // Constructor.
862   Sigma2ffbarWggm() {}
863
864   // Evaluate weight for gamma&/Z0 decay angle.
865   virtual double weightDecay( Event& process, int iResBeg, int iResEnd); 
866
867 private:
868
869 };
870  
871 //**************************************************************************
872
873 // A derived class for q qbar' -> W+- g.
874
875 class Sigma2qqbar2Wg : public Sigma2ffbarWggm {
876
877 public:
878
879   // Constructor.
880   Sigma2qqbar2Wg() {}
881
882   // Initialize process. 
883   virtual void initProc(); 
884
885   // Calculate flavour-independent parts of cross section.
886   virtual void sigmaKin();
887
888   // Evaluate d(sigmaHat)/d(tHat). 
889   virtual double sigmaHat();
890
891   // Select flavour, colour and anticolour.
892   virtual void setIdColAcol();
893
894   // Info on the subprocess.
895   virtual string name()    const {return "q qbar' -> W+- g";}
896   virtual int    code()    const {return 251;}
897   virtual string inFlux()  const {return "ffbarChg";}
898   virtual int    id3Mass() const {return 24;}
899
900 private:
901
902   // Values stored for later use.
903   double sigma0, openFracPos, openFracNeg;
904
905 };
906  
907 //**************************************************************************
908
909 // A derived class for q g -> W+- q'.
910
911 class Sigma2qg2Wq : public Sigma2ffbarWggm {
912
913 public:
914
915   // Constructor.
916   Sigma2qg2Wq() {}
917
918   // Initialize process. 
919   virtual void initProc(); 
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 "q g-> W+- q'";}
932   virtual int    code()    const {return 252;}
933   virtual string inFlux()  const {return "qg";}
934   virtual int    id3Mass() const {return 24;}
935
936 private:
937
938   // Values stored for later use.
939   double sigma0, openFracPos, openFracNeg;
940
941 };
942  
943 //**************************************************************************
944
945 // A derived class for f fbar' -> W+- gamma.
946
947 class Sigma2ffbar2Wgm : public Sigma2ffbarWggm {
948
949 public:
950
951   // Constructor.
952   Sigma2ffbar2Wgm() {}
953
954   // Initialize process. 
955   virtual void initProc(); 
956
957   // Calculate flavour-independent parts of cross section.
958   virtual void sigmaKin();
959
960   // Evaluate d(sigmaHat)/d(tHat). 
961   virtual double sigmaHat();
962
963   // Select flavour, colour and anticolour.
964   virtual void setIdColAcol();
965
966   // Info on the subprocess.
967   virtual string name()    const {return "f fbar' -> W+- gamma";}
968   virtual int    code()    const {return 253;}
969   virtual string inFlux()  const {return "ffbarChg";}
970   virtual int    id3Mass() const {return 24;}
971
972 private:
973
974   // Values stored for later use.
975   double sigma0, openFracPos, openFracNeg;
976
977 };
978  
979 //**************************************************************************
980
981 // A derived class for f gamma -> W+- f'.
982
983 class Sigma2fgm2Wf : public Sigma2ffbarWggm {
984
985 public:
986
987   // Constructor.
988   Sigma2fgm2Wf() {}
989
990   // Initialize process. 
991   virtual void initProc(); 
992
993   // Calculate flavour-independent parts of cross section.
994   virtual void sigmaKin();
995
996   // Evaluate d(sigmaHat)/d(tHat). 
997   virtual double sigmaHat();
998
999   // Select flavour, colour and anticolour.
1000   virtual void setIdColAcol();
1001
1002   // Info on the subprocess.
1003   virtual string name()    const {return "f gamma -> W+- f'";}
1004   virtual int    code()    const {return 254;}
1005   virtual string inFlux()  const {return "fgm";}
1006   virtual int    id3Mass() const {return 24;}
1007
1008 private:
1009
1010   // Values stored for later use.
1011   double sigma0, openFracPos, openFracNeg;
1012
1013 };
1014  
1015 //**************************************************************************
1016
1017 } // end namespace Pythia8
1018
1019 #endif // Pythia8_SigmaEW_H