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