PYTHIA  8.316
SigmaQCD.h
1 // SigmaQCD.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2025 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 // Auxiliary class for top threshold corrections, based on
397 // V. Fadin, V. Khoze and T. Sjostrand, Z. Phys. C48 (1990) 613.
398 
400 
401 public:
402 
403  // Trivial constructor and destructor.
405  ~TopThreshold() {}
406 
407  // Initialization setup - read in necessary settings.
408  void setup( int topModelIn, double mtIn, double gammatIn,
409  double thresholdWidthIn, double singletFracIn,
410  int alphasOrder, double alphasValue);
411 
412  // Cross section enhancement factor, combined.
413  double multiplySigmaBy( bool inInit, double mHat, double m3, double m4,
414  double eThr);
415 
416  // Imaginary part of Green's function for singlet state.
417  double imGreenSin(double eNow, double mtNow);
418 
419  // Imaginary part of Green's function for octet state.
420  double imGreenOct(double eNow, double mtNow);
421 
422 private:
423 
424  // Commonly available variables.
425  int topModel;
426  double mt, gammat, thrWidth, singletFrac, alps;
427 
428  // Need alphaStrong with special scale.
429  AlphaStrong alphas;
430 
431 };
432 
433 //==========================================================================
434 
435 // A derived class for g g -> Q Qbar (Q = c, b or t).
436 
438 
439 public:
440 
441  // Constructor.
442  Sigma2gg2QQbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn),
443  sigTS(), sigUS(), sigSum(), sigma(), openFracPair() {}
444 
445  // Initialize process.
446  virtual void initProc();
447 
448  // Calculate flavour-independent parts of cross section.
449  virtual void sigmaKin();
450 
451  // Evaluate d(sigmaHat)/d(tHat).
452  virtual double sigmaHat() {return sigma;}
453 
454  // Select flavour, colour and anticolour.
455  virtual void setIdColAcol();
456 
457  // Evaluate weight for W decay angles in top decay (else inactive).
458  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
459 
460  // Info on the subprocess.
461  virtual string name() const {return nameSave;}
462  virtual int code() const {return codeSave;}
463  virtual string inFlux() const {return "gg";}
464  virtual int id3Mass() const {return idNew;}
465  virtual int id4Mass() const {return idNew;}
466 
467  private:
468 
469  // Values stored for process type and colour flow selection.
470  int idNew, codeSave, topModel;
471  string nameSave;
472  double sigTS, sigUS, sigSum, sigma, openFracPair, ggSingletFrac;
473 
474  // Class for top threshold corrections.
475  TopThreshold topThreshold;
476 
477 };
478 
479 //==========================================================================
480 
481 // A derived class for q qbar -> Q Qbar (Q = c, b or t).
482 
484 
485 public:
486 
487  // Constructor.
488  Sigma2qqbar2QQbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn),
489  sigma(), openFracPair() {}
490 
491  // Initialize process.
492  virtual void initProc();
493 
494  // Calculate flavour-independent parts of cross section.
495  virtual void sigmaKin();
496 
497  // Evaluate d(sigmaHat)/d(tHat).
498  virtual double sigmaHat() {return sigma;}
499 
500  // Select flavour, colour and anticolour.
501  virtual void setIdColAcol();
502 
503  // Evaluate weight for W decay angles in top decay (else inactive).
504  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
505 
506  // Info on the subprocess.
507  virtual string name() const {return nameSave;}
508  virtual int code() const {return codeSave;}
509  virtual string inFlux() const {return "qqbarSame";}
510  virtual int id3Mass() const {return idNew;}
511  virtual int id4Mass() const {return idNew;}
512 
513  private:
514 
515  // Values stored for process type.
516  int idNew, codeSave, topModel;
517  string nameSave;
518  double sigma, openFracPair, qqSingletFrac;
519 
520  // Class for top threshold corrections.
521  TopThreshold topThreshold;
522 
523 };
524 
525 //==========================================================================
526 
527 // A derived class for g g -> g g g.
528 
529 class Sigma3gg2ggg : public Sigma3Process {
530 
531 public:
532 
533  // Constructor.
534  Sigma3gg2ggg() : sigma(), pp() {}
535 
536  // Calculate flavour-independent parts of cross section.
537  virtual void sigmaKin();
538 
539  // Evaluate d(sigmaHat)/d(tHat).
540  virtual double sigmaHat() {return sigma;}
541 
542  // Select flavour, colour and anticolour.
543  virtual void setIdColAcol();
544 
545  // Info on the subprocess.
546  virtual string name() const {return "g g -> g g g";}
547  virtual int code() const {return 131;}
548  virtual int nFinal() const {return 3;}
549  virtual string inFlux() const {return "gg";}
550  virtual bool isQCD3body() const {return true;}
551 
552 private:
553 
554  // Values stored for colour flow selection.
555  double sigma;
556 
557  // Intermediate storage and calculation of four-products.
558  double pp[6][6];
559  double cycle(int i1, int i2, int i3, int i4, int i5) {return
560  pp[i1][i2] * pp[i2][i3] * pp[i3][i4] * pp[i4][i5] * pp[i5][i1];}
561 
562 };
563 
564 //==========================================================================
565 
566 // A derived class for q qbar -> g g g.
567 
569 
570 public:
571 
572  // Constructor.
573  Sigma3qqbar2ggg() : config(), a(), b(), pp(), ab(), sigma() {}
574 
575  // Calculate flavour-independent parts of cross section.
576  virtual void sigmaKin();
577 
578  // Evaluate d(sigmaHat)/d(tHat).
579  virtual double sigmaHat() {return sigma;}
580 
581  // Select flavour, colour and anticolour.
582  virtual void setIdColAcol();
583 
584  // Info on the subprocess.
585  virtual string name() const {return "q qbar -> g g g";}
586  virtual int code() const {return 132;}
587  virtual int nFinal() const {return 3;}
588  virtual string inFlux() const {return "qqbarSame";}
589  virtual bool isQCD3body() const {return true;}
590 
591 protected:
592 
593  // Pick/map a random final state configuration
594  int config;
595  inline void pickFinal() { config = int( 6 * rndmPtr->flat() ); }
596  inline void mapFinal();
597 
598  // |M|^2 calculation
599  inline double m2Calc();
600 
601  // Four-vectors for |M|^2 calculation
602  Vec4 pCM[5];
603 
604  // Intermediate storage and calculation of four-products
605  double a[3], b[3], pp[3][3], ab[3][3];
606 
607  // Values stored for colour flow selection.
608  double sigma;
609 
610 };
611 
612 //==========================================================================
613 
614 // A derived class for q g -> q g g
615 // Derived from Sigma3qqbar2ggg
616 
618 
619 public:
620 
621  // Constructor.
622  Sigma3qg2qgg() : sigma() {}
623 
624  // Calculate flavour-independent parts of cross section.
625  virtual void sigmaKin();
626 
627  // Evaluate d(sigmaHat)/d(tHat).
628  virtual double sigmaHat();
629 
630  // Select flavour, colour and anticolour.
631  virtual void setIdColAcol();
632 
633  // Info on the subprocess.
634  virtual string name() const {return "q g -> q g g";}
635  virtual int code() const {return 133;}
636  virtual int nFinal() const {return 3;}
637  virtual string inFlux() const {return "qg";}
638  virtual bool isQCD3body() const {return true;}
639 
640 private:
641 
642  // Sigma for (qg) and (gq) incoming
643  double sigma[2];
644 
645 };
646 
647 //==========================================================================
648 
649 // A derived class for g g -> q qbar g
650 // Derived from Sigma3qqbar2ggg
651 
653 
654 public:
655 
656  // Constructor.
657  Sigma3gg2qqbarg() : nQuarkNew() {}
658 
659  // Initialize process.
660  virtual void initProc();
661 
662  // Calculate flavour-independent parts of cross section.
663  virtual void sigmaKin();
664 
665  // Select flavour, colour and anticolour.
666  virtual void setIdColAcol();
667 
668  // Info on the subprocess.
669  virtual string name() const {return "g g -> q qbar g";}
670  virtual int code() const {return 138;}
671  virtual int nFinal() const {return 3;}
672  virtual string inFlux() const {return "gg";}
673  virtual bool isQCD3body() const {return true;}
674 
675 private:
676 
677  // Number of quarks to be considered in massless approximation.
678  int nQuarkNew;
679 
680 };
681 
682 //==========================================================================
683 
684 // A derived class for q q' -> q q' g
685 
687 
688 public:
689 
690  // Constructor.
691  Sigma3qq2qqgDiff() : config(), s(), t(), u(), sp(), tp(), up(), sigma() {}
692 
693  // Calculate flavour-independent parts of cross section.
694  virtual void sigmaKin();
695 
696  // Evaluate d(sigmaHat)/d(tHat).
697  virtual double sigmaHat();
698 
699  // Select flavour, colour and anticolour.
700  virtual void setIdColAcol();
701 
702  // Info on the subprocess.
703  virtual string name() const
704  {return "q(bar) q(bar)' -> q(bar) q(bar)' g";}
705  virtual int code() const {return 134;}
706  virtual int nFinal() const {return 3;}
707  virtual string inFlux() const {return "qq";}
708  virtual bool isQCD3body() const {return true;}
709 
710 protected:
711 
712  // Pick/map a random final state configuration
713  int config;
714  inline void pickFinal() { config = int( 6 * rndmPtr->flat() ); }
715  inline void mapFinal();
716 
717  // |M|^2 calculation
718  inline double m2Calc();
719 
720  // Kinematic configuration
721  Vec4 pCM[5];
722 
723  // Four-products
724  double s, t, u, sp, tp, up;
725 
726  // Cross section
727  double sigma;
728 
729 };
730 
731 //==========================================================================
732 
733 // A derived class for q qbar -> q' qbar' g
734 // Derived from Sigma3qq2qqgDiff
735 
737 
738 public:
739 
740  // Constructor.
741  Sigma3qqbar2qqbargDiff() : nQuarkNew() {}
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() {return sigma;}
751 
752  // Select flavour, colour and anticolour.
753  virtual void setIdColAcol();
754 
755  // Info on the subprocess.
756  virtual string name() const {return "q qbar -> q' qbar' g";}
757  virtual int code() const {return 136;}
758  virtual int nFinal() const {return 3;}
759  virtual string inFlux() const {return "qqbarSame";}
760  virtual bool isQCD3body() const {return true;}
761 
762 private:
763 
764  // Number of quarks to be considered in massless approximation.
765  int nQuarkNew;
766 
767 };
768 
769 //==========================================================================
770 
771 // A derived class for q g -> q q' qbar'
772 // Derived from Sigma3qq2qqgDiff
773 
775 
776 public:
777 
778  // Constructor.
779  Sigma3qg2qqqbarDiff() : nQuarkNew(), sigma() {}
780 
781  // Initialize process.
782  virtual void initProc();
783 
784  // Calculate flavour-independent parts of cross section.
785  virtual void sigmaKin();
786 
787  // Evaluate d(sigmaHat)/d(tHat).
788  virtual double sigmaHat();
789 
790  // Select flavour, colour and anticolour.
791  virtual void setIdColAcol();
792 
793  // Info on the subprocess.
794  virtual string name() const {return "q g -> q q' qbar'";}
795  virtual int code() const {return 139;}
796  virtual int nFinal() const {return 3;}
797  virtual string inFlux() const {return "qg";}
798  virtual bool isQCD3body() const {return true;}
799 
800 private:
801 
802  // Number of quarks to be considered in massless approximation.
803  int nQuarkNew;
804 
805  // gq and qg incoming
806  double sigma[2];
807 
808 };
809 
810 //==========================================================================
811 
812 // A derived class for q q -> q q g
813 
815 
816 public:
817 
818  // Constructor.
819  Sigma3qq2qqgSame() : config(), s(), t(), u(), sp(), tp(), up(), ssp(),
820  ttp(), uup(), s_sp(), t_tp(), u_up(), sigma() {}
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
833  {return "q(bar) q(bar) -> q(bar) q(bar) g";}
834  virtual int code() const {return 135;}
835  virtual int nFinal() const {return 3;}
836  virtual string inFlux() const {return "qq";}
837  virtual bool isQCD3body() const {return true;}
838 
839 protected:
840 
841  // Pick/map a random final state configuration
842  int config;
843  inline void pickFinal() { config = int( 6 * rndmPtr->flat() ); }
844  inline void mapFinal();
845 
846  // |M|^2 calculation
847  inline double m2Calc();
848 
849  // Kinematic configuration
850  Vec4 pCM[5];
851 
852  // Four-products
853  double s, t, u, sp, tp, up;
854  double ssp, ttp, uup, s_sp, t_tp, u_up;
855 
856  // Cross section
857  double sigma;
858 
859 };
860 
861 //==========================================================================
862 
863 // A derived class for q q -> q q g
864 // Derived from Sigma3qq2qqgSame
865 
867 
868 public:
869 
870  // Constructor.
872 
873  // Calculate flavour-independent parts of cross section.
874  virtual void sigmaKin();
875 
876  // Evaluate d(sigmaHat)/d(tHat).
877  virtual double sigmaHat() {return sigma;}
878 
879  // Select flavour, colour and anticolour.
880  virtual void setIdColAcol();
881 
882  // Info on the subprocess.
883  virtual string name() const {return "q qbar -> q qbar g";}
884  virtual int code() const {return 137;}
885  virtual int nFinal() const {return 3;}
886  virtual string inFlux() const {return "qqbarSame";}
887  virtual bool isQCD3body() const {return true;}
888 
889 private:
890 
891 };
892 
893 //==========================================================================
894 
895 // A derived class for q g -> q qbar q; same flavour.
896 // Derived from Sigma3qq2qqgSame
897 
899 
900 public:
901 
902  // Constructor.
903  Sigma3qg2qqqbarSame() : sigma() {}
904 
905  // Calculate flavour-independent parts of cross section.
906  virtual void sigmaKin();
907 
908  // Evaluate d(sigmaHat)/d(tHat).
909  virtual double sigmaHat();
910 
911  // Select flavour, colour and anticolour.
912  virtual void setIdColAcol();
913 
914  // Info on the subprocess.
915  virtual string name() const {return "q g -> q q qbar";}
916  virtual int code() const {return 140;}
917  virtual int nFinal() const {return 3;}
918  virtual string inFlux() const {return "qg";}
919  virtual bool isQCD3body() const {return true;}
920 
921 private:
922 
923  // gq and qg incoming
924  double sigma[2];
925 
926 };
927 
928 //==========================================================================
929 
930 } // end namespace Pythia8
931 
932 #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:585
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:546
Sigma2gg2qqbar()
Constructor.
Definition: SigmaQCD.h:225
TopThreshold()
Trivial constructor and destructor.
Definition: SigmaQCD.h:404
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:568
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:832
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:866
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:883
Definition: StandardModel.h:23
Definition: SigmaQCD.h:898
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:145
virtual int nFinal() const
Number of final-state particles.
Definition: SigmaQCD.h:636
virtual double sigmaHat()
Evaluate d(sigmaHat)/d(tHat).
Definition: SigmaQCD.h:498
Sigma3qq2qqgSame()
Constructor.
Definition: SigmaQCD.h:819
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:917
Sigma3qqbar2qqbargDiff()
Constructor.
Definition: SigmaQCD.h:741
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:408
virtual int nFinal() const
Number of final-state particles.
Definition: SigmaQCD.h:835
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:671
virtual double weightDecay(Event &, int, int)
Definition: SigmaProcess.h:169
virtual int nFinal() const
Number of final-state particles.
Definition: SigmaQCD.h:548
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:35
Sigma3qqbar2ggg()
Constructor.
Definition: SigmaQCD.h:573
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:760
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:759
Definition: SigmaQCD.h:294
Definition: SigmaQCD.h:399
Sigma0AB2AX()
Constructor.
Definition: SigmaQCD.h:107
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:638
Rndm * rndmPtr
Pointer to the random number generator.
Definition: PhysicsBase.h:97
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:796
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:550
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:669
A derived class for g g -> g g.
Definition: SigmaQCD.h:188
Definition: SigmaQCD.h:652
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:534
virtual double sigmaHat()
Evaluate d(sigmaHat)/d(tHat).
Definition: SigmaQCD.h:199
Sigma3qg2qqqbarDiff()
Constructor.
Definition: SigmaQCD.h:779
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:589
Sigma0AB2AXB()
Constructor.
Definition: SigmaQCD.h:164
Sigma2gg2gg()
Constructor.
Definition: SigmaQCD.h:193
Sigma3qq2qqgDiff()
Constructor.
Definition: SigmaQCD.h:691
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:617
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:794
A derived class for q qbar -> g g.
Definition: SigmaQCD.h:326
A derived class for g g -> g g g.
Definition: SigmaQCD.h:529
Sigma2qg2qg()
Constructor.
Definition: SigmaQCD.h:266
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:707
Definition: SigmaProcess.h:545
double s
Four-products.
Definition: SigmaQCD.h:724
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:637
Definition: SigmaProcess.h:401
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:915
virtual double sigmaHat()
Evaluate sigma.
Definition: SigmaQCD.h:110
Sigma3qg2qqqbarSame()
Constructor.
Definition: SigmaQCD.h:903
A derived class for g g -> Q Qbar (Q = c, b or t).
Definition: SigmaQCD.h:437
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:634
A derived class for q qbar -> Q Qbar (Q = c, b or t).
Definition: SigmaQCD.h:483
Sigma2gg2QQbar(int idIn, int codeIn)
Constructor.
Definition: SigmaQCD.h:442
Sigma2qqbar2qqbarNew()
Constructor.
Definition: SigmaQCD.h:363
Sigma2qqbar2QQbar(int idIn, int codeIn)
Constructor.
Definition: SigmaQCD.h:488
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:509
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:886
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:549
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:510
double s
Four-products.
Definition: SigmaQCD.h:853
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:918
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:919
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:708
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:887
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:507
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:241
double sigma
Values stored for colour flow selection.
Definition: SigmaQCD.h:608
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:837
virtual int nFinal() const
Number of final-state particles.
Definition: SigmaQCD.h:587
A derived class for minimum-bias (inelastic, nondiffractive) events.
Definition: SigmaQCD.h:20
Sigma3qg2qgg()
Constructor.
Definition: SigmaQCD.h:622
double sigma
Cross section.
Definition: SigmaQCD.h:857
virtual double sigmaHat()
Evaluate d(sigmaHat)/d(tHat).
Definition: SigmaQCD.h:540
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:797
Sigma0AB2AB()
Constructor.
Definition: SigmaQCD.h:52
virtual int nFinal() const
Number of final-state particles.
Definition: SigmaQCD.h:758
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:836
Definition: SigmaQCD.h:261
int config
Pick/map a random final state configuration.
Definition: SigmaQCD.h:842
Sigma2qqbar2gg()
Constructor.
Definition: SigmaQCD.h:331
Info * infoPtr
Definition: PhysicsBase.h:82
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:594
Sigma3gg2qqbarg()
Constructor.
Definition: SigmaQCD.h:657
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:673
Definition: SigmaQCD.h:774
Sigma0nonDiffractive()
Constructor.
Definition: SigmaQCD.h:25
virtual int id3Mass() const
Definition: SigmaQCD.h:464
double sigma
Cross section.
Definition: SigmaQCD.h:727
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:706
Sigma2qq2qq()
Constructor.
Definition: SigmaQCD.h:299
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:672
virtual double sigmaHat()
Evaluate d(sigmaHat)/d(tHat).
Definition: SigmaQCD.h:579
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:703
Definition: SigmaQCD.h:736
Sigma3qqbar2qqbargSame()
Constructor.
Definition: SigmaQCD.h:871
virtual bool isQCD3body() const
QCD 2 -> 3 processes need special phase space selection machinery.
Definition: SigmaQCD.h:798
virtual double sigmaHat()
Evaluate d(sigmaHat)/d(tHat).
Definition: SigmaQCD.h:452
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:756
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:885
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:750
A derived class for q q' -> q q' g.
Definition: SigmaQCD.h:686
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:119
A derived class for q q -> q q g.
Definition: SigmaQCD.h:814
virtual double sigmaHat()
Evaluate d(sigmaHat)/d(tHat).
Definition: SigmaQCD.h:877
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:588
virtual string name() const
Info on the subprocess.
Definition: SigmaQCD.h:461
int config
Pick/map a random final state configuration.
Definition: SigmaQCD.h:713
virtual string inFlux() const
Need to know which incoming partons to set up interaction for.
Definition: SigmaQCD.h:463