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