StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
SigmaExtraDim.h
1 // SigmaExtraDim.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2014 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 // Author: Stefan Ask for the *LED* routines.
7 // Header file for extra-dimensional-process differential cross sections.
8 // Contains classes derived from SigmaProcess via Sigma(1/2)Process.
9 
10 #ifndef Pythia8_SigmaExtraDim_H
11 #define Pythia8_SigmaExtraDim_H
12 
13 #include "Pythia8/SigmaProcess.h"
14 
15 namespace Pythia8 {
16 
17 //==========================================================================
18 
19 // A derived class for g g -> G^* (excited graviton state).
20 
21 class Sigma1gg2GravitonStar : public Sigma1Process {
22 
23 public:
24 
25  // Constructor.
26  Sigma1gg2GravitonStar() {}
27 
28  // Initialize process.
29  virtual void initProc();
30 
31  // Calculate flavour-independent parts of cross section.
32  virtual void sigmaKin();
33 
34  // Evaluate sigmaHat(sHat).
35  virtual double sigmaHat() {return sigma;}
36 
37  // Select flavour, colour and anticolour.
38  virtual void setIdColAcol();
39 
40  // Evaluate weight for G* decay angle.
41  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
42 
43  // Info on the subprocess.
44  virtual string name() const {return "g g -> G*";}
45  virtual int code() const {return 5001;}
46  virtual string inFlux() const {return "gg";}
47  virtual int resonanceA() const {return idGstar;}
48 
49 private:
50 
51  // Parameters set at initialization or for current kinematics.
52  bool eDsmbulk, eDvlvl;
53  int idGstar;
54  double mRes, GammaRes, m2Res, GamMRat, kappaMG, sigma;
55 
56  // Couplings between graviton and SM (indexed by particle id).
57  double eDcoupling[27];
58 
59  // Pointer to properties of the particle species, to access decay channels.
60  ParticleDataEntry* gStarPtr;
61 
62 };
63 
64 //==========================================================================
65 
66 // A derived class for f fbar -> G^* (excited graviton state).
67 
68 class Sigma1ffbar2GravitonStar : public Sigma1Process {
69 
70 public:
71 
72  // Constructor.
73  Sigma1ffbar2GravitonStar() {}
74 
75  // Initialize process.
76  virtual void initProc();
77 
78  // Calculate flavour-independent parts of cross section.
79  virtual void sigmaKin();
80 
81  // Evaluate sigmaHat(sHat).
82  virtual double sigmaHat();
83 
84  // Select flavour, colour and anticolour.
85  virtual void setIdColAcol();
86 
87  // Evaluate weight for G* decay angle.
88  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
89 
90  // Info on the subprocess.
91  virtual string name() const {return "f fbar -> G*";}
92  virtual int code() const {return 5002;}
93  virtual string inFlux() const {return "ffbarSame";}
94  virtual int resonanceA() const {return idGstar;}
95 
96 private:
97 
98  // Parameters set at initialization or for current kinematics.
99  bool eDsmbulk, eDvlvl;
100  int idGstar;
101  double mRes, GammaRes, m2Res, GamMRat, kappaMG, sigma0;
102 
103  // Couplings between graviton and SM (indexed by particle id).
104  double eDcoupling[27];
105 
106  // Pointer to properties of the particle species, to access decay channels.
107  ParticleDataEntry* gStarPtr;
108 
109 };
110 
111 //==========================================================================
112 
113 // A derived class for q qbar -> g^*/KK-gluon^* (excited kk-gluon state).
114 
115 class Sigma1qqbar2KKgluonStar : public Sigma1Process {
116 
117 public:
118 
119  // Constructor.
120  Sigma1qqbar2KKgluonStar() {}
121 
122  // Initialize process.
123  virtual void initProc();
124 
125  // Calculate flavour-independent parts of cross section.
126  virtual void sigmaKin();
127 
128  // Evaluate sigmaHat(sHat).
129  virtual double sigmaHat();
130 
131  // Select flavour, colour and anticolour.
132  virtual void setIdColAcol();
133 
134  // Evaluate weight for g* decay angle.
135  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
136 
137  // Info on the subprocess.
138  virtual string name() const {return "q qbar -> g*/KK-gluon*";}
139  virtual int code() const {return 5006;}
140  virtual string inFlux() const {return "qqbarSame";}
141  virtual int resonanceA() const {return idKKgluon;}
142 
143 private:
144 
145  // Parameters set at initialization or for current kinematics.
146  int idKKgluon;
147  double mRes, GammaRes, m2Res, GamMRat;
148  double sumSM, sumInt, sumKK, sigSM, sigInt, sigKK;
149 
150  // Couplings between kk gluon and SM (indexed by particle id).
151  // Helicity dependent couplings. Use vector/axial-vector
152  // couplings internally, gv/ga = 0.5 * (gL +/- gR).
153  double eDgv[10], eDga[10];
154 
155  // Interference parameter.
156  int interfMode;
157 
158  // Pointer to properties of the particle species, to access decay
159  // channels.
160  ParticleDataEntry* gStarPtr;
161 
162 };
163 
164 //==========================================================================
165 
166 // A derived class for g g -> G^* g (excited graviton state).
167 
168 class Sigma2gg2GravitonStarg : public Sigma2Process {
169 
170 public:
171 
172  // Constructor.
173  Sigma2gg2GravitonStarg() {}
174 
175  // Initialize process.
176  virtual void initProc();
177 
178  // Calculate flavour-independent parts of cross section.
179  virtual void sigmaKin();
180 
181  // Evaluate sigmaHat(sHat).
182  virtual double sigmaHat() {return sigma;}
183 
184  // Select flavour, colour and anticolour.
185  virtual void setIdColAcol();
186 
187  // Evaluate weight: currently isotropic (except secondary top decay)..
188  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
189 
190  // Info on the subprocess.
191  virtual string name() const {return "g g -> G* g";}
192  virtual int code() const {return 5003;}
193  virtual string inFlux() const {return "gg";}
194  virtual int id3Mass() const {return idGstar;}
195 
196 private:
197 
198  // Parameters set at initialization or for current kinematics.
199  int idGstar;
200  double mRes, GammaRes, m2Res, GamMRat, kappaMG, openFrac, sigma;
201 
202 };
203 
204 //==========================================================================
205 
206 // A derived class for q g -> G^* q (excited graviton state).
207 
208 class Sigma2qg2GravitonStarq : public Sigma2Process {
209 
210 public:
211 
212  // Constructor.
213  Sigma2qg2GravitonStarq() {}
214 
215  // Initialize process.
216  virtual void initProc();
217 
218  // Calculate flavour-independent parts of cross section.
219  virtual void sigmaKin();
220 
221  // Evaluate sigmaHat(sHat).
222  virtual double sigmaHat() {return sigma;}
223 
224  // Select flavour, colour and anticolour.
225  virtual void setIdColAcol();
226 
227  // Evaluate weight: currently isotropic (except secondary top decay).
228  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
229 
230  // Info on the subprocess.
231  virtual string name() const {return "q g -> G* q";}
232  virtual int code() const {return 5004;}
233  virtual string inFlux() const {return "qg";}
234  virtual int id3Mass() const {return idGstar;}
235 
236 private:
237 
238  // Parameters set at initialization or for current kinematics.
239  int idGstar;
240  double mRes, GammaRes, m2Res, GamMRat, kappaMG, openFrac, sigma;
241 
242 };
243 
244 //==========================================================================
245 
246 // A derived class for q qbar -> G^* g (excited graviton state).
247 
248 class Sigma2qqbar2GravitonStarg : public Sigma2Process {
249 
250 public:
251 
252  // Constructor.
253  Sigma2qqbar2GravitonStarg() {}
254 
255  // Initialize process.
256  virtual void initProc();
257 
258  // Calculate flavour-independent parts of cross section.
259  virtual void sigmaKin();
260 
261  // Evaluate sigmaHat(sHat).
262  virtual double sigmaHat() {return sigma;}
263 
264  // Select flavour, colour and anticolour.
265  virtual void setIdColAcol();
266 
267  // Evaluate weight: currently isotropic (except secondary top decay).
268  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
269 
270  // Info on the subprocess.
271  virtual string name() const {return "q qbar -> G* g";}
272  virtual int code() const {return 5005;}
273  virtual string inFlux() const {return "qqbarSame";}
274  virtual int id3Mass() const {return idGstar;}
275 
276 private:
277 
278  // Parameters set at initialization or for current kinematics.
279  int idGstar;
280  double mRes, GammaRes, m2Res, GamMRat, kappaMG, openFrac, sigma;
281 
282 };
283 
284 //==========================================================================
285 
286 // NOAM: A derived class for, f fbar -> (gamma/Z)_KKTower -> F Fbar,
287 // for one heavy F.
288 // Process provided by N. Hod et al. and is described in arXiv:XXXX.YYYY
289 
290 class Sigma2ffbar2TEVffbar : public Sigma2Process {
291 
292 public:
293 
294  // Constructor.
295  Sigma2ffbar2TEVffbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
296 
297  // Initialize process.
298  virtual void initProc();
299 
300  // Calculate flavour-independent parts of cross section.
301  virtual void sigmaKin();
302 
303  // Evaluate sigmaHat(sHat).
304  virtual double sigmaHat();
305 
306  // Select flavour, colour and anticolour.
307  virtual void setIdColAcol();
308 
309  // Evaluate weight for W decay angles in top decay (else inactive).
310  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
311 
312  // Info on the subprocess.
313  virtual string name() const {return nameSave;}
314  virtual int code() const {return codeSave;}
315  virtual string inFlux() const {return "ffbarSame";}
316  virtual bool isSChannel() const {return true;}
317  virtual int idSChannel() const {return 5000023;}
318  virtual int resonanceA() const {return 23;}
319  virtual int resonanceB() const {return 5000023;}
320  virtual int id3Mass() const {return idNew;}
321  virtual int id4Mass() const {return idNew;}
322  // Add phase-space sampling also around the Z_KK resonance.
323  virtual int resonanceA();
324  virtual int resonanceB();
325 
326 private:
327 
328  // Values stored for process type.
329  string nameSave;
330  int idNew, gmZmode, codeSave, nexcitationmax;
331  bool isPhysical;
332  double gPlusf, gMinusf, gPlusF, gMinusF, gPlusTop, gMinusTop, gf, gF;
333  double mRes, m2Res, mStar, mTop, m2Top, mZKKn, m2ZKKn, m2gmKKn, mgmKKn,
334  alphaemfixed;
335  double helicityME2, coefTot, coefAngular;
336  double mr, betaf, cosThe, openFracPair;
337  double wgmKKFactor, wgmKKn, wZKKn,
338  wZ0, ttbarwZKKn, ttbarwgmKKn,
339  ttbarwFactorA, ttbarwFactorB;
340  double phaseSpacemHatMin, phaseSpacemHatMax;
341  complex gammaProp, resProp, gmPropKK, ZPropKK, totalProp;
342  complex mI;
343 };
344 
345 //==========================================================================
346 
347 // A derived class for g g -> U/G g (real graviton emission in
348 // large extra dimensions or unparticle emission).
349 
350 class Sigma2gg2LEDUnparticleg : public Sigma2Process {
351 
352 public:
353 
354  // Constructor: bool Graviton = true, to use LED graviton settings.
355  Sigma2gg2LEDUnparticleg( bool Graviton ) : eDgraviton(Graviton) {}
356 
357  // Initialize process.
358  virtual void initProc();
359 
360  // Calculate flavour-independent parts of cross section;
361  // first step when inflavours unknown.
362  virtual void sigmaKin();
363 
364  // Evaluate sigmaHat(sHat); second step for given inflavours.
365  virtual double sigmaHat();
366 
367  // Select flavour, colour and anticolour.
368  virtual void setIdColAcol();
369 
370  // Info on the subprocess.
371  virtual string name() const {return
372  (eDgraviton ? "g g -> G g" : "g g -> U g") ;}
373  virtual int code() const {return (eDgraviton ? 5021 : 5045);}
374  virtual string inFlux() const {return "gg";}
375  virtual int id3Mass() const {return 5000039;}
376  virtual int id4Mass() const {return 21;}
377 
378 private:
379 
380  bool eDgraviton;
381  int eDspin, eDnGrav, eDidG, eDcutoff;
382  double mG, mGS, eDsigma0, eDdU, eDLambdaU, eDlambda, eDconstantTerm,
383  eDtff, eDcf;
384 
385 };
386 
387 //==========================================================================
388 
389 // A derived class for q g -> U/G q (real graviton emission in
390 // large extra dimensions or unparticle emission).
391 
392 class Sigma2qg2LEDUnparticleq : public Sigma2Process {
393 
394 public:
395 
396  // Constructor: bool Graviton = true, to use LED graviton settings.
397  Sigma2qg2LEDUnparticleq( bool Graviton) : eDgraviton(Graviton) {}
398 
399  // Initialize process.
400  virtual void initProc();
401 
402  // Calculate flavour-independent parts of cross section;
403  // first step when inflavours unknown.
404  virtual void sigmaKin();
405 
406  // Evaluate sigmaHat(sHat); second step for given inflavours.
407  virtual double sigmaHat();
408 
409  // Select flavour, colour and anticolour.
410  virtual void setIdColAcol();
411 
412  // Info on the subprocess.
413  virtual string name() const {return
414  (eDgraviton ? "q g -> G q" : "q g -> U q") ;}
415  virtual int code() const {return (eDgraviton ? 5022 : 5046);}
416  virtual string inFlux() const {return "qg";}
417  virtual int id3Mass() const {return 5000039;}
418 
419 private:
420 
421  bool eDgraviton;
422  int eDspin, eDnGrav, eDidG, eDcutoff;
423  double mG, mGS, eDsigma0, eDdU, eDLambdaU, eDlambda, eDconstantTerm,
424  eDtff, eDgf, eDcf;
425 
426 };
427 
428 //==========================================================================
429 
430 // A derived class for q qbar -> U/G g (real graviton emission in
431 // large extra dimensions or unparticle emission).
432 
433 class Sigma2qqbar2LEDUnparticleg : public Sigma2Process {
434 
435 public:
436 
437  // Constructor: bool Graviton = true, to use LED graviton settings.
438  Sigma2qqbar2LEDUnparticleg( bool Graviton) : eDgraviton(Graviton) {}
439 
440  // Initialize process.
441  virtual void initProc();
442 
443  // Calculate flavour-independent parts of cross section;
444  // first step when inflavours unknown.
445  virtual void sigmaKin();
446 
447  // Evaluate sigmaHat(sHat); second step for given inflavours.
448  virtual double sigmaHat();
449 
450  // Select flavour, colour and anticolour.
451  virtual void setIdColAcol();
452 
453  // Info on the subprocess.
454  virtual string name() const {return
455  (eDgraviton ? "q qbar -> G g" : "q qbar -> U g") ;}
456  virtual int code() const {return (eDgraviton ? 5023 : 5047);}
457  virtual string inFlux() const {return "qqbarSame";}
458  virtual int id3Mass() const {return 5000039;}
459  virtual int id4Mass() const {return 21;}
460 
461 private:
462 
463  bool eDgraviton;
464  int eDspin, eDnGrav, eDidG, eDcutoff;
465  double mG, mGS, eDsigma0, eDdU, eDLambdaU, eDlambda, eDconstantTerm,
466  eDtff, eDgf, eDcf;
467 
468 };
469 
470 //==========================================================================
471 
472 // A derived class for f fbar -> U/G Z (real graviton emission in
473 // large extra dimensions or unparticle emission).
474 
475 class Sigma2ffbar2LEDUnparticleZ : public Sigma2Process {
476 
477 public:
478 
479  // Constructor: bool Graviton = true, to use LED graviton settings.
480  Sigma2ffbar2LEDUnparticleZ( bool Graviton) : eDgraviton(Graviton) {}
481 
482  // Initialize process.
483  virtual void initProc();
484 
485  // Calculate flavour-independent parts of cross section;
486  // first step when inflavours unknown.
487  virtual void sigmaKin();
488 
489  // Evaluate sigmaHat(sHat); second step for given inflavours.
490  virtual double sigmaHat();
491 
492  // Select flavour, colour and anticolour.
493  virtual void setIdColAcol();
494 
495  // Info on the subprocess.
496  virtual string name() const {return
497  (eDgraviton ? "f fbar -> G Z" : "f fbar -> U Z") ;}
498  virtual int code() const {return (eDgraviton ? 5024 : 5041);}
499  virtual string inFlux() const {return "ffbarSame";}
500  virtual int id3Mass() const {return 5000039;}
501  virtual int id4Mass() const {return 23;}
502  virtual int resonanceA() const {return 23;}
503  virtual int gmZmode() const {return 2;}
504 
505 private:
506 
507  // Constants: could only be changed in the code itself.
508  static const double FIXRATIO;
509 
510  int eDspin, eDnGrav, eDcutoff, eDidG;
511  bool eDgraviton;
512  double eDdU, eDLambdaU, eDlambda, eDratio, eDlambdaPrime,
513  eDtff, eDconstantTerm;
514  double sHS, tHS, uHS, tHC, uHC, tHQ, uHQ, tHuH, mU, mUS, mZ, widZ,
515  mZS, mwZS, eDsigma0;
516 
517 };
518 
519 //==========================================================================
520 
521 // A derived class for f fbar -> U/G gamma (real graviton emission in
522 // large extra dimensions or unparticle emission).
523 
524 class Sigma2ffbar2LEDUnparticlegamma : public Sigma2Process {
525 
526 public:
527 
528  // Constructor: bool Graviton = true, to use LED graviton settings.
529  Sigma2ffbar2LEDUnparticlegamma( bool Graviton) : eDgraviton(Graviton) {}
530 
531  // Initialize process.
532  virtual void initProc();
533 
534  // Calculate flavour-independent parts of cross section;
535  // first step when inflavours unknown.
536  virtual void sigmaKin();
537 
538  // Evaluate sigmaHat(sHat); second step for given inflavours.
539  virtual double sigmaHat();
540 
541  // Select flavour, colour and anticolour.
542  virtual void setIdColAcol();
543 
544  // Info on the subprocess.
545  virtual string name() const {return
546  (eDgraviton ? "f fbar -> G gamma" : "f fbar -> U gamma") ;}
547  virtual int code() const {return (eDgraviton ? 5025 : 5042);}
548  virtual string inFlux() const {return "ffbarSame";}
549  virtual int id3Mass() const {return 5000039;}
550  virtual int id4Mass() const {return 22;}
551 
552 private:
553 
554  // Constants: could only be changed in the code itself.
555  static const double FIXRATIO;
556 
557  int eDspin, eDnGrav, eDcutoff, eDidG;
558  bool eDgraviton;
559  double eDdU, eDLambdaU, eDlambda, eDratio, eDlambdaPrime,
560  eDtff, eDconstantTerm;
561  double sHS, tHS, uHS, tHC, uHC, tHQ, uHQ, tHuH, mU, mUS, mZ,
562  mZS, eDsigma0;
563 
564 };
565 
566 //==========================================================================
567 
568 // A derived class for f fbar -> (LED G*/U*) -> gamma gamma
569 // (virtual graviton/unparticle exchange).
570 
571 class Sigma2ffbar2LEDgammagamma : public Sigma2Process {
572 
573 public:
574 
575  // Constructor: bool Graviton = true, to use LED graviton settings.
576  Sigma2ffbar2LEDgammagamma( bool Graviton) : eDgraviton(Graviton) {}
577 
578  // Initialize process.
579  virtual void initProc();
580 
581  // Calculate flavour-independent parts of cross section;
582  // first step when inflavours unknown.
583  virtual void sigmaKin();
584 
585  // Evaluate sigmaHat(sHat); second step for given inflavours.
586  virtual double sigmaHat();
587 
588  // Select flavour, colour and anticolour.
589  virtual void setIdColAcol();
590 
591  // Info on the subprocess.
592  virtual string name() const {return
593  (eDgraviton ? "f fbar -> (LED G*) -> gamma gamma"
594  : "f fbar -> (U*) -> gamma gamma") ;}
595  virtual int code() const {return (eDgraviton ? 5026 : 5043);}
596  virtual string inFlux() const {return "ffbarSame";}
597 
598 private:
599 
600  int eDspin, eDcutoff, eDnGrav, eDnegInt;
601  bool eDgraviton;
602  double eDdU, eDLambdaU, eDlambda, eDlambda2chi,
603  eDterm1, eDterm2, eDterm3, eDtff;
604 
605 };
606 
607 //==========================================================================
608 
609 // A derived class for g g -> (LED G*/U*) -> gamma gamma
610 // (virtual graviton/unparticle exchange).
611 
612 class Sigma2gg2LEDgammagamma : public Sigma2Process {
613 
614 public:
615 
616  // Constructor: bool Graviton = true, to use LED graviton settings.
617  Sigma2gg2LEDgammagamma( bool Graviton) : eDgraviton(Graviton) {}
618 
619  // Initialize process.
620  virtual void initProc();
621 
622  // Calculate flavour-independent parts of cross section;
623  // first step when inflavours unknown.
624  virtual void sigmaKin();
625 
626  // Evaluate sigmaHat(sHat); second step for given inflavours.
627  virtual double sigmaHat();
628 
629  // Select flavour, colour and anticolour.
630  virtual void setIdColAcol();
631 
632  // Info on the subprocess.
633  virtual string name() const {return (eDgraviton
634  ? "g g -> (LED G*) -> gamma gamma" : "g g -> (U*) -> gamma gamma") ;}
635  virtual int code() const {return (eDgraviton ? 5027 : 5044);}
636  virtual string inFlux() const {return "gg";}
637 
638 private:
639 
640  int eDspin, eDcutoff, eDnGrav;
641  bool eDgraviton;
642  double eDdU, eDLambdaU, eDlambda, eDlambda2chi, eDsigma0, eDtff;
643 
644 };
645 
646 //==========================================================================
647 
648 // A derived class for f fbar -> (LED G*/U*) -> l lbar
649 // (virtual graviton/unparticle exchange).
650 // Does not include t-channel contributions relevant for e^+e^- to e^+e^-
651 
652 class Sigma2ffbar2LEDllbar : public Sigma2Process {
653 
654 public:
655 
656  // Constructor: bool Graviton = true, to use LED graviton settings.
657  Sigma2ffbar2LEDllbar( bool Graviton) : eDgraviton(Graviton) {}
658 
659  // Initialize process.
660  virtual void initProc();
661 
662  // Calculate flavour-independent parts of cross section;
663  // first step when inflavours unknown.
664  virtual void sigmaKin();
665 
666  // Evaluate sigmaHat(sHat); second step for given inflavours.
667  virtual double sigmaHat();
668 
669  // Select flavour, colour and anticolour.
670  virtual void setIdColAcol();
671 
672  // Info on the subprocess.
673  virtual string name() const {return
674  (eDgraviton ? "f fbar -> (LED G*) -> l l" : "f fbar -> (U*) -> l l") ;}
675  virtual int code() const {return (eDgraviton ? 5028 : 5048);}
676  virtual string inFlux() const {return "ffbarSame";}
677  virtual bool isSChannel() const {return true;}
678 
679 private:
680 
681  int eDspin, eDcutoff, eDnGrav,eDnxx, eDnxy, eDnegInt;
682  bool eDgraviton;
683  double eDdU, eDLambdaU, eDlambda, eDlambda2chi, eDtff,
684  eDmZ, eDmZS, eDGZ, eDGZS, eDabsMeU, eDdenomPropZ, eDrePropGamma,
685  eDrePropZ, eDimPropZ, eDabsAS, eDreA, eDreABW, eDpoly1, eDpoly2,
686  eDpoly3;
687 
688 };
689 
690 //==========================================================================
691 
692 // A derived class for g g -> (LED G*/U*) -> l lbar
693 // (virtual graviton/unparticle exchange).
694 
695 class Sigma2gg2LEDllbar : public Sigma2Process {
696 
697 public:
698 
699  // Constructor: bool Graviton = true, to use LED graviton settings.
700  Sigma2gg2LEDllbar( bool Graviton) : eDgraviton(Graviton) {}
701 
702 
703  // Initialize process.
704  virtual void initProc();
705 
706  // Calculate flavour-independent parts of cross section;
707  // first step when inflavours unknown.
708  virtual void sigmaKin();
709 
710  // Evaluate sigmaHat(sHat); second step for given inflavours.
711  virtual double sigmaHat() {return eDsigma0;}
712 
713  // Select flavour, colour and anticolour.
714  virtual void setIdColAcol();
715 
716  // Info on the subprocess.
717  virtual string name() const {return
718  (eDgraviton ? "g g -> (LED G*) -> l l" : "g g -> (U*) -> l l") ;}
719  virtual int code() const {return (eDgraviton ? 5029 : 5049);}
720  virtual string inFlux() const {return "gg";}
721 
722 private:
723 
724  int eDspin, eDcutoff, eDnGrav;
725  bool eDgraviton;
726  double eDdU, eDLambdaU, eDlambda, eDlambda2chi, eDsigma0, eDtff;
727 
728 };
729 
730 //==========================================================================
731 
732 // A derived class for g g -> (LED G*) -> g g.
733 
734 class Sigma2gg2LEDgg : public Sigma2Process {
735 
736 public:
737 
738  // Constructor.
739  Sigma2gg2LEDgg() {}
740 
741  // Initialize process.
742  virtual void initProc();
743 
744  // Calculate flavour-independent parts of cross section.
745  virtual void sigmaKin();
746 
747  // Evaluate d(sigmaHat)/d(tHat).
748  virtual double sigmaHat() {return sigma;}
749 
750  // Select flavour, colour and anticolour.
751  virtual void setIdColAcol();
752 
753  // Info on the subprocess.
754  virtual string name() const {return "g g -> (LED G*) -> g g";}
755  virtual int code() const {return 5030;}
756  virtual string inFlux() const {return "gg";}
757 
758 private:
759 
760  // Values stored for colour flow selection.
761  double sigTS, sigUS, sigTU, sigSum, sigma;
762 
763  // Model parameters.
764  int eDopMode, eDnGrav, eDcutoff, eDnegInt;
765  double eDMD, eDLambdaT, eDtff;
766 
767 };
768 
769 //==========================================================================
770 
771 // A derived class for g g -> (LED G*) -> q qbar.
772 
773 class Sigma2gg2LEDqqbar : public Sigma2Process {
774 
775 public:
776 
777  // Constructor.
778  Sigma2gg2LEDqqbar() {}
779 
780  // Initialize process.
781  virtual void initProc();
782 
783  // Calculate flavour-independent parts of cross section.
784  virtual void sigmaKin();
785 
786  // Evaluate d(sigmaHat)/d(tHat).
787  virtual double sigmaHat() {return sigma;}
788 
789  // Select flavour, colour and anticolour.
790  virtual void setIdColAcol();
791 
792  // Info on the subprocess.
793  virtual string name() const {return "g g -> (LED G*) -> q qbar (uds)";}
794  virtual int code() const {return 5031;}
795  virtual string inFlux() const {return "gg";}
796 
797 private:
798 
799  // Number of quarks to be considered in massless approximation.
800  int nQuarkNew;
801 
802  // Values stored for colour flow selection.
803  int idNew;
804  double mNew, m2New, sigTS, sigUS, sigSum, sigma;
805 
806  // Model parameters.
807  int eDopMode, eDnGrav, eDcutoff, eDnegInt;
808  double eDMD, eDLambdaT, eDtff;
809 
810 };
811 
812 //==========================================================================
813 
814 // A derived class for q g -> (LED G*) -> q g.
815 // Use massless approximation also for Q since no alternative.
816 
817 class Sigma2qg2LEDqg : public Sigma2Process {
818 
819 public:
820 
821  // Constructor.
822  Sigma2qg2LEDqg() {}
823 
824  // Initialize process.
825  virtual void initProc();
826 
827  // Calculate flavour-independent parts of cross section.
828  virtual void sigmaKin();
829 
830  // Evaluate d(sigmaHat)/d(tHat).
831  virtual double sigmaHat() {return sigma;}
832 
833  // Select flavour, colour and anticolour.
834  virtual void setIdColAcol();
835 
836  // Info on the subprocess.
837  virtual string name() const {return "q g -> (LED G*) -> q g";}
838  virtual int code() const {return 5032;}
839  virtual string inFlux() const {return "qg";}
840 
841 private:
842 
843  // Values stored for colour flow selection.
844  double sigTS, sigTU, sigSum, sigma;
845 
846  // Model parameters.
847  int eDopMode, eDnGrav, eDcutoff, eDnegInt;
848  double eDMD, eDLambdaT, eDtff;
849 
850 };
851 
852 //==========================================================================
853 
854 // A derived class for q q(bar)' -> (LED G*) -> q q(bar)'.
855 
856 class Sigma2qq2LEDqq : public Sigma2Process {
857 
858 public:
859 
860  // Constructor.
861  Sigma2qq2LEDqq() {}
862 
863  // Initialize process.
864  virtual void initProc();
865 
866  // Calculate flavour-independent parts of cross section.
867  virtual void sigmaKin();
868 
869  // Evaluate d(sigmaHat)/d(tHat).
870  virtual double sigmaHat();
871 
872  // Select flavour, colour and anticolour.
873  virtual void setIdColAcol();
874 
875  // Info on the subprocess.
876  virtual string name() const {return "q q(bar)' -> (LED G*) -> q q(bar)'";}
877  virtual int code() const {return 5033;}
878  virtual string inFlux() const {return "qq";}
879 
880  private:
881 
882  // Values stored for colour flow selection.
883  double sigT, sigU, sigTU, sigST, sigSum;
884  double sigGrT1, sigGrT2, sigGrU, sigGrTU, sigGrST;
885 
886  // Model parameters.
887  int eDopMode, eDnGrav, eDcutoff, eDnegInt;
888  double eDMD, eDLambdaT, eDtff;
889 
890 };
891 
892 //==========================================================================
893 
894 // A derived class for q qbar -> (LED G*) -> g g.
895 
896 class Sigma2qqbar2LEDgg : public Sigma2Process {
897 
898 public:
899 
900  // Constructor.
901  Sigma2qqbar2LEDgg() {}
902 
903  // Initialize process.
904  virtual void initProc();
905 
906  // Calculate flavour-independent parts of cross section.
907  virtual void sigmaKin();
908 
909  // Evaluate d(sigmaHat)/d(tHat).
910  virtual double sigmaHat() {return sigma;}
911 
912  // Select flavour, colour and anticolour.
913  virtual void setIdColAcol();
914 
915  // Info on the subprocess.
916  virtual string name() const {return "q qbar -> (LED G*) -> g g";}
917  virtual int code() const {return 5034;}
918  virtual string inFlux() const {return "qqbarSame";}
919 
920  private:
921 
922  // Values stored for colour flow selection.
923  double sigTS, sigUS, sigSum, sigma;
924 
925  // Model parameters.
926  int eDopMode, eDnGrav, eDcutoff, eDnegInt;
927  double eDMD, eDLambdaT, eDtff;
928 
929 };
930 
931 //==========================================================================
932 
933 // A derived class for q qbar -> (LED G*) -> q' qbar'.
934 
935 class Sigma2qqbar2LEDqqbarNew : public Sigma2Process {
936 
937 public:
938 
939  // Constructor.
940  Sigma2qqbar2LEDqqbarNew() {}
941 
942  // Initialize process.
943  virtual void initProc();
944 
945  // Calculate flavour-independent parts of cross section.
946  virtual void sigmaKin();
947 
948  // Evaluate d(sigmaHat)/d(tHat).
949  virtual double sigmaHat() {return sigma;}
950 
951  // Select flavour, colour and anticolour.
952  virtual void setIdColAcol();
953 
954  // Info on the subprocess.
955  virtual string name() const {return "q qbar -> (LED G*) -> q' qbar' (uds)";}
956  virtual int code() const {return 5035;}
957  virtual string inFlux() const {return "qqbarSame";}
958 
959  private:
960 
961  // Number of quarks to be considered in massless approximation.
962  int nQuarkNew;
963 
964  // Values stored for colour flow selection.
965  int idNew;
966  double mNew, m2New, sigS, sigma;
967 
968  // Model parameters.
969  int eDopMode, eDnGrav, eDcutoff;
970  double eDMD, eDLambdaT, eDtff;
971 
972 };
973 
974 //==========================================================================
975 
976 } // end namespace Pythia8
977 
978 #endif // Pythia8_SigmaExtraDim_H
Definition: AgUStep.h:26