Line data Source code
1 : // SigmaSUSY.h is a part of the PYTHIA event generator.
2 : // Copyright (C) 2015 Torbjorn Sjostrand.
3 : // Main authors of this file: N. Desai, P. Skands
4 : // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
5 : // Please respect the MCnet Guidelines, see GUIDELINES for details.
6 :
7 : // Header file for Supersymmetric process differential cross sections.
8 : // Contains classes derived from SigmaProcess via Sigma2Process.
9 :
10 : #ifndef Pythia8_SigmaSUSY_H
11 : #define Pythia8_SigmaSUSY_H
12 :
13 : #include "Pythia8/PhaseSpace.h"
14 : #include "Pythia8/PythiaComplex.h"
15 : #include "Pythia8/SigmaProcess.h"
16 : #include "Pythia8/SusyCouplings.h"
17 :
18 : namespace Pythia8 {
19 :
20 : //==========================================================================
21 :
22 : // An intermediate class for SUSY 2 -> 2 with nontrivial decay angles.
23 :
24 0 : class Sigma2SUSY : public Sigma2Process {
25 :
26 : public:
27 :
28 : // Constructor.
29 0 : Sigma2SUSY() { };
30 :
31 : // Evaluate weight for decay angles.
32 : virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
33 :
34 : };
35 :
36 : //==========================================================================
37 :
38 : // A derived class for q qbar -> neutralino_i neutralino_j.
39 :
40 0 : class Sigma2qqbar2chi0chi0 : public Sigma2SUSY {
41 :
42 : public:
43 :
44 : // Constructor.
45 0 : Sigma2qqbar2chi0chi0() {};
46 :
47 : // Constructor.
48 0 : Sigma2qqbar2chi0chi0(int id3chiIn, int id4chiIn, int codeIn) {
49 :
50 : // Save ordering indices and process code
51 0 : id3chi = id3chiIn;
52 0 : id4chi = id4chiIn;
53 0 : codeSave = codeIn;
54 :
55 :
56 : // Construct id codes from ordering indices.
57 0 : id3 = 1000022;
58 0 : if (id3chi == 2) id3 = 1000023;
59 0 : if (id3chi == 3) id3 = 1000025;
60 0 : if (id3chi == 4) id3 = 1000035;
61 0 : if (id3chi == 5) id3 = 1000045;
62 0 : id4 = 1000022;
63 0 : if (id4chi == 2) id4 = 1000023;
64 0 : if (id4chi == 3) id4 = 1000025;
65 0 : if (id4chi == 4) id4 = 1000035;
66 0 : if (id4chi == 5) id4 = 1000045;
67 :
68 0 : }
69 :
70 : // Initialize process.
71 : virtual void initProc();
72 :
73 : // Calculate flavour-independent parts of cross section.
74 : virtual void sigmaKin();
75 :
76 : // Evaluate d(sigmaHat)/d(tHat).
77 : virtual double sigmaHat();
78 :
79 : // Select flavour, colour and anticolour.
80 : virtual void setIdColAcol();
81 :
82 : // Evaluate weight for decay angles.
83 : // virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
84 :
85 : // Info on the subprocess.
86 0 : virtual string name() const {return nameSave;}
87 0 : virtual int code() const {return codeSave;}
88 0 : virtual string inFlux() const {return "ff";}
89 0 : virtual int id3Mass() const {return abs(id3);}
90 0 : virtual int id4Mass() const {return abs(id4);}
91 0 : virtual int resonanceA() const {return 23;}
92 0 : virtual bool isSUSY() const {return true;}
93 0 : virtual double getSigma0() const {return sigma0;}
94 :
95 : protected:
96 :
97 : // Basic process information
98 : int id3chi, id4chi, codeSave;
99 : string nameSave;
100 :
101 : // Values stored for later use
102 : double sigma0, ui, uj, ti, tj, openFracPair;
103 : complex propZ;
104 :
105 : CoupSUSY* coupSUSYPtr;
106 :
107 : };
108 :
109 : //==========================================================================
110 :
111 : // A derived class for q qbar -> neutralino_i chargino_j.
112 :
113 0 : class Sigma2qqbar2charchi0 : public Sigma2qqbar2chi0chi0 {
114 :
115 : public:
116 :
117 : // Constructor.
118 0 : Sigma2qqbar2charchi0(int id3chiIn, int id4chiIn, int codeIn) {
119 :
120 : // Save ordering indices and process code
121 0 : id3chi = id3chiIn;
122 0 : id4chi = id4chiIn;
123 0 : codeSave = codeIn;
124 :
125 : // Construct id codes from ordering indices.
126 0 : id3 = (abs(id3chi) == 2) ? 1000037 : 1000024;
127 0 : if (id3chi < 0) id3 = -id3;
128 :
129 0 : id4 = 1000022;
130 0 : if (id4chi == 2) id4 = 1000023;
131 0 : if (id4chi == 3) id4 = 1000025;
132 0 : if (id4chi == 4) id4 = 1000035;
133 0 : if (id4chi == 5) id4 = 1000045;
134 :
135 0 : }
136 :
137 : // Calculate flavour-independent parts of cross section.
138 : virtual void sigmaKin();
139 :
140 : // Evaluate d(sigmaHat)/d(tHat).
141 : virtual double sigmaHat();
142 :
143 0 : virtual int resonanceA() const {return 24;}
144 :
145 : protected :
146 :
147 : complex propW;
148 :
149 : };
150 :
151 : //==========================================================================
152 :
153 : // A derived class for q qbar -> chargino+_i chargino-_j.
154 :
155 0 : class Sigma2qqbar2charchar : public Sigma2qqbar2chi0chi0 {
156 :
157 : public:
158 :
159 : // Constructor.
160 0 : Sigma2qqbar2charchar(int id3chiIn, int id4chiIn, int codeIn) {
161 :
162 : // Save ordering indices and process code
163 0 : id3chi = id3chiIn;
164 0 : id4chi = id4chiIn;
165 0 : codeSave = codeIn;
166 :
167 : // Construct id codes from ordering indices.
168 0 : id3 = (abs(id3chi) == 2) ? 1000037 : 1000024;
169 0 : id4 = (abs(id4chi) == 2) ? -1000037 : -1000024;
170 :
171 0 : }
172 :
173 : // Calculate flavour-independent parts of cross section.
174 : virtual void sigmaKin();
175 :
176 : // Evaluate d(sigmaHat)/d(tHat).
177 : virtual double sigmaHat();
178 :
179 : };
180 :
181 : //==========================================================================
182 :
183 : // A derived class for q g -> neutralino_i squark_j (and cc)
184 :
185 0 : class Sigma2qg2chi0squark : public Sigma2Process {
186 :
187 : public:
188 :
189 : // Constructor.
190 0 : Sigma2qg2chi0squark() { };
191 :
192 : // Constructor.
193 0 : Sigma2qg2chi0squark(int id3chiIn, int id4sqIn, bool isUp, int codeIn) {
194 :
195 : // Save ordering indices and process code
196 0 : id3chi = id3chiIn;
197 0 : id4sq = id4sqIn;
198 0 : codeSave = codeIn;
199 :
200 : // Construct id codes from ordering indices.
201 0 : id3 = 1000022;
202 0 : if (id3chi == 2) id3 = 1000023;
203 0 : if (id3chi == 3) id3 = 1000025;
204 0 : if (id3chi == 4) id3 = 1000035;
205 0 : if (id3chi == 5) id3 = 1000045;
206 0 : id4 = 1000001 + (isUp ? 1 : 0);
207 0 : if (id4sq == 2) id4 = 1000003 + (isUp ? 1 : 0);
208 0 : if (id4sq == 3) id4 = 1000005 + (isUp ? 1 : 0);
209 0 : if (id4sq == 4) id4 = 2000001 + (isUp ? 1 : 0);
210 0 : if (id4sq == 5) id4 = 2000003 + (isUp ? 1 : 0);
211 0 : if (id4sq == 6) id4 = 2000005 + (isUp ? 1 : 0);
212 :
213 0 : }
214 :
215 : // Initialize process.
216 : virtual void initProc();
217 :
218 : // Calculate flavour-independent parts of cross section.
219 : virtual void sigmaKin();
220 :
221 : // Evaluate d(sigmaHat)/d(tHat).
222 : virtual double sigmaHat();
223 :
224 : // Select flavour, colour and anticolour.
225 : virtual void setIdColAcol();
226 :
227 : // Info on the subprocess.
228 0 : virtual string name() const {return nameSave;}
229 0 : virtual int code() const {return codeSave;}
230 0 : virtual string inFlux() const {return "qg";}
231 0 : virtual int id3Mass() const {return abs(id3);}
232 0 : virtual int id4Mass() const {return abs(id4);}
233 0 : virtual bool isSUSY() const {return true;}
234 :
235 : protected:
236 :
237 : // Basic process information
238 : int id3chi, id4sq, codeSave;
239 : string nameSave;
240 :
241 : // Values stored for later use
242 : double sigma0, ui, uj, ti, tj, openFracPair;
243 :
244 : //SUSY couplings
245 : CoupSUSY* coupSUSYPtr;
246 :
247 : };
248 :
249 : //==========================================================================
250 :
251 : // A derived class for q g -> chargino_i squark_j (incl cc)
252 :
253 0 : class Sigma2qg2charsquark : public Sigma2qg2chi0squark {
254 :
255 : public:
256 :
257 : // Constructor.
258 0 : Sigma2qg2charsquark(int id3chiIn, int id4sqIn, bool isUp, int codeIn) {
259 :
260 : // Save ordering indices and process code
261 0 : id3chi = id3chiIn;
262 0 : id4sq = id4sqIn;
263 0 : codeSave = codeIn;
264 :
265 : // Construct id codes from ordering indices.
266 0 : id3Sav = 1000024;
267 0 : if (abs(id3chi) == 2) id3Sav = 1000037;
268 0 : if (isUp) id3Sav = -id3Sav;
269 0 : id4Sav = 1000001 + (isUp ? 1 : 0);
270 0 : if (id4sq == 2) id4Sav = 1000003 + (isUp ? 1 : 0);
271 0 : if (id4sq == 3) id4Sav = 1000005 + (isUp ? 1 : 0);
272 0 : if (id4sq == 4) id4Sav = 2000001 + (isUp ? 1 : 0);
273 0 : if (id4sq == 5) id4Sav = 2000003 + (isUp ? 1 : 0);
274 0 : if (id4sq == 6) id4Sav = 2000005 + (isUp ? 1 : 0);
275 :
276 : // Initial values, can be swapped to charge conjugates event by event.
277 0 : id3 = id3Sav;
278 0 : id4 = id4Sav;
279 :
280 0 : }
281 :
282 : // Initialize process.
283 : virtual void initProc();
284 :
285 : // Calculate flavour-independent parts of cross section.
286 : virtual void sigmaKin();
287 :
288 : // Evaluate d(sigmaHat)/d(tHat).
289 : virtual double sigmaHat();
290 :
291 : // Select flavour, colour and anticolour.
292 : virtual void setIdColAcol();
293 :
294 : private:
295 :
296 : // Basic process information
297 : int id3Sav, id4Sav;
298 :
299 : };
300 :
301 : //==========================================================================
302 :
303 : // A derived class for q q' -> ~q_i ~q_j
304 :
305 0 : class Sigma2qq2squarksquark : public Sigma2Process {
306 :
307 : public:
308 :
309 : // Constructor.
310 : Sigma2qq2squarksquark() {}
311 :
312 : // Constructor.
313 0 : Sigma2qq2squarksquark(int id3In, int id4In, int codeIn) {
314 :
315 : // Save ordering indices and process code
316 0 : id3Sav = id3In;
317 0 : id4Sav = id4In;
318 0 : codeSave = codeIn;
319 : // Initial values (flipped for c.c.)
320 0 : id3 = id3Sav;
321 0 : id4 = id4Sav;
322 :
323 0 : }
324 :
325 : // Initialize process.
326 : virtual void initProc();
327 :
328 : // Calculate flavour-independent parts of cross section.
329 : virtual void sigmaKin();
330 :
331 : // Evaluate d(sigmaHat)/d(tHat).
332 : virtual double sigmaHat();
333 :
334 : // Select flavour, colour and anticolour.
335 : virtual void setIdColAcol();
336 :
337 : // Info on the subprocess.
338 0 : virtual string name() const {return nameSave;}
339 0 : virtual int code() const {return codeSave;}
340 0 : virtual string inFlux() const {return "qq";}
341 0 : virtual int id3Mass() const {return abs(id3Sav);}
342 0 : virtual int id4Mass() const {return abs(id4Sav);}
343 0 : virtual bool isSUSY() const {return true;}
344 :
345 : private:
346 :
347 : // Basic process information
348 : int id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut;
349 : string nameSave;
350 : bool isUD, onlyQCD;
351 :
352 : // Storage of mass squares
353 : double m2Glu;
354 : vector<double> m2Neut, m2Char;
355 :
356 : // Flavor-independent prefactors.
357 : double sigmaChar, sigmaNeut, sigmaGlu;
358 : double sigmaCharNeut, sigmaCharGlu, sigmaNeutGlu;
359 : double openFracPair;
360 :
361 : // Point-by-point info
362 : double tGlu, uGlu;
363 : vector<double> tNeut, uNeut, tChar, uChar;
364 : double sumCt, sumCu, sumNt, sumNu, sumGt, sumGu, sumInterference;
365 :
366 : //SUSY couplings
367 : CoupSUSY* coupSUSYPtr;
368 : };
369 :
370 : //==========================================================================
371 :
372 : // A derived class for q qbar' -> ~q_i ~q*_j
373 :
374 0 : class Sigma2qqbar2squarkantisquark : public Sigma2Process {
375 :
376 : public:
377 :
378 : // Constructor.
379 0 : Sigma2qqbar2squarkantisquark() {}
380 :
381 : // Constructor.
382 0 : Sigma2qqbar2squarkantisquark(int id3In, int id4In, int codeIn) {
383 :
384 : // Save ordering indices and process code
385 : // (always store squark first, antisquark second)
386 0 : id3Sav = abs(id3In);
387 0 : id4Sav = -abs(id4In);
388 0 : codeSave = codeIn;
389 : // Initial values
390 0 : id3 = id3Sav;
391 0 : id4 = id4Sav;
392 :
393 0 : }
394 :
395 : // Initialize process.
396 : virtual void initProc();
397 :
398 : // Calculate flavour-independent parts of cross section.
399 : virtual void sigmaKin();
400 :
401 : // Evaluate d(sigmaHat)/d(tHat).
402 : virtual double sigmaHat();
403 :
404 : // Select flavour, colour and anticolour.
405 : virtual void setIdColAcol();
406 :
407 : // Info on the subprocess.
408 0 : virtual string name() const {return nameSave;}
409 0 : virtual int code() const {return codeSave;}
410 0 : virtual string inFlux() const {return "qq";}
411 0 : virtual int id3Mass() const {return abs(id3Sav);}
412 0 : virtual int id4Mass() const {return abs(id4Sav);}
413 0 : virtual bool isSUSY() const {return true;}
414 :
415 : private:
416 :
417 : // Basic process information
418 : int id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut;
419 : string nameSave;
420 : bool isUD, isCC, onlyQCD;
421 :
422 : // Storage of mass squares
423 : double m2Glu;
424 : vector<double> m2Neut;
425 :
426 : // Flavor-independent prefactors: EW, strong, and interference
427 : double xW;
428 : double openFracPair;
429 : double sigmaEW, sigmaGlu, sigmaEWG;
430 :
431 : // Point-by-point info
432 : double tGlu, uGlu;
433 : vector<double> tNeut, uNeut;
434 : complex propZW;
435 : double sumColS, sumColT, sumInterference;
436 :
437 : //SUSY couplings
438 : CoupSUSY* coupSUSYPtr;
439 :
440 : };
441 :
442 : //==========================================================================
443 :
444 : // A derived class for g g -> ~q ~q*
445 :
446 0 : class Sigma2gg2squarkantisquark : public Sigma2Process {
447 :
448 : public:
449 :
450 : // Constructor.
451 : Sigma2gg2squarkantisquark() {
452 : }
453 :
454 : // Constructor.
455 0 : Sigma2gg2squarkantisquark(int id34In, int codeIn) {
456 :
457 : // Save ordering indices and process code
458 : // (always store squark first, antisquark second)
459 0 : id3Sav = abs(id34In);
460 0 : id4Sav = -abs(id34In);
461 0 : codeSave = codeIn;
462 : // Initial values
463 0 : id3 = id3Sav;
464 0 : id4 = id4Sav;
465 :
466 0 : }
467 :
468 : // Initialize process.
469 : virtual void initProc();
470 :
471 : // Calculate flavour-independent parts of cross section.
472 : virtual void sigmaKin();
473 :
474 : // Evaluate d(sigmaHat)/d(tHat).
475 0 : virtual double sigmaHat() {return sigma;}
476 :
477 : // Select flavour, colour and anticolour.
478 : virtual void setIdColAcol();
479 :
480 : // Info on the subprocess.
481 0 : virtual string name() const {return nameSave;}
482 0 : virtual int code() const {return codeSave;}
483 0 : virtual string inFlux() const {return "gg";}
484 0 : virtual int id3Mass() const {return abs(id3Sav);}
485 0 : virtual int id4Mass() const {return abs(id4Sav);}
486 0 : virtual bool isSUSY() const {return true;}
487 :
488 : private:
489 :
490 : // Basic process information
491 : int id3Sav, id4Sav, codeSave;
492 : string nameSave;
493 : double sigma, m2Sq, openFracPair;
494 :
495 : //SUSY couplings
496 : CoupSUSY* coupSUSYPtr;
497 :
498 : };
499 :
500 : //==========================================================================
501 :
502 : // A derived class for q g -> ~q ~g
503 :
504 0 : class Sigma2qg2squarkgluino : public Sigma2Process {
505 :
506 : public:
507 :
508 : // Constructor.
509 : Sigma2qg2squarkgluino() {}
510 :
511 : // Constructor.
512 0 : Sigma2qg2squarkgluino(int id3In, int codeIn) {
513 :
514 : // Save ordering indices and process code
515 0 : id3Sav = abs(id3In);
516 0 : codeSave = codeIn;
517 : // Initial values
518 0 : id3 = id3Sav;
519 0 : id4 = 1000021;
520 :
521 0 : }
522 :
523 : // Initialize process.
524 : virtual void initProc();
525 :
526 : // Calculate flavour-independent parts of cross section.
527 : virtual void sigmaKin();
528 :
529 : // Evaluate d(sigmaHat)/d(tHat).
530 : virtual double sigmaHat();
531 :
532 : // Select flavour, colour and anticolour.
533 : virtual void setIdColAcol();
534 :
535 : // Info on the subprocess.
536 0 : virtual string name() const {return nameSave;}
537 0 : virtual int code() const {return codeSave;}
538 0 : virtual string inFlux() const {return "qg";}
539 0 : virtual int id3Mass() const {return abs(id3Sav);}
540 0 : virtual int id4Mass() const {return 1000021;}
541 0 : virtual bool isSUSY() const {return true;}
542 :
543 : private:
544 :
545 : // Basic process information
546 : int id3Sav, codeSave;
547 : string nameSave;
548 : double sigmaA, sigmaB, comFacHat, m2Glu, m2Sq, openFracPair;
549 :
550 : //SUSY couplings
551 : CoupSUSY* coupSUSYPtr;
552 :
553 : };
554 :
555 : //==========================================================================
556 :
557 : // A derived class for g g -> gluino gluino.
558 :
559 0 : class Sigma2gg2gluinogluino : public Sigma2Process {
560 :
561 : public:
562 :
563 : // Constructor.
564 0 : Sigma2gg2gluinogluino() {
565 0 : }
566 :
567 : // Initialize process.
568 : virtual void initProc();
569 :
570 : // Calculate flavour-independent parts of cross section.
571 : virtual void sigmaKin();
572 :
573 : // Evaluate d(sigmaHat)/d(tHat).
574 0 : virtual double sigmaHat() {return sigma;}
575 :
576 : // Select flavour, colour and anticolour.
577 : virtual void setIdColAcol();
578 :
579 : // Info on the subprocess.
580 0 : virtual string name() const {return "g g -> gluino gluino";}
581 0 : virtual int code() const {return 1201;}
582 0 : virtual string inFlux() const {return "gg";}
583 0 : virtual int id3Mass() const {return 1000021;}
584 0 : virtual int id4Mass() const {return 1000021;}
585 0 : virtual bool isSUSY() const {return true;}
586 :
587 : private:
588 :
589 : // Values stored for process type and colour flow selection.
590 : double sigTS, sigUS, sigTU, sigSum, sigma, openFracPair;
591 :
592 : //SUSY couplings
593 : CoupSUSY* coupSUSYPtr;
594 :
595 : };
596 :
597 : //==========================================================================
598 :
599 : // A derived class for q qbar -> gluino gluino.
600 :
601 0 : class Sigma2qqbar2gluinogluino : public Sigma2Process {
602 :
603 : public:
604 :
605 : // Constructor.
606 0 : Sigma2qqbar2gluinogluino() {
607 :
608 0 : }
609 :
610 : // Initialize process.
611 : virtual void initProc();
612 :
613 : // Calculate flavour-independent parts of cross section.
614 : virtual void sigmaKin();
615 :
616 : // Evaluate d(sigmaHat)/d(tHat).
617 : virtual double sigmaHat();
618 :
619 : // Select flavour, colour and anticolour.
620 : virtual void setIdColAcol();
621 :
622 : // Info on the subprocess.
623 0 : virtual string name() const {return "q qbar -> gluino gluino";}
624 0 : virtual int code() const {return 1202;}
625 0 : virtual string inFlux() const {return "qq";}
626 0 : virtual int id3Mass() const {return 1000021;}
627 0 : virtual int id4Mass() const {return 1000021;}
628 0 : virtual bool isSUSY() const {return true;}
629 :
630 : private:
631 :
632 : // Values stored for process type and colour flow selection.
633 : double openFracPair, s34Avg, sigS, tHG, uHG, tHG2, uHG2;
634 :
635 : //SUSY couplings
636 : CoupSUSY* coupSUSYPtr;
637 :
638 : };
639 :
640 : //==========================================================================
641 :
642 0 : class Sigma1qq2antisquark : public Sigma1Process {
643 : public:
644 :
645 : // Constructor.
646 : Sigma1qq2antisquark() {}
647 :
648 :
649 0 : Sigma1qq2antisquark(int id3In) {
650 :
651 0 : idRes = id3In;
652 :
653 0 : }
654 :
655 : // Initialize process.
656 : virtual void initProc();
657 :
658 : // Calculate flavour-independent parts of cross section.
659 : virtual void sigmaKin();
660 :
661 : // Evaluate d(sigmaHat)/d(tHat).
662 : virtual double sigmaHat();
663 :
664 : // Select flavour, colour and anticolour.
665 : virtual void setIdColAcol();
666 :
667 : // Info on the subprocess.
668 0 : virtual string name() const {return nameSave;}
669 0 : virtual int code() const {return codeSave;}
670 0 : virtual string inFlux() const {return "qq";}
671 0 : virtual bool isSUSY() const {return true;}
672 0 : virtual bool isRPV() const {return true;}
673 0 : virtual int resonanceA() const {return idRes;}
674 :
675 : private:
676 :
677 : // Values stored for process type and colour flow selection.
678 : double mRes, GammaRes, m2Res, sigBW, widthOut;
679 : int codeSave, idRes;
680 : string nameSave;
681 :
682 : //SUSY couplings
683 : CoupSUSY* coupSUSYPtr;
684 :
685 : };
686 :
687 :
688 : //==========================================================================
689 :
690 : // A derived class for q qbar -> neutralino_i gluino.
691 :
692 0 : class Sigma2qqbar2chi0gluino : public Sigma2SUSY {
693 :
694 : public:
695 :
696 : // Constructor.
697 0 : Sigma2qqbar2chi0gluino() {};
698 :
699 : // Constructor.
700 0 : Sigma2qqbar2chi0gluino(int id4chiIn, int codeIn) {
701 :
702 : // Save ordering indices and process code
703 0 : id3 = 1000021;
704 0 : id4chi = id4chiIn;
705 0 : codeSave = codeIn;
706 :
707 :
708 : // Construct id codes from ordering indices.
709 0 : id4 = 1000022;
710 0 : if (id4chi == 2) id4 = 1000023;
711 0 : if (id4chi == 3) id4 = 1000025;
712 0 : if (id4chi == 4) id4 = 1000035;
713 0 : if (id4chi == 5) id4 = 1000045;
714 :
715 0 : }
716 :
717 : // Initialize process.
718 : virtual void initProc();
719 :
720 : // Calculate flavour-independent parts of cross section.
721 : virtual void sigmaKin();
722 :
723 : // Evaluate d(sigmaHat)/d(tHat).
724 : virtual double sigmaHat();
725 :
726 : // Select flavour, colour and anticolour.
727 : virtual void setIdColAcol();
728 :
729 : // Evaluate weight for decay angles.
730 : // virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
731 :
732 : // Info on the subprocess.
733 0 : virtual string name() const {return nameSave;}
734 0 : virtual int code() const {return codeSave;}
735 0 : virtual string inFlux() const {return "ff";}
736 0 : virtual int id3Mass() const {return abs(id3);}
737 0 : virtual int id4Mass() const {return abs(id4);}
738 0 : virtual int resonanceA() const {return 23;}
739 0 : virtual bool isSUSY() const {return true;}
740 0 : virtual double getSigma0() const {return sigma0;}
741 :
742 : protected:
743 :
744 : // Basic process information
745 : int id3chi, id4chi, codeSave;
746 : string nameSave;
747 :
748 : // Values stored for later use
749 : double sigma0, ui, uj, ti, tj, openFracPair;
750 :
751 : CoupSUSY* coupSUSYPtr;
752 :
753 : };
754 :
755 : //==========================================================================
756 :
757 : // A derived class for q qbar -> neutralino_i chargino_j.
758 :
759 0 : class Sigma2qqbar2chargluino : public Sigma2qqbar2chi0gluino {
760 :
761 : public:
762 :
763 : // Constructor.
764 0 : Sigma2qqbar2chargluino(int id4chiIn, int codeIn) {
765 :
766 : // Save ordering indices and process code
767 0 : id3 = 1000021;
768 0 : id4chi = id4chiIn;
769 0 : codeSave = codeIn;
770 :
771 : // Construct id codes from ordering indices.
772 0 : id4 = (abs(id4chi) == 2) ? 1000037 : 1000024;
773 0 : if (id4chi < 0) id4 = -id4;
774 0 : }
775 :
776 : // Initialize process.
777 : virtual void initProc();
778 :
779 : // Calculate flavour-independent parts of cross section.
780 : virtual void sigmaKin();
781 :
782 : // Evaluate d(sigmaHat)/d(tHat).
783 : virtual double sigmaHat();
784 :
785 : // Select flavour, colour and anticolour.
786 : virtual void setIdColAcol();
787 :
788 0 : virtual int resonanceA() const {return 24;}
789 :
790 : protected :
791 :
792 : complex propW;
793 :
794 : };
795 :
796 : //==========================================================================
797 :
798 : // A derived class for q qbar' -> ~q_i ~q*_j
799 :
800 0 : class Sigma2qqbar2sleptonantislepton : public Sigma2qqbar2squarkantisquark {
801 :
802 : public:
803 :
804 : // Constructor.
805 : Sigma2qqbar2sleptonantislepton() {}
806 :
807 : // Constructor.
808 0 : Sigma2qqbar2sleptonantislepton(int id3In, int id4In, int codeIn) {
809 :
810 : // Save ordering indices and process code
811 : // (always store squark first, antisquark second)
812 0 : id3Sav = abs(id3In);
813 0 : id4Sav = -abs(id4In);
814 0 : codeSave = codeIn;
815 : // Initial values
816 0 : id3 = id3Sav;
817 0 : id4 = id4Sav;
818 0 : }
819 :
820 : // Initialize process.
821 : virtual void initProc();
822 :
823 : // Calculate flavour-independent parts of cross section.
824 : virtual void sigmaKin();
825 :
826 : // Evaluate d(sigmaHat)/d(tHat).
827 : virtual double sigmaHat();
828 :
829 : // Select flavour, colour and anticolour.
830 : virtual void setIdColAcol();
831 :
832 : // Info on the subprocess.
833 0 : virtual string name() const {return nameSave;}
834 0 : virtual int code() const {return codeSave;}
835 0 : virtual string inFlux() const {return "qq";}
836 0 : virtual int id3Mass() const {return abs(id3Sav);}
837 0 : virtual int id4Mass() const {return abs(id4Sav);}
838 0 : virtual bool isSUSY() const {return true;}
839 :
840 : private:
841 :
842 : // Basic process information
843 : int id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut;
844 : string nameSave;
845 : bool isUD;
846 :
847 : // Storage of mass squares
848 : vector<double> m2Neut;
849 :
850 : // Flavor-independent prefactors: EW, strong, and interference
851 : double xW;
852 : double openFracPair;
853 : double sigmaEW;
854 :
855 : // Point-by-point info
856 : vector<double> tNeut, uNeut;
857 : complex propZW;
858 : double sumColS, sumColT, sumInterference;
859 :
860 : //SUSY couplings
861 : CoupSUSY* coupSUSYPtr;
862 :
863 : };
864 :
865 : //==========================================================================
866 :
867 : } // end namespace Pythia8
868 :
869 : #endif // Pythia8_SigmaSUSY_H
|
