StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
SigmaQCD.h
1 // SigmaQCD.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2018 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 QCD process differential cross sections.
7 // Contains classes derived from SigmaProcess via Sigma(0/2)Process.
8 
9 #ifndef Pythia8_SigmaQCD_H
10 #define Pythia8_SigmaQCD_H
11 
12 #include "Pythia8/SigmaProcess.h"
13 
14 namespace Pythia8 {
15 
16 //==========================================================================
17 
18 // A derived class for minimum-bias (inelastic, nondiffractive) events.
19 
20 class Sigma0nonDiffractive : public Sigma0Process {
21 
22 public:
23 
24  // Constructor.
25  Sigma0nonDiffractive() {}
26 
27  // Evaluate sigma.
28  virtual double sigmaHat() {return sigmaTotPtr->sigmaND();}
29 
30  // Select flavour, colour and anticolour.
31  virtual void setIdColAcol() {}
32 
33  // Info on the subprocess.
34  virtual string name() const {return "non-diffractive";}
35  virtual int code() const {return 101;}
36  virtual bool isNonDiff() const {return true;}
37 
38 private:
39 
40 };
41 
42 //==========================================================================
43 
44 // A derived class for elastic scattering A B -> A B.
45 
46 class Sigma0AB2AB : public Sigma0Process {
47 
48 public:
49 
50  // Constructor.
51  Sigma0AB2AB() {}
52 
53  // Evaluate sigma.
54  virtual double sigmaHat() {return sigmaTotPtr->sigmaEl();}
55 
56  // Select flavour, colour and anticolour.
57  virtual void setIdColAcol();
58 
59  // Info on the subprocess.
60  virtual string name() const {return "A B -> A B elastic";}
61  virtual int code() const {return 102;}
62  virtual bool isResolved() const {return false;}
63 
64 private:
65 
66 };
67 
68 //==========================================================================
69 
70 // A derived class for single diffractive scattering A B -> X B.
71 
72 class Sigma0AB2XB : public Sigma0Process {
73 
74 public:
75 
76  // Constructor.
77  Sigma0AB2XB() {}
78 
79  // Evaluate sigma.
80  virtual double sigmaHat() {return sigmaTotPtr->sigmaXB();}
81 
82  // Select flavour, colour and anticolour.
83  virtual void setIdColAcol();
84 
85  // Info on the subprocess.
86  virtual string name() const {return "A B -> X B single diffractive";}
87  virtual int code() const {return 103;}
88  virtual bool isResolved() const {return false;}
89  virtual bool isDiffA() const {return true;};
90 
91 private:
92 
93 };
94 
95 //==========================================================================
96 
97 // A derived class for single diffractive scattering A B -> A X.
98 
99 class Sigma0AB2AX : public Sigma0Process {
100 
101 public:
102 
103  // Constructor.
104  Sigma0AB2AX() {}
105 
106  // Evaluate sigma.
107  virtual double sigmaHat() {return sigmaTotPtr->sigmaAX();}
108 
109  // Select flavour, colour and anticolour.
110  virtual void setIdColAcol();
111 
112  // Info on the subprocess.
113  virtual string name() const {return "A B -> A X single diffractive";}
114  virtual int code() const {return 104;}
115  virtual bool isResolved() const {return false;}
116  virtual bool isDiffB() const {return true;};
117 
118 private:
119 
120 };
121 
122 //==========================================================================
123 
124 // A derived class for double diffractive scattering A B -> X X.
125 
126 class Sigma0AB2XX : public Sigma0Process {
127 
128 public:
129 
130  // Constructor.
131  Sigma0AB2XX() {}
132 
133  // Evaluate sigma.
134  virtual double sigmaHat() {return sigmaTotPtr->sigmaXX();}
135 
136  // Select flavour, colour and anticolour.
137  virtual void setIdColAcol();
138 
139  // Info on the subprocess.
140  virtual string name() const {return "A B -> X X double diffractive";}
141  virtual int code() const {return 105;}
142  virtual bool isResolved() const {return false;}
143  virtual bool isDiffA() const {return true;};
144  virtual bool isDiffB() const {return true;};
145 
146 private:
147 
148 };
149 
150 //==========================================================================
151 
152 // A derived class for central diffractive scattering A B -> A X B.
153 
154 class Sigma0AB2AXB : public Sigma0Process {
155 
156 public:
157 
158  // Constructor.
159  Sigma0AB2AXB() {}
160 
161  // Evaluate sigma.
162  virtual double sigmaHat() {return sigmaTotPtr->sigmaAXB();}
163 
164  // Select flavour, colour and anticolour.
165  virtual void setIdColAcol();
166 
167  // Info on the subprocess.
168  virtual string name() const {return "A B -> A X B central diffractive";}
169  virtual int code() const {return 106;}
170  virtual int nFinal() const {return 3;}
171  virtual bool isResolved() const {return false;}
172  virtual bool isDiffC() const {return true;};
173 
174 private:
175 
176 };
177 
178 //==========================================================================
179 
180 // A derived class for g g -> g g.
181 
182 class Sigma2gg2gg : public Sigma2Process {
183 
184 public:
185 
186  // Constructor.
187  Sigma2gg2gg() {}
188 
189  // Calculate flavour-independent parts of cross section.
190  virtual void sigmaKin();
191 
192  // Evaluate d(sigmaHat)/d(tHat).
193  virtual double sigmaHat() {return sigma;}
194 
195  // Select flavour, colour and anticolour.
196  virtual void setIdColAcol();
197 
198  // Info on the subprocess.
199  virtual string name() const {return "g g -> g g";}
200  virtual int code() const {return 111;}
201  virtual string inFlux() const {return "gg";}
202 
203 private:
204 
205  // Values stored for colour flow selection.
206  double sigTS, sigUS, sigTU, sigSum, sigma;
207 
208 };
209 
210 //==========================================================================
211 
212 // A derived class for g g -> q qbar (q = u, d, s, i.e. almost massless).
213 
214 class Sigma2gg2qqbar : public Sigma2Process {
215 
216 public:
217 
218  // Constructor.
219  Sigma2gg2qqbar() {}
220 
221  // Initialize process.
222  virtual void initProc();
223 
224  // Calculate flavour-independent parts of cross section.
225  virtual void sigmaKin();
226 
227  // Evaluate d(sigmaHat)/d(tHat).
228  virtual double sigmaHat() {return sigma;}
229 
230  // Select flavour, colour and anticolour.
231  virtual void setIdColAcol();
232 
233  // Info on the subprocess.
234  virtual string name() const {return "g g -> q qbar (uds)";}
235  virtual int code() const {return 112;}
236  virtual string inFlux() const {return "gg";}
237 
238 private:
239 
240  // Number of quarks to be considered in massless approximation.
241  int nQuarkNew;
242 
243  // Values stored for colour flow selection.
244  int idNew;
245  double mNew, m2New, sigTS, sigUS, sigSum, sigma;
246 
247 };
248 
249 //==========================================================================
250 
251 // A derived class for q g -> q g (q = u, d, s, c, b).
252 // Use massless approximation also for Q since no alternative.
253 
254 class Sigma2qg2qg : public Sigma2Process {
255 
256 public:
257 
258  // Constructor.
259  Sigma2qg2qg() {}
260 
261  // Calculate flavour-independent parts of cross section.
262  virtual void sigmaKin();
263 
264  // Evaluate d(sigmaHat)/d(tHat).
265  virtual double sigmaHat() {return sigma;}
266 
267  // Select flavour, colour and anticolour.
268  virtual void setIdColAcol();
269 
270  // Info on the subprocess.
271  virtual string name() const {return "q g -> q g";}
272  virtual int code() const {return 113;}
273  virtual string inFlux() const {return "qg";}
274 
275 private:
276 
277  // Values stored for colour flow selection.
278  double sigTS, sigTU, sigSum, sigma;
279 
280 };
281 
282 //==========================================================================
283 
284 // A derived class for q qbar' -> q qbar' or q q' -> q q'
285 // (qbar qbar' -> qbar qbar'), q' may be same as q.
286 
287 class Sigma2qq2qq : public Sigma2Process {
288 
289 public:
290 
291  // Constructor.
292  Sigma2qq2qq() {}
293 
294  // Calculate flavour-independent parts of cross section.
295  virtual void sigmaKin();
296 
297  // Evaluate d(sigmaHat)/d(tHat).
298  virtual double sigmaHat();
299 
300  // Select flavour, colour and anticolour.
301  virtual void setIdColAcol();
302 
303  // Info on the subprocess.
304  virtual string name() const {return "q q(bar)' -> q q(bar)'";}
305  virtual int code() const {return 114;}
306  virtual string inFlux() const {return "qq";}
307 
308  private:
309 
310  // Values stored for colour flow selection.
311  double sigT, sigU, sigTU, sigST, sigSum;
312 
313 };
314 
315 //==========================================================================
316 
317 // A derived class for q qbar -> g g.
318 
319 class Sigma2qqbar2gg : public Sigma2Process {
320 
321 public:
322 
323  // Constructor.
324  Sigma2qqbar2gg() {}
325 
326  // Calculate flavour-independent parts of cross section.
327  virtual void sigmaKin();
328 
329  // Evaluate d(sigmaHat)/d(tHat).
330  virtual double sigmaHat() {return sigma;}
331 
332  // Select flavour, colour and anticolour.
333  virtual void setIdColAcol();
334 
335  // Info on the subprocess.
336  virtual string name() const {return "q qbar -> g g";}
337  virtual int code() const {return 115;}
338  virtual string inFlux() const {return "qqbarSame";}
339 
340  private:
341 
342  // Values stored for colour flow selection.
343  double sigTS, sigUS, sigSum, sigma;
344 
345 };
346 
347 //==========================================================================
348 
349 // A derived class for q qbar -> q' qbar'.
350 
351 class Sigma2qqbar2qqbarNew : public Sigma2Process {
352 
353 public:
354 
355  // Constructor.
356  Sigma2qqbar2qqbarNew() {}
357 
358  // Initialize process.
359  virtual void initProc();
360 
361  // Calculate flavour-independent parts of cross section.
362  virtual void sigmaKin();
363 
364  // Evaluate d(sigmaHat)/d(tHat).
365  virtual double sigmaHat() {return sigma;}
366 
367  // Select flavour, colour and anticolour.
368  virtual void setIdColAcol();
369 
370  // Info on the subprocess.
371  virtual string name() const {return "q qbar -> q' qbar' (uds)";}
372  virtual int code() const {return 116;}
373  virtual string inFlux() const {return "qqbarSame";}
374 
375  private:
376 
377  // Number of quarks to be considered in massless approximation.
378  int nQuarkNew;
379 
380  // Values stored for colour flow selection.
381  int idNew;
382  double mNew, m2New, sigS, sigma;
383 
384 };
385 
386 //==========================================================================
387 
388 // A derived class for g g -> Q Qbar (Q = c, b or t).
389 
390 class Sigma2gg2QQbar : public Sigma2Process {
391 
392 public:
393 
394  // Constructor.
395  Sigma2gg2QQbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
396 
397  // Initialize process.
398  virtual void initProc();
399 
400  // Calculate flavour-independent parts of cross section.
401  virtual void sigmaKin();
402 
403  // Evaluate d(sigmaHat)/d(tHat).
404  virtual double sigmaHat() {return sigma;}
405 
406  // Select flavour, colour and anticolour.
407  virtual void setIdColAcol();
408 
409  // Evaluate weight for W decay angles in top decay (else inactive).
410  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
411 
412  // Info on the subprocess.
413  virtual string name() const {return nameSave;}
414  virtual int code() const {return codeSave;}
415  virtual string inFlux() const {return "gg";}
416  virtual int id3Mass() const {return idNew;}
417  virtual int id4Mass() const {return idNew;}
418 
419  private:
420 
421  // Values stored for process type and colour flow selection.
422  int idNew, codeSave;
423  string nameSave;
424  double sigTS, sigUS, sigSum, sigma, openFracPair;
425 
426 };
427 
428 //==========================================================================
429 
430 // A derived class for q qbar -> Q Qbar (Q = c, b or t).
431 
432 class Sigma2qqbar2QQbar : public Sigma2Process {
433 
434 public:
435 
436  // Constructor.
437  Sigma2qqbar2QQbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
438 
439  // Initialize process.
440  virtual void initProc();
441 
442  // Calculate flavour-independent parts of cross section.
443  virtual void sigmaKin();
444 
445  // Evaluate d(sigmaHat)/d(tHat).
446  virtual double sigmaHat() {return sigma;}
447 
448  // Select flavour, colour and anticolour.
449  virtual void setIdColAcol();
450 
451  // Evaluate weight for W decay angles in top decay (else inactive).
452  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
453 
454  // Info on the subprocess.
455  virtual string name() const {return nameSave;}
456  virtual int code() const {return codeSave;}
457  virtual string inFlux() const {return "qqbarSame";}
458  virtual int id3Mass() const {return idNew;}
459  virtual int id4Mass() const {return idNew;}
460 
461  private:
462 
463  // Values stored for process type.
464  int idNew, codeSave;
465  string nameSave;
466  double sigma, openFracPair;
467 
468 };
469 
470 //==========================================================================
471 
472 // A derived class for g g -> g g g.
473 
474 class Sigma3gg2ggg : public Sigma3Process {
475 
476 public:
477 
478  // Constructor.
479  Sigma3gg2ggg() {}
480 
481  // Calculate flavour-independent parts of cross section.
482  virtual void sigmaKin();
483 
484  // Evaluate d(sigmaHat)/d(tHat).
485  virtual double sigmaHat() {return sigma;}
486 
487  // Select flavour, colour and anticolour.
488  virtual void setIdColAcol();
489 
490  // Info on the subprocess.
491  virtual string name() const {return "g g -> g g g";}
492  virtual int code() const {return 131;}
493  virtual int nFinal() const {return 3;}
494  virtual string inFlux() const {return "gg";}
495  virtual bool isQCD3body() const {return true;}
496 
497 private:
498 
499  // Values stored for colour flow selection.
500  double sigma;
501 
502  // Intermediate storage and calculation of four-products.
503  double pp[6][6];
504  double cycle(int i1, int i2, int i3, int i4, int i5) {return
505  pp[i1][i2] * pp[i2][i3] * pp[i3][i4] * pp[i4][i5] * pp[i5][i1];}
506 
507 };
508 
509 //==========================================================================
510 
511 // A derived class for q qbar -> g g g.
512 
513 class Sigma3qqbar2ggg : public Sigma3Process {
514 
515 public:
516 
517  // Constructor.
518  Sigma3qqbar2ggg() {}
519 
520  // Calculate flavour-independent parts of cross section.
521  virtual void sigmaKin();
522 
523  // Evaluate d(sigmaHat)/d(tHat).
524  virtual double sigmaHat() {return sigma;}
525 
526  // Select flavour, colour and anticolour.
527  virtual void setIdColAcol();
528 
529  // Info on the subprocess.
530  virtual string name() const {return "q qbar -> g g g";}
531  virtual int code() const {return 132;}
532  virtual int nFinal() const {return 3;}
533  virtual string inFlux() const {return "qqbarSame";}
534  virtual bool isQCD3body() const {return true;}
535 
536 protected:
537 
538  // Pick/map a random final state configuration
539  int config;
540  inline void pickFinal() { config = int( 6 * rndmPtr->flat() ); }
541  inline void mapFinal();
542 
543  // |M|^2 calculation
544  inline double m2Calc();
545 
546  // Four-vectors for |M|^2 calculation
547  Vec4 pCM[5];
548 
549  // Intermediate storage and calculation of four-products
550  double a[3], b[3], pp[3][3], ab[3][3];
551 
552  // Values stored for colour flow selection.
553  double sigma;
554 
555 };
556 
557 //==========================================================================
558 
559 // A derived class for q g -> q g g
560 // Derived from Sigma3qqbar2ggg
561 
562 class Sigma3qg2qgg : public Sigma3qqbar2ggg {
563 
564 public:
565 
566  // Constructor.
567  Sigma3qg2qgg() {}
568 
569  // Calculate flavour-independent parts of cross section.
570  virtual void sigmaKin();
571 
572  // Evaluate d(sigmaHat)/d(tHat).
573  virtual double sigmaHat();
574 
575  // Select flavour, colour and anticolour.
576  virtual void setIdColAcol();
577 
578  // Info on the subprocess.
579  virtual string name() const {return "q g -> q g g";}
580  virtual int code() const {return 133;}
581  virtual int nFinal() const {return 3;}
582  virtual string inFlux() const {return "qg";}
583  virtual bool isQCD3body() const {return true;}
584 
585 private:
586 
587  // Sigma for (qg) and (gq) incoming
588  double sigma[2];
589 
590 };
591 
592 //==========================================================================
593 
594 // A derived class for g g -> q qbar g
595 // Derived from Sigma3qqbar2ggg
596 
597 class Sigma3gg2qqbarg : public Sigma3qqbar2ggg {
598 
599 public:
600 
601  // Constructor.
602  Sigma3gg2qqbarg() {}
603 
604  // Initialize process.
605  virtual void initProc();
606 
607  // Calculate flavour-independent parts of cross section.
608  virtual void sigmaKin();
609 
610  // Select flavour, colour and anticolour.
611  virtual void setIdColAcol();
612 
613  // Info on the subprocess.
614  virtual string name() const {return "g g -> q qbar g";}
615  virtual int code() const {return 138;}
616  virtual int nFinal() const {return 3;}
617  virtual string inFlux() const {return "gg";}
618  virtual bool isQCD3body() const {return true;}
619 
620 private:
621 
622  // Number of quarks to be considered in massless approximation.
623  int nQuarkNew;
624 
625 };
626 
627 //==========================================================================
628 
629 // A derived class for q q' -> q q' g
630 
631 class Sigma3qq2qqgDiff : public Sigma3Process {
632 
633 public:
634 
635  // Constructor.
636  Sigma3qq2qqgDiff() {}
637 
638  // Calculate flavour-independent parts of cross section.
639  virtual void sigmaKin();
640 
641  // Evaluate d(sigmaHat)/d(tHat).
642  virtual double sigmaHat();
643 
644  // Select flavour, colour and anticolour.
645  virtual void setIdColAcol();
646 
647  // Info on the subprocess.
648  virtual string name() const
649  {return "q(bar) q(bar)' -> q(bar) q(bar)' g";}
650  virtual int code() const {return 134;}
651  virtual int nFinal() const {return 3;}
652  virtual string inFlux() const {return "qq";}
653  virtual bool isQCD3body() const {return true;}
654 
655 protected:
656 
657  // Pick/map a random final state configuration
658  int config;
659  inline void pickFinal() { config = int( 6 * rndmPtr->flat() ); }
660  inline void mapFinal();
661 
662  // |M|^2 calculation
663  inline double m2Calc();
664 
665  // Kinematic configuration
666  Vec4 pCM[5];
667 
668  // Four-products
669  double s, t, u, sp, tp, up;
670 
671  // Cross section
672  double sigma;
673 
674 };
675 
676 //==========================================================================
677 
678 // A derived class for q qbar -> q' qbar' g
679 // Derived from Sigma3qq2qqgDiff
680 
681 class Sigma3qqbar2qqbargDiff : public Sigma3qq2qqgDiff {
682 
683 public:
684 
685  // Constructor.
686  Sigma3qqbar2qqbargDiff() {}
687 
688  // Initialize process.
689  virtual void initProc();
690 
691  // Calculate flavour-independent parts of cross section.
692  virtual void sigmaKin();
693 
694  // Evaluate d(sigmaHat)/d(tHat).
695  virtual double sigmaHat() {return sigma;}
696 
697  // Select flavour, colour and anticolour.
698  virtual void setIdColAcol();
699 
700  // Info on the subprocess.
701  virtual string name() const {return "q qbar -> q' qbar' g";}
702  virtual int code() const {return 136;}
703  virtual int nFinal() const {return 3;}
704  virtual string inFlux() const {return "qqbarSame";}
705  virtual bool isQCD3body() const {return true;}
706 
707 private:
708 
709  // Number of quarks to be considered in massless approximation.
710  int nQuarkNew;
711 
712 };
713 
714 //==========================================================================
715 
716 // A derived class for q g -> q q' qbar'
717 // Derived from Sigma3qq2qqgDiff
718 
719 class Sigma3qg2qqqbarDiff : public Sigma3qq2qqgDiff {
720 
721 public:
722 
723  // Constructor.
724  Sigma3qg2qqqbarDiff() {}
725 
726  // Initialize process.
727  virtual void initProc();
728 
729  // Calculate flavour-independent parts of cross section.
730  virtual void sigmaKin();
731 
732  // Evaluate d(sigmaHat)/d(tHat).
733  virtual double sigmaHat();
734 
735  // Select flavour, colour and anticolour.
736  virtual void setIdColAcol();
737 
738  // Info on the subprocess.
739  virtual string name() const {return "q g -> q q' qbar'";}
740  virtual int code() const {return 139;}
741  virtual int nFinal() const {return 3;}
742  virtual string inFlux() const {return "qg";}
743  virtual bool isQCD3body() const {return true;}
744 
745 private:
746 
747  // Number of quarks to be considered in massless approximation.
748  int nQuarkNew;
749 
750  // gq and qg incoming
751  double sigma[2];
752 
753 };
754 
755 //==========================================================================
756 
757 // A derived class for q q -> q q g
758 
759 class Sigma3qq2qqgSame : public Sigma3Process {
760 
761 public:
762 
763  // Constructor.
764  Sigma3qq2qqgSame() {}
765 
766  // Calculate flavour-independent parts of cross section.
767  virtual void sigmaKin();
768 
769  // Evaluate d(sigmaHat)/d(tHat).
770  virtual double sigmaHat();
771 
772  // Select flavour, colour and anticolour.
773  virtual void setIdColAcol();
774 
775  // Info on the subprocess.
776  virtual string name() const
777  {return "q(bar) q(bar) -> q(bar) q(bar) g";}
778  virtual int code() const {return 135;}
779  virtual int nFinal() const {return 3;}
780  virtual string inFlux() const {return "qq";}
781  virtual bool isQCD3body() const {return true;}
782 
783 protected:
784 
785  // Pick/map a random final state configuration
786  int config;
787  inline void pickFinal() { config = int( 6 * rndmPtr->flat() ); }
788  inline void mapFinal();
789 
790  // |M|^2 calculation
791  inline double m2Calc();
792 
793  // Kinematic configuration
794  Vec4 pCM[5];
795 
796  // Four-products
797  double s, t, u, sp, tp, up;
798  double ssp, ttp, uup, s_sp, t_tp, u_up;
799 
800  // Cross section
801  double sigma;
802 
803 };
804 
805 //==========================================================================
806 
807 // A derived class for q q -> q q g
808 // Derived from Sigma3qq2qqgSame
809 
810 class Sigma3qqbar2qqbargSame : public Sigma3qq2qqgSame {
811 
812 public:
813 
814  // Constructor.
815  Sigma3qqbar2qqbargSame() {}
816 
817  // Calculate flavour-independent parts of cross section.
818  virtual void sigmaKin();
819 
820  // Evaluate d(sigmaHat)/d(tHat).
821  virtual double sigmaHat() {return sigma;}
822 
823  // Select flavour, colour and anticolour.
824  virtual void setIdColAcol();
825 
826  // Info on the subprocess.
827  virtual string name() const {return "q qbar -> q qbar g";}
828  virtual int code() const {return 137;}
829  virtual int nFinal() const {return 3;}
830  virtual string inFlux() const {return "qqbarSame";}
831  virtual bool isQCD3body() const {return true;}
832 
833 private:
834 
835 };
836 
837 //==========================================================================
838 
839 // A derived class for q g -> q qbar q; same flavour.
840 // Derived from Sigma3qq2qqgSame
841 
842 class Sigma3qg2qqqbarSame : public Sigma3qq2qqgSame {
843 
844 public:
845 
846  // Constructor.
847  Sigma3qg2qqqbarSame() {}
848 
849  // Calculate flavour-independent parts of cross section.
850  virtual void sigmaKin();
851 
852  // Evaluate d(sigmaHat)/d(tHat).
853  virtual double sigmaHat();
854 
855  // Select flavour, colour and anticolour.
856  virtual void setIdColAcol();
857 
858  // Info on the subprocess.
859  virtual string name() const {return "q g -> q q qbar";}
860  virtual int code() const {return 140;}
861  virtual int nFinal() const {return 3;}
862  virtual string inFlux() const {return "qg";}
863  virtual bool isQCD3body() const {return true;}
864 
865 private:
866 
867  // gq and qg incoming
868  double sigma[2];
869 
870 };
871 
872 //==========================================================================
873 
874 } // end namespace Pythia8
875 
876 #endif // Pythia8_SigmaQCD_H
Definition: AgUStep.h:26