Line data Source code
1 : // SigmaQCD.h is a part of the PYTHIA event generator.
2 : // Copyright (C) 2015 Torbjorn Sjostrand.
3 : // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
4 : // Please respect the MCnet Guidelines, see GUIDELINES for details.
5 :
6 : // Header file for 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 0 : class Sigma0nonDiffractive : public Sigma0Process {
21 :
22 : public:
23 :
24 : // Constructor.
25 0 : Sigma0nonDiffractive() {}
26 :
27 : // Evaluate sigma.
28 0 : virtual double sigmaHat() {return sigmaTotPtr->sigmaND();}
29 :
30 : // Select flavour, colour and anticolour.
31 0 : virtual void setIdColAcol() {}
32 :
33 : // Info on the subprocess.
34 0 : virtual string name() const {return "non-diffractive";}
35 0 : virtual int code() const {return 101;}
36 0 : 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 0 : class Sigma0AB2AB : public Sigma0Process {
47 :
48 : public:
49 :
50 : // Constructor.
51 0 : Sigma0AB2AB() {}
52 :
53 : // Evaluate sigma.
54 0 : virtual double sigmaHat() {return sigmaTotPtr->sigmaEl();}
55 :
56 : // Select flavour, colour and anticolour.
57 : virtual void setIdColAcol();
58 :
59 : // Info on the subprocess.
60 0 : virtual string name() const {return "A B -> A B elastic";}
61 0 : virtual int code() const {return 102;}
62 0 : 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 0 : class Sigma0AB2XB : public Sigma0Process {
73 :
74 : public:
75 :
76 : // Constructor.
77 0 : Sigma0AB2XB() {}
78 :
79 : // Evaluate sigma.
80 0 : virtual double sigmaHat() {return sigmaTotPtr->sigmaXB();}
81 :
82 : // Select flavour, colour and anticolour.
83 : virtual void setIdColAcol();
84 :
85 : // Info on the subprocess.
86 0 : virtual string name() const {return "A B -> X B single diffractive";}
87 0 : virtual int code() const {return 103;}
88 0 : virtual bool isResolved() const {return false;}
89 0 : 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 0 : class Sigma0AB2AX : public Sigma0Process {
100 :
101 : public:
102 :
103 : // Constructor.
104 0 : Sigma0AB2AX() {}
105 :
106 : // Evaluate sigma.
107 0 : virtual double sigmaHat() {return sigmaTotPtr->sigmaAX();}
108 :
109 : // Select flavour, colour and anticolour.
110 : virtual void setIdColAcol();
111 :
112 : // Info on the subprocess.
113 0 : virtual string name() const {return "A B -> A X single diffractive";}
114 0 : virtual int code() const {return 104;}
115 0 : virtual bool isResolved() const {return false;}
116 0 : 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 0 : class Sigma0AB2XX : public Sigma0Process {
127 :
128 : public:
129 :
130 : // Constructor.
131 0 : Sigma0AB2XX() {}
132 :
133 : // Evaluate sigma.
134 0 : virtual double sigmaHat() {return sigmaTotPtr->sigmaXX();}
135 :
136 : // Select flavour, colour and anticolour.
137 : virtual void setIdColAcol();
138 :
139 : // Info on the subprocess.
140 0 : virtual string name() const {return "A B -> X X double diffractive";}
141 0 : virtual int code() const {return 105;}
142 0 : virtual bool isResolved() const {return false;}
143 0 : virtual bool isDiffA() const {return true;};
144 0 : 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 0 : class Sigma0AB2AXB : public Sigma0Process {
155 :
156 : public:
157 :
158 : // Constructor.
159 0 : Sigma0AB2AXB() {}
160 :
161 : // Evaluate sigma.
162 0 : virtual double sigmaHat() {return sigmaTotPtr->sigmaAXB();}
163 :
164 : // Select flavour, colour and anticolour.
165 : virtual void setIdColAcol();
166 :
167 : // Info on the subprocess.
168 0 : virtual string name() const {return "A B -> A X B central diffractive";}
169 0 : virtual int code() const {return 106;}
170 0 : virtual int nFinal() const {return 3;}
171 0 : virtual bool isResolved() const {return false;}
172 0 : 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 0 : class Sigma2gg2gg : public Sigma2Process {
183 :
184 : public:
185 :
186 : // Constructor.
187 0 : Sigma2gg2gg() {}
188 :
189 : // Calculate flavour-independent parts of cross section.
190 : virtual void sigmaKin();
191 :
192 : // Evaluate d(sigmaHat)/d(tHat).
193 0 : virtual double sigmaHat() {return sigma;}
194 :
195 : // Select flavour, colour and anticolour.
196 : virtual void setIdColAcol();
197 :
198 : // Info on the subprocess.
199 0 : virtual string name() const {return "g g -> g g";}
200 0 : virtual int code() const {return 111;}
201 0 : 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 0 : class Sigma2gg2qqbar : public Sigma2Process {
215 :
216 : public:
217 :
218 : // Constructor.
219 0 : 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 0 : virtual double sigmaHat() {return sigma;}
229 :
230 : // Select flavour, colour and anticolour.
231 : virtual void setIdColAcol();
232 :
233 : // Info on the subprocess.
234 0 : virtual string name() const {return "g g -> q qbar (uds)";}
235 0 : virtual int code() const {return 112;}
236 0 : 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 0 : class Sigma2qg2qg : public Sigma2Process {
255 :
256 : public:
257 :
258 : // Constructor.
259 0 : Sigma2qg2qg() {}
260 :
261 : // Calculate flavour-independent parts of cross section.
262 : virtual void sigmaKin();
263 :
264 : // Evaluate d(sigmaHat)/d(tHat).
265 0 : virtual double sigmaHat() {return sigma;}
266 :
267 : // Select flavour, colour and anticolour.
268 : virtual void setIdColAcol();
269 :
270 : // Info on the subprocess.
271 0 : virtual string name() const {return "q g -> q g";}
272 0 : virtual int code() const {return 113;}
273 0 : 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 0 : class Sigma2qq2qq : public Sigma2Process {
288 :
289 : public:
290 :
291 : // Constructor.
292 0 : 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 0 : virtual string name() const {return "q q(bar)' -> q q(bar)'";}
305 0 : virtual int code() const {return 114;}
306 0 : 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 0 : class Sigma2qqbar2gg : public Sigma2Process {
320 :
321 : public:
322 :
323 : // Constructor.
324 0 : Sigma2qqbar2gg() {}
325 :
326 : // Calculate flavour-independent parts of cross section.
327 : virtual void sigmaKin();
328 :
329 : // Evaluate d(sigmaHat)/d(tHat).
330 0 : virtual double sigmaHat() {return sigma;}
331 :
332 : // Select flavour, colour and anticolour.
333 : virtual void setIdColAcol();
334 :
335 : // Info on the subprocess.
336 0 : virtual string name() const {return "q qbar -> g g";}
337 0 : virtual int code() const {return 115;}
338 0 : 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 0 : class Sigma2qqbar2qqbarNew : public Sigma2Process {
352 :
353 : public:
354 :
355 : // Constructor.
356 0 : 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 0 : virtual double sigmaHat() {return sigma;}
366 :
367 : // Select flavour, colour and anticolour.
368 : virtual void setIdColAcol();
369 :
370 : // Info on the subprocess.
371 0 : virtual string name() const {return "q qbar -> q' qbar' (uds)";}
372 0 : virtual int code() const {return 116;}
373 0 : 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 0 : class Sigma2gg2QQbar : public Sigma2Process {
391 :
392 : public:
393 :
394 : // Constructor.
395 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
414 0 : virtual int code() const {return codeSave;}
415 0 : virtual string inFlux() const {return "gg";}
416 0 : virtual int id3Mass() const {return idNew;}
417 0 : 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 0 : class Sigma2qqbar2QQbar : public Sigma2Process {
433 :
434 : public:
435 :
436 : // Constructor.
437 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
456 0 : virtual int code() const {return codeSave;}
457 0 : virtual string inFlux() const {return "qqbarSame";}
458 0 : virtual int id3Mass() const {return idNew;}
459 0 : 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 0 : class Sigma3gg2ggg : public Sigma3Process {
475 :
476 : public:
477 :
478 : // Constructor.
479 0 : Sigma3gg2ggg() {}
480 :
481 : // Calculate flavour-independent parts of cross section.
482 : virtual void sigmaKin();
483 :
484 : // Evaluate d(sigmaHat)/d(tHat).
485 0 : virtual double sigmaHat() {return sigma;}
486 :
487 : // Select flavour, colour and anticolour.
488 : virtual void setIdColAcol();
489 :
490 : // Info on the subprocess.
491 0 : virtual string name() const {return "g g -> g g g";}
492 0 : virtual int code() const {return 131;}
493 0 : virtual int nFinal() const {return 3;}
494 0 : virtual string inFlux() const {return "gg";}
495 0 : 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 0 : double cycle(int i1, int i2, int i3, int i4, int i5) {return
505 0 : 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 0 : class Sigma3qqbar2ggg : public Sigma3Process {
514 :
515 : public:
516 :
517 : // Constructor.
518 0 : Sigma3qqbar2ggg() {}
519 :
520 : // Calculate flavour-independent parts of cross section.
521 : virtual void sigmaKin();
522 :
523 : // Evaluate d(sigmaHat)/d(tHat).
524 0 : virtual double sigmaHat() {return sigma;}
525 :
526 : // Select flavour, colour and anticolour.
527 : virtual void setIdColAcol();
528 :
529 : // Info on the subprocess.
530 0 : virtual string name() const {return "q qbar -> g g g";}
531 0 : virtual int code() const {return 132;}
532 0 : virtual int nFinal() const {return 3;}
533 0 : virtual string inFlux() const {return "qqbarSame";}
534 0 : virtual bool isQCD3body() const {return true;}
535 :
536 : protected:
537 :
538 : // Pick/map a random final state configuration
539 : int config;
540 0 : 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 0 : class Sigma3qg2qgg : public Sigma3qqbar2ggg {
563 :
564 : public:
565 :
566 : // Constructor.
567 0 : 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 0 : virtual string name() const {return "q g -> q g g";}
580 0 : virtual int code() const {return 133;}
581 0 : virtual int nFinal() const {return 3;}
582 0 : virtual string inFlux() const {return "qg";}
583 0 : 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 0 : class Sigma3gg2qqbarg : public Sigma3qqbar2ggg {
598 :
599 : public:
600 :
601 : // Constructor.
602 0 : 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 0 : virtual string name() const {return "g g -> q qbar g";}
615 0 : virtual int code() const {return 138;}
616 0 : virtual int nFinal() const {return 3;}
617 0 : virtual string inFlux() const {return "gg";}
618 0 : 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 0 : class Sigma3qq2qqgDiff : public Sigma3Process {
632 :
633 : public:
634 :
635 : // Constructor.
636 0 : 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 0 : {return "q(bar) q(bar)' -> q(bar) q(bar)' g";}
650 0 : virtual int code() const {return 134;}
651 0 : virtual int nFinal() const {return 3;}
652 0 : virtual string inFlux() const {return "qq";}
653 0 : virtual bool isQCD3body() const {return true;}
654 :
655 : protected:
656 :
657 : // Pick/map a random final state configuration
658 : int config;
659 0 : 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 0 : class Sigma3qqbar2qqbargDiff : public Sigma3qq2qqgDiff {
682 :
683 : public:
684 :
685 : // Constructor.
686 0 : 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 0 : virtual double sigmaHat() {return sigma;}
696 :
697 : // Select flavour, colour and anticolour.
698 : virtual void setIdColAcol();
699 :
700 : // Info on the subprocess.
701 0 : virtual string name() const {return "q qbar -> q' qbar' g";}
702 0 : virtual int code() const {return 136;}
703 0 : virtual int nFinal() const {return 3;}
704 0 : virtual string inFlux() const {return "qqbarSame";}
705 0 : 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 0 : class Sigma3qg2qqqbarDiff : public Sigma3qq2qqgDiff {
720 :
721 : public:
722 :
723 : // Constructor.
724 0 : 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 0 : virtual string name() const {return "q g -> q q' qbar'";}
740 0 : virtual int code() const {return 139;}
741 0 : virtual int nFinal() const {return 3;}
742 0 : virtual string inFlux() const {return "qg";}
743 0 : 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 0 : class Sigma3qq2qqgSame : public Sigma3Process {
760 :
761 : public:
762 :
763 : // Constructor.
764 0 : 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 0 : {return "q(bar) q(bar) -> q(bar) q(bar) g";}
778 0 : virtual int code() const {return 135;}
779 0 : virtual int nFinal() const {return 3;}
780 0 : virtual string inFlux() const {return "qq";}
781 0 : virtual bool isQCD3body() const {return true;}
782 :
783 : protected:
784 :
785 : // Pick/map a random final state configuration
786 : int config;
787 0 : 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 0 : class Sigma3qqbar2qqbargSame : public Sigma3qq2qqgSame {
811 :
812 : public:
813 :
814 : // Constructor.
815 0 : Sigma3qqbar2qqbargSame() {}
816 :
817 : // Calculate flavour-independent parts of cross section.
818 : virtual void sigmaKin();
819 :
820 : // Evaluate d(sigmaHat)/d(tHat).
821 0 : virtual double sigmaHat() {return sigma;}
822 :
823 : // Select flavour, colour and anticolour.
824 : virtual void setIdColAcol();
825 :
826 : // Info on the subprocess.
827 0 : virtual string name() const {return "q qbar -> q qbar g";}
828 0 : virtual int code() const {return 137;}
829 0 : virtual int nFinal() const {return 3;}
830 0 : virtual string inFlux() const {return "qqbarSame";}
831 0 : 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 0 : class Sigma3qg2qqqbarSame : public Sigma3qq2qqgSame {
843 :
844 : public:
845 :
846 : // Constructor.
847 0 : 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 0 : virtual string name() const {return "q g -> q q qbar";}
860 0 : virtual int code() const {return 140;}
861 0 : virtual int nFinal() const {return 3;}
862 0 : virtual string inFlux() const {return "qg";}
863 0 : 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
|
