]>
Commit | Line | Data |
---|---|---|
9419eeef | 1 | // SigmaSUSY.h is a part of the PYTHIA event generator. |
2 | // Copyright (C) 2010 Peter Skands, 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 Supersymmetric process differential cross sections. | |
7 | // Contains classes derived from SigmaProcess via Sigma2Process. | |
8 | ||
9 | #ifndef Pythia8_SigmaSUSY_H | |
10 | #define Pythia8_SigmaSUSY_H | |
11 | ||
12 | #include "PhaseSpace.h" | |
13 | #include "PythiaComplex.h" | |
14 | #include "SigmaProcess.h" | |
15 | #include "SusyCouplings.h" | |
16 | #include "SusyLesHouches.h" | |
17 | ||
18 | namespace Pythia8 { | |
19 | ||
20 | //========================================================================== | |
21 | ||
22 | // A derived class for q qbar -> neutralino_i neutralino_j. | |
23 | ||
24 | class Sigma2qqbar2chi0chi0 : public Sigma2Process { | |
25 | ||
26 | public: | |
27 | ||
28 | // Constructor. | |
29 | Sigma2qqbar2chi0chi0() {}; | |
30 | ||
31 | // Constructor. | |
32 | Sigma2qqbar2chi0chi0(int id3chiIn, int id4chiIn, int codeIn) { | |
33 | ||
34 | // Save ordering indices and process code | |
35 | id3chi = id3chiIn; | |
36 | id4chi = id4chiIn; | |
37 | codeSave = codeIn; | |
38 | ||
39 | ||
40 | // Construct id codes from ordering indices. | |
41 | id3 = 1000022; | |
42 | if (id3chi == 2) id3 = 1000023; | |
43 | if (id3chi == 3) id3 = 1000025; | |
44 | if (id3chi == 4) id3 = 1000035; | |
45 | if (id3chi == 5) id3 = 1000045; | |
46 | id4 = 1000022; | |
47 | if (id4chi == 2) id4 = 1000023; | |
48 | if (id4chi == 3) id4 = 1000025; | |
49 | if (id4chi == 4) id4 = 1000035; | |
50 | if (id4chi == 5) id4 = 1000045; | |
51 | ||
52 | } | |
53 | ||
54 | // Initialize process. | |
55 | virtual void initProc(); | |
56 | ||
57 | // Calculate flavour-independent parts of cross section. | |
58 | virtual void sigmaKin(); | |
59 | ||
60 | // Evaluate d(sigmaHat)/d(tHat). | |
61 | virtual double sigmaHat(); | |
62 | ||
63 | // Select flavour, colour and anticolour. | |
64 | virtual void setIdColAcol(); | |
65 | ||
66 | // Info on the subprocess. | |
67 | virtual string name() const {return nameSave;} | |
68 | virtual int code() const {return codeSave;} | |
69 | virtual string inFlux() const {return "qq";} | |
70 | virtual int id3Mass() const {return abs(id3);} | |
71 | virtual int id4Mass() const {return abs(id4);} | |
72 | virtual int resonanceA() const {return 23;} | |
73 | virtual bool isSUSY() const {return true;} | |
74 | ||
75 | protected: | |
76 | ||
77 | // Basic process information | |
78 | int id3chi, id4chi, codeSave; | |
79 | string nameSave; | |
80 | ||
81 | // Values stored for later use | |
82 | double sigma0, ui, uj, ti, tj, openFracPair; | |
83 | complex propZ; | |
84 | ||
85 | CoupSUSY* coupSUSYPtr; | |
86 | ||
87 | }; | |
88 | ||
89 | //========================================================================== | |
90 | ||
91 | // A derived class for q qbar -> neutralino_i chargino_j. | |
92 | ||
93 | class Sigma2qqbar2charchi0 : public Sigma2qqbar2chi0chi0 { | |
94 | ||
95 | public: | |
96 | ||
97 | // Constructor. | |
98 | Sigma2qqbar2charchi0(int id3chiIn, int id4chiIn, int codeIn) { | |
99 | ||
100 | // Save ordering indices and process code | |
101 | id3chi = id3chiIn; | |
102 | id4chi = id4chiIn; | |
103 | codeSave = codeIn; | |
104 | ||
105 | // Construct id codes from ordering indices. | |
106 | id3 = (abs(id3chi) == 2) ? 1000037 : 1000024; | |
107 | if (id3chi < 0) id3 = -id3; | |
108 | ||
109 | id4 = 1000022; | |
110 | if (id4chi == 2) id4 = 1000023; | |
111 | if (id4chi == 3) id4 = 1000025; | |
112 | if (id4chi == 4) id4 = 1000035; | |
113 | if (id4chi == 5) id4 = 1000045; | |
114 | ||
115 | } | |
116 | ||
117 | // Calculate flavour-independent parts of cross section. | |
118 | virtual void sigmaKin(); | |
119 | ||
120 | // Evaluate d(sigmaHat)/d(tHat). | |
121 | virtual double sigmaHat(); | |
122 | ||
123 | virtual int resonanceA() const {return 24;} | |
124 | ||
125 | protected : | |
126 | ||
127 | complex propW; | |
128 | ||
129 | }; | |
130 | ||
131 | //========================================================================== | |
132 | ||
133 | // A derived class for q qbar -> chargino+_i chargino-_j. | |
134 | ||
135 | class Sigma2qqbar2charchar : public Sigma2qqbar2chi0chi0 { | |
136 | ||
137 | public: | |
138 | ||
139 | // Constructor. | |
140 | Sigma2qqbar2charchar(int id3chiIn, int id4chiIn, int codeIn) { | |
141 | ||
142 | // Save ordering indices and process code | |
143 | id3chi = id3chiIn; | |
144 | id4chi = id4chiIn; | |
145 | codeSave = codeIn; | |
146 | ||
147 | // Construct id codes from ordering indices. | |
148 | id3 = (abs(id3chi) == 2) ? 1000037 : 1000024; | |
149 | id4 = (abs(id4chi) == 2) ? -1000037 : -1000024; | |
150 | ||
151 | } | |
152 | ||
153 | // Calculate flavour-independent parts of cross section. | |
154 | virtual void sigmaKin(); | |
155 | ||
156 | // Evaluate d(sigmaHat)/d(tHat). | |
157 | virtual double sigmaHat(); | |
158 | ||
159 | }; | |
160 | ||
161 | //========================================================================== | |
162 | ||
163 | // A derived class for q g -> neutralino_i squark_j (and cc) | |
164 | ||
165 | class Sigma2qg2chi0squark : public Sigma2Process { | |
166 | ||
167 | public: | |
168 | ||
169 | // Constructor. | |
170 | Sigma2qg2chi0squark() { }; | |
171 | ||
172 | // Constructor. | |
173 | Sigma2qg2chi0squark(int id3chiIn, int id4sqIn, bool isUp, int codeIn) { | |
174 | ||
175 | // Save ordering indices and process code | |
176 | id3chi = id3chiIn; | |
177 | id4sq = id4sqIn; | |
178 | codeSave = codeIn; | |
179 | ||
180 | // Construct id codes from ordering indices. | |
181 | id3 = 1000022; | |
182 | if (id3chi == 2) id3 = 1000023; | |
183 | if (id3chi == 3) id3 = 1000025; | |
184 | if (id3chi == 4) id3 = 1000035; | |
185 | if (id3chi == 5) id3 = 1000045; | |
186 | id4 = 1000001 + (isUp ? 1 : 0); | |
187 | if (id4sq == 2) id4 = 1000003 + (isUp ? 1 : 0); | |
188 | if (id4sq == 3) id4 = 1000005 + (isUp ? 1 : 0); | |
189 | if (id4sq == 4) id4 = 2000001 + (isUp ? 1 : 0); | |
190 | if (id4sq == 5) id4 = 2000003 + (isUp ? 1 : 0); | |
191 | if (id4sq == 6) id4 = 2000005 + (isUp ? 1 : 0); | |
192 | ||
193 | } | |
194 | ||
195 | // Initialize process. | |
196 | virtual void initProc(); | |
197 | ||
198 | // Calculate flavour-independent parts of cross section. | |
199 | virtual void sigmaKin(); | |
200 | ||
201 | // Evaluate d(sigmaHat)/d(tHat). | |
202 | virtual double sigmaHat(); | |
203 | ||
204 | // Select flavour, colour and anticolour. | |
205 | virtual void setIdColAcol(); | |
206 | ||
207 | // Info on the subprocess. | |
208 | virtual string name() const {return nameSave;} | |
209 | virtual int code() const {return codeSave;} | |
210 | virtual string inFlux() const {return "qg";} | |
211 | virtual int id3Mass() const {return abs(id3);} | |
212 | virtual int id4Mass() const {return abs(id4);} | |
213 | virtual bool isSUSY() const {return true;} | |
214 | ||
215 | protected: | |
216 | ||
217 | // Basic process information | |
218 | int id3chi, id4sq, codeSave; | |
219 | string nameSave; | |
220 | ||
221 | // Values stored for later use | |
222 | double sigma0, ui, uj, ti, tj, openFracPair; | |
223 | ||
224 | //SUSY couplings | |
225 | CoupSUSY* coupSUSYPtr; | |
226 | ||
227 | }; | |
228 | ||
229 | //========================================================================== | |
230 | ||
231 | // A derived class for q g -> chargino_i squark_j (incl cc) | |
232 | ||
233 | class Sigma2qg2charsquark : public Sigma2qg2chi0squark { | |
234 | ||
235 | public: | |
236 | ||
237 | // Constructor. | |
238 | Sigma2qg2charsquark(int id3chiIn, int id4sqIn, bool isUp, int codeIn) { | |
239 | ||
240 | // Save ordering indices and process code | |
241 | id3chi = id3chiIn; | |
242 | id4sq = id4sqIn; | |
243 | codeSave = codeIn; | |
244 | ||
245 | // Construct id codes from ordering indices. | |
246 | id3Sav = 1000024; | |
247 | if (abs(id3chi) == 2) id3Sav = 1000037; | |
248 | if (isUp) id3Sav = -id3Sav; | |
249 | id4Sav = 1000001 + (isUp ? 1 : 0); | |
250 | if (id4sq == 2) id4Sav = 1000003 + (isUp ? 1 : 0); | |
251 | if (id4sq == 3) id4Sav = 1000005 + (isUp ? 1 : 0); | |
252 | if (id4sq == 4) id4Sav = 2000001 + (isUp ? 1 : 0); | |
253 | if (id4sq == 5) id4Sav = 2000003 + (isUp ? 1 : 0); | |
254 | if (id4sq == 6) id4Sav = 2000005 + (isUp ? 1 : 0); | |
255 | ||
256 | // Initial values, can be swapped to charge conjugates event by event. | |
257 | id3 = id3Sav; | |
258 | id4 = id4Sav; | |
259 | ||
260 | } | |
261 | ||
262 | // Initialize process. | |
263 | virtual void initProc(); | |
264 | ||
265 | // Evaluate d(sigmaHat)/d(tHat). | |
266 | virtual double sigmaHat(); | |
267 | ||
268 | // Select flavour, colour and anticolour. | |
269 | virtual void setIdColAcol(); | |
270 | ||
271 | private: | |
272 | ||
273 | // Basic process information | |
274 | int id3Sav, id4Sav; | |
275 | ||
276 | }; | |
277 | ||
278 | //========================================================================== | |
279 | ||
280 | // A derived class for q q' -> ~q_i ~q_j | |
281 | ||
282 | class Sigma2qq2squarksquark : public Sigma2Process { | |
283 | ||
284 | public: | |
285 | ||
286 | // Constructor. | |
287 | Sigma2qq2squarksquark() {} | |
288 | ||
289 | // Constructor. | |
290 | Sigma2qq2squarksquark(int id3In, int id4In, int codeIn) { | |
291 | ||
292 | // Save ordering indices and process code | |
293 | id3Sav = id3In; | |
294 | id4Sav = id4In; | |
295 | codeSave = codeIn; | |
296 | // Initial values (flipped for c.c.) | |
297 | id3 = id3Sav; | |
298 | id4 = id4Sav; | |
299 | ||
300 | } | |
301 | ||
302 | // Initialize process. | |
303 | virtual void initProc(); | |
304 | ||
305 | // Calculate flavour-independent parts of cross section. | |
306 | virtual void sigmaKin(); | |
307 | ||
308 | // Evaluate d(sigmaHat)/d(tHat). | |
309 | virtual double sigmaHat(); | |
310 | ||
311 | // Select flavour, colour and anticolour. | |
312 | virtual void setIdColAcol(); | |
313 | ||
314 | // Info on the subprocess. | |
315 | virtual string name() const {return nameSave;} | |
316 | virtual int code() const {return codeSave;} | |
317 | virtual string inFlux() const {return "qq";} | |
318 | virtual int id3Mass() const {return abs(id3Sav);} | |
319 | virtual int id4Mass() const {return abs(id4Sav);} | |
320 | virtual bool isSUSY() const {return true;} | |
321 | ||
322 | private: | |
323 | ||
324 | // Basic process information | |
325 | int id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut; | |
326 | string nameSave; | |
327 | bool isUD; | |
328 | ||
329 | // Storage of mass squares | |
330 | double m2Glu; | |
331 | vector<double> m2Neut, m2Char; | |
332 | ||
333 | // Flavor-independent prefactors. | |
334 | double sigmaChar, sigmaNeut, sigmaGlu; | |
335 | double sigmaCharNeut, sigmaCharGlu, sigmaNeutGlu; | |
336 | double openFracPair; | |
337 | ||
338 | // Point-by-point info | |
339 | double tGlu, uGlu; | |
340 | vector<double> tNeut, uNeut, tChar, uChar; | |
341 | double sumCt, sumCu, sumNt, sumNu, sumGt, sumGu, sumInterference; | |
342 | ||
343 | //SUSY couplings | |
344 | CoupSUSY* coupSUSYPtr; | |
345 | }; | |
346 | ||
347 | //========================================================================== | |
348 | ||
349 | // A derived class for q qbar' -> ~q_i ~q*_j | |
350 | ||
351 | class Sigma2qqbar2squarkantisquark : public Sigma2Process { | |
352 | ||
353 | public: | |
354 | ||
355 | // Constructor. | |
356 | Sigma2qqbar2squarkantisquark() {} | |
357 | ||
358 | // Constructor. | |
359 | Sigma2qqbar2squarkantisquark(int id3In, int id4In, int codeIn) { | |
360 | ||
361 | // Save ordering indices and process code | |
362 | // (always store squark first, antisquark second) | |
363 | id3Sav = abs(id3In); | |
364 | id4Sav = -abs(id4In); | |
365 | codeSave = codeIn; | |
366 | // Initial values | |
367 | id3 = id3Sav; | |
368 | id4 = id4Sav; | |
369 | ||
370 | } | |
371 | ||
372 | // Initialize process. | |
373 | virtual void initProc(); | |
374 | ||
375 | // Calculate flavour-independent parts of cross section. | |
376 | virtual void sigmaKin(); | |
377 | ||
378 | // Evaluate d(sigmaHat)/d(tHat). | |
379 | virtual double sigmaHat(); | |
380 | ||
381 | // Select flavour, colour and anticolour. | |
382 | virtual void setIdColAcol(); | |
383 | ||
384 | // Info on the subprocess. | |
385 | virtual string name() const {return nameSave;} | |
386 | virtual int code() const {return codeSave;} | |
387 | virtual string inFlux() const {return "qq";} | |
388 | virtual int id3Mass() const {return abs(id3Sav);} | |
389 | virtual int id4Mass() const {return abs(id4Sav);} | |
390 | virtual bool isSUSY() const {return true;} | |
391 | ||
392 | private: | |
393 | ||
394 | // Basic process information | |
395 | int id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut; | |
396 | string nameSave; | |
397 | bool isUD, isCC; | |
398 | ||
399 | // Storage of mass squares | |
400 | double m2Glu; | |
401 | vector<double> m2Neut; | |
402 | ||
403 | // Flavor-independent prefactors: EW, strong, and interference | |
404 | double xW; | |
405 | double openFracPair; | |
406 | double sigmaEW, sigmaGlu, sigmaEWG; | |
407 | ||
408 | // Point-by-point info | |
409 | double tGlu, uGlu; | |
410 | vector<double> tNeut, uNeut; | |
411 | complex propZW; | |
412 | double sumColS, sumColT, sumColSCC, sumColTCC, sumInterference; | |
413 | ||
414 | //SUSY couplings | |
415 | CoupSUSY* coupSUSYPtr; | |
416 | ||
417 | }; | |
418 | ||
419 | //========================================================================== | |
420 | ||
421 | // A derived class for g g -> ~q ~q* | |
422 | ||
423 | class Sigma2gg2squarkantisquark : public Sigma2Process { | |
424 | ||
425 | public: | |
426 | ||
427 | // Constructor. | |
428 | Sigma2gg2squarkantisquark() { | |
429 | } | |
430 | ||
431 | // Constructor. | |
432 | Sigma2gg2squarkantisquark(int id34In, int codeIn) { | |
433 | ||
434 | // Save ordering indices and process code | |
435 | // (always store squark first, antisquark second) | |
436 | id3Sav = abs(id34In); | |
437 | id4Sav = -abs(id34In); | |
438 | codeSave = codeIn; | |
439 | // Initial values | |
440 | id3 = id3Sav; | |
441 | id4 = id4Sav; | |
442 | ||
443 | } | |
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 | // Info on the subprocess. | |
458 | virtual string name() const {return nameSave;} | |
459 | virtual int code() const {return codeSave;} | |
460 | virtual string inFlux() const {return "gg";} | |
461 | virtual int id3Mass() const {return abs(id3Sav);} | |
462 | virtual int id4Mass() const {return abs(id4Sav);} | |
463 | virtual bool isSUSY() const {return true;} | |
464 | ||
465 | private: | |
466 | ||
467 | // Basic process information | |
468 | int id3Sav, id4Sav, codeSave; | |
469 | string nameSave; | |
470 | double sigma, m2Sq, openFracPair; | |
471 | ||
472 | // Color flow info | |
473 | double sumColT, sumColU, sumInterference; | |
474 | ||
475 | //SUSY couplings | |
476 | CoupSUSY* coupSUSYPtr; | |
477 | ||
478 | }; | |
479 | ||
480 | //========================================================================== | |
481 | ||
482 | // A derived class for q g -> ~q ~g | |
483 | ||
484 | class Sigma2qg2squarkgluino : public Sigma2Process { | |
485 | ||
486 | public: | |
487 | ||
488 | // Constructor. | |
489 | Sigma2qg2squarkgluino() {} | |
490 | ||
491 | // Constructor. | |
492 | Sigma2qg2squarkgluino(int id3In, int codeIn) { | |
493 | ||
494 | // Save ordering indices and process code | |
495 | id3Sav = abs(id3In); | |
496 | codeSave = codeIn; | |
497 | // Initial values | |
498 | id3 = id3Sav; | |
499 | id4 = 1000021; | |
500 | ||
501 | } | |
502 | ||
503 | // Initialize process. | |
504 | virtual void initProc(); | |
505 | ||
506 | // Calculate flavour-independent parts of cross section. | |
507 | virtual void sigmaKin(); | |
508 | ||
509 | // Evaluate d(sigmaHat)/d(tHat). | |
510 | virtual double sigmaHat(); | |
511 | ||
512 | // Select flavour, colour and anticolour. | |
513 | virtual void setIdColAcol(); | |
514 | ||
515 | // Info on the subprocess. | |
516 | virtual string name() const {return nameSave;} | |
517 | virtual int code() const {return codeSave;} | |
518 | virtual string inFlux() const {return "qg";} | |
519 | virtual int id3Mass() const {return abs(id3Sav);} | |
520 | virtual int id4Mass() const {return 1000021;} | |
521 | virtual bool isSUSY() const {return true;} | |
522 | ||
523 | private: | |
524 | ||
525 | // Basic process information | |
526 | int id3Sav, codeSave; | |
527 | string nameSave; | |
528 | double sigmaA, sigmaB, comFacHat, m2Glu, m2Sq, openFracPair; | |
529 | ||
530 | //SUSY couplings | |
531 | CoupSUSY* coupSUSYPtr; | |
532 | ||
533 | }; | |
534 | ||
535 | //========================================================================== | |
536 | ||
537 | // A derived class for g g -> gluino gluino. | |
538 | ||
539 | class Sigma2gg2gluinogluino : public Sigma2Process { | |
540 | ||
541 | public: | |
542 | ||
543 | // Constructor. | |
544 | Sigma2gg2gluinogluino() { | |
545 | } | |
546 | ||
547 | // Initialize process. | |
548 | virtual void initProc(); | |
549 | ||
550 | // Calculate flavour-independent parts of cross section. | |
551 | virtual void sigmaKin(); | |
552 | ||
553 | // Evaluate d(sigmaHat)/d(tHat). | |
554 | virtual double sigmaHat() {return sigma;} | |
555 | ||
556 | // Select flavour, colour and anticolour. | |
557 | virtual void setIdColAcol(); | |
558 | ||
559 | // Info on the subprocess. | |
560 | virtual string name() const {return "g g -> gluino gluino";} | |
561 | virtual int code() const {return 1201;} | |
562 | virtual string inFlux() const {return "gg";} | |
563 | virtual int id3Mass() const {return 1000021;} | |
564 | virtual int id4Mass() const {return 1000021;} | |
565 | virtual bool isSUSY() const {return true;} | |
566 | ||
567 | private: | |
568 | ||
569 | // Values stored for process type and colour flow selection. | |
570 | double sigTS, sigUS, sigTU, sigSum, sigma, openFracPair; | |
571 | ||
572 | //SUSY couplings | |
573 | CoupSUSY* coupSUSYPtr; | |
574 | ||
575 | }; | |
576 | ||
577 | //========================================================================== | |
578 | ||
579 | // A derived class for q qbar -> gluino gluino. | |
580 | ||
581 | class Sigma2qqbar2gluinogluino : public Sigma2Process { | |
582 | ||
583 | public: | |
584 | ||
585 | // Constructor. | |
586 | Sigma2qqbar2gluinogluino() { | |
587 | ||
588 | } | |
589 | ||
590 | // Initialize process. | |
591 | virtual void initProc(); | |
592 | ||
593 | // Calculate flavour-independent parts of cross section. | |
594 | virtual void sigmaKin(); | |
595 | ||
596 | // Evaluate d(sigmaHat)/d(tHat). | |
597 | virtual double sigmaHat(); | |
598 | ||
599 | // Select flavour, colour and anticolour. | |
600 | virtual void setIdColAcol(); | |
601 | ||
602 | // Info on the subprocess. | |
603 | virtual string name() const {return "q qbar -> gluino gluino";} | |
604 | virtual int code() const {return 1202;} | |
605 | virtual string inFlux() const {return "qqbarSame";} | |
606 | virtual int id3Mass() const {return 1000021;} | |
607 | virtual int id4Mass() const {return 1000021;} | |
608 | virtual bool isSUSY() const {return true;} | |
609 | ||
610 | private: | |
611 | ||
612 | // Values stored for process type and colour flow selection. | |
613 | double openFracPair, s34Avg, sigS, tHG, uHG, tHG2, uHG2; | |
614 | ||
615 | //SUSY couplings | |
616 | CoupSUSY* coupSUSYPtr; | |
617 | ||
618 | }; | |
619 | ||
620 | //========================================================================== | |
621 | ||
622 | class Sigma1qq2antisquark : public Sigma1Process { | |
623 | public: | |
624 | ||
625 | // Constructor. | |
626 | Sigma1qq2antisquark() {} | |
627 | ||
628 | ||
629 | Sigma1qq2antisquark(int id3In) { | |
630 | ||
631 | idRes = id3In; | |
632 | ||
633 | } | |
634 | ||
635 | // Initialize process. | |
636 | virtual void initProc(); | |
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 {return nameSave;} | |
649 | virtual int code() const {return codeSave;} | |
650 | virtual string inFlux() const {return "qq";} | |
651 | virtual bool isSUSY() const {return true;} | |
652 | virtual bool isRPV() const {return true;} | |
653 | virtual int resonanceA() const {return idRes;} | |
654 | ||
655 | private: | |
656 | ||
657 | // Values stored for process type and colour flow selection. | |
658 | double mRes, GammaRes, m2Res, GamMRat, sigBW, widthOut; | |
659 | int squarkType, codeSave, idRes; | |
660 | string nameSave; | |
661 | ||
662 | //SUSY couplings | |
663 | CoupSUSY* coupSUSYPtr; | |
664 | ||
665 | }; | |
666 | ||
667 | ||
668 | //========================================================================== | |
669 | } // end namespace Pythia8 | |
670 | ||
671 | ||
672 | ||
673 | ||
674 | ||
675 | ||
676 | ||
677 | #endif // Pythia8_SigmaSUSY_H | |
678 |