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