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