3502477e4f9454d880b75211de3d0a2e85fc0b0e
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8175 / include / SigmaExtraDim.h
1 // SigmaExtraDim.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2013 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 "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,
333           gPlus, gMinus, gf, gF;
334   double  mRes, m2Res, mStar, mTop, m2Top, mZKKn, m2ZKKn, m2gmKKn, mgmKKn,
335           alphaemfixed;
336   double  helicityME2, coefTot, coefAngular;
337   double  mr, betaf, cosThe, openFracPair;
338   double  wgmKKFactor, wgmKKn, wZKKn,
339           wZ0, ttbarwZKKn, ttbarwgmKKn,
340           ttbarwFactorA, ttbarwFactorB;
341   double  phaseSpacemHatMin, phaseSpacemHatMax;
342   complex gammaProp, resProp, gmPropKK, ZPropKK, totalProp;
343   complex mI;
344 };
345  
346 //==========================================================================
347  
348 // A derived class for g g -> U/G g (real graviton emission in
349 // large extra dimensions or unparticle emission).
350  
351 class Sigma2gg2LEDUnparticleg : public Sigma2Process {
352  
353 public:
354  
355   // Constructor: bool Graviton  = true, to use LED graviton settings.
356   Sigma2gg2LEDUnparticleg( bool Graviton ) : eDgraviton(Graviton) {}
357  
358   // Initialize process.
359   virtual void initProc();
360  
361   // Calculate flavour-independent parts of cross section;
362   // first step when inflavours unknown.
363   virtual void sigmaKin();
364  
365   // Evaluate sigmaHat(sHat); second step for given inflavours.
366   virtual double sigmaHat();
367  
368   // Select flavour, colour and anticolour.
369   virtual void setIdColAcol();
370  
371   // Info on the subprocess.
372   virtual string name()       const {return
373     (eDgraviton ? "g g -> G g" : "g g -> U g") ;}
374   virtual int    code()       const {return (eDgraviton ? 5021 : 5045);}
375   virtual string inFlux()     const {return "gg";}
376   virtual int    id3Mass()    const {return 5000039;}
377   virtual int    id4Mass()    const {return 21;}
378  
379 private:
380  
381   bool   eDgraviton;
382   int    eDspin, eDnGrav, eDidG, eDcutoff;
383   double mG, mGS, eDsigma0, eDdU, eDLambdaU, eDlambda, eDconstantTerm,
384          eDtff, eDcf;
385  
386 };
387  
388 //==========================================================================
389  
390 // A derived class for q g -> U/G q (real graviton emission in
391 // large extra dimensions or unparticle emission).
392  
393 class Sigma2qg2LEDUnparticleq : public Sigma2Process {
394  
395 public:
396  
397   // Constructor: bool Graviton  = true, to use LED graviton settings.
398   Sigma2qg2LEDUnparticleq( bool Graviton) : eDgraviton(Graviton) {}
399  
400   // Initialize process.
401   virtual void initProc();
402  
403   // Calculate flavour-independent parts of cross section;
404   // first step when inflavours unknown.
405   virtual void sigmaKin();
406  
407   // Evaluate sigmaHat(sHat); second step for given inflavours.
408   virtual double sigmaHat();
409  
410   // Select flavour, colour and anticolour.
411   virtual void setIdColAcol();
412  
413   // Info on the subprocess.
414   virtual string name()       const {return
415     (eDgraviton ? "q g -> G q" : "q g -> U q") ;}
416   virtual int    code()       const {return (eDgraviton ? 5022 : 5046);}
417   virtual string inFlux()     const {return "qg";}
418   virtual int    id3Mass()    const {return 5000039;}
419  
420 private:
421  
422   bool   eDgraviton;
423   int    eDspin, eDnGrav, eDidG, eDcutoff;
424   double mG, mGS, eDsigma0, eDdU, eDLambdaU, eDlambda, eDconstantTerm,
425          eDtff, eDgf, eDcf;
426  
427 };
428  
429 //==========================================================================
430  
431 // A derived class for q qbar -> U/G g (real graviton emission in
432 // large extra dimensions or unparticle emission).
433  
434 class Sigma2qqbar2LEDUnparticleg : public Sigma2Process {
435  
436 public:
437  
438   // Constructor: bool Graviton  = true, to use LED graviton settings.
439   Sigma2qqbar2LEDUnparticleg( bool Graviton) : eDgraviton(Graviton) {}
440  
441   // Initialize process.
442   virtual void initProc();
443  
444   // Calculate flavour-independent parts of cross section;
445   // first step when inflavours unknown.
446   virtual void sigmaKin();
447  
448   // Evaluate sigmaHat(sHat); second step for given inflavours.
449   virtual double sigmaHat();
450  
451   // Select flavour, colour and anticolour.
452   virtual void setIdColAcol();
453  
454   // Info on the subprocess.
455   virtual string name()       const {return
456     (eDgraviton ? "q qbar -> G g" : "q qbar -> U g") ;}
457   virtual int    code()       const {return (eDgraviton ? 5023 : 5047);}
458   virtual string inFlux()     const {return "qqbarSame";}
459   virtual int    id3Mass()    const {return 5000039;}
460   virtual int    id4Mass()    const {return 21;}
461  
462 private:
463  
464   bool   eDgraviton;
465   int    eDspin, eDnGrav, eDidG, eDcutoff;
466   double mG, mGS, eDsigma0, eDdU, eDLambdaU, eDlambda, eDconstantTerm,
467          eDtff, eDgf, eDcf;
468  
469 };
470  
471 //==========================================================================
472  
473 // A derived class for f fbar -> U/G Z (real graviton emission in
474 // large extra dimensions or unparticle emission).
475  
476 class Sigma2ffbar2LEDUnparticleZ : public Sigma2Process {
477  
478 public:
479  
480   // Constructor: bool Graviton  = true, to use LED graviton settings.
481   Sigma2ffbar2LEDUnparticleZ( bool Graviton) : eDgraviton(Graviton) {}
482  
483   // Initialize process.
484   virtual void initProc();
485  
486   // Calculate flavour-independent parts of cross section;
487   // first step when inflavours unknown.
488   virtual void sigmaKin();
489  
490   // Evaluate sigmaHat(sHat); second step for given inflavours.
491   virtual double sigmaHat();
492  
493   // Select flavour, colour and anticolour.
494   virtual void setIdColAcol();
495  
496   // Info on the subprocess.
497   virtual string name()       const {return
498     (eDgraviton ? "f fbar -> G Z" : "f fbar -> U Z") ;}
499   virtual int    code()       const {return (eDgraviton ? 5024 : 5041);}
500   virtual string inFlux()     const {return "ffbarSame";}
501   virtual int    id3Mass()    const {return 5000039;}
502   virtual int    id4Mass()    const {return 23;}
503   virtual int    resonanceA() const {return 23;}
504   virtual int    gmZmode()    const {return 2;}
505  
506 private:
507  
508   // Constants: could only be changed in the code itself.
509   static const double FIXRATIO;
510  
511   int    eDspin, eDnGrav, eDcutoff, eDidG;
512   bool   eDgraviton;
513   double eDdU, eDLambdaU, eDlambda, eDratio, eDlambdaPrime,
514          eDtff, eDconstantTerm;
515   double sHS, tHS, uHS, tHC, uHC, tHQ, uHQ, tHuH, mU, mUS, mZ, widZ,
516          mZS, mwZS, thetaWRat, eDsigma0;
517  
518 };
519  
520 //==========================================================================
521  
522 // A derived class for f fbar -> U/G gamma (real graviton emission in
523 // large extra dimensions or unparticle emission).
524  
525 class Sigma2ffbar2LEDUnparticlegamma : public Sigma2Process {
526  
527 public:
528  
529   // Constructor: bool Graviton  = true, to use LED graviton settings.
530   Sigma2ffbar2LEDUnparticlegamma( bool Graviton) : eDgraviton(Graviton) {}
531  
532   // Initialize process.
533   virtual void initProc();
534  
535   // Calculate flavour-independent parts of cross section;
536   // first step when inflavours unknown.
537   virtual void sigmaKin();
538  
539   // Evaluate sigmaHat(sHat); second step for given inflavours.
540   virtual double sigmaHat();
541  
542   // Select flavour, colour and anticolour.
543   virtual void setIdColAcol();
544  
545   // Info on the subprocess.
546   virtual string name()       const {return
547     (eDgraviton ? "f fbar -> G gamma" : "f fbar -> U gamma") ;}
548   virtual int    code()       const {return (eDgraviton ? 5025 : 5042);}
549   virtual string inFlux()     const {return "ffbarSame";}
550   virtual int    id3Mass()    const {return 5000039;}
551   virtual int    id4Mass()    const {return 22;}
552  
553 private:
554  
555   // Constants: could only be changed in the code itself.
556   static const double FIXRATIO;
557  
558   int    eDspin, eDnGrav, eDcutoff, eDidG;
559   bool   eDgraviton;
560   double eDdU, eDLambdaU, eDlambda, eDratio, eDlambdaPrime,
561          eDtff, eDconstantTerm;
562   double sHS, tHS, uHS, tHC, uHC, tHQ, uHQ, tHuH, mU, mUS, mZ, widZ,
563          mZS, mwZS, thetaWRat, eDsigma0;
564  
565 };
566  
567 //==========================================================================
568  
569 // A derived class for f fbar -> (LED G*/U*) -> gamma gamma
570 // (virtual graviton/unparticle exchange).
571  
572 class Sigma2ffbar2LEDgammagamma : public Sigma2Process {
573  
574 public:
575  
576   // Constructor: bool Graviton  = true, to use LED graviton settings.
577   Sigma2ffbar2LEDgammagamma( bool Graviton) : eDgraviton(Graviton) {}
578  
579   // Initialize process.
580   virtual void initProc();
581  
582   // Calculate flavour-independent parts of cross section;
583   // first step when inflavours unknown.
584   virtual void sigmaKin();
585  
586   // Evaluate sigmaHat(sHat); second step for given inflavours.
587   virtual double sigmaHat();
588  
589   // Select flavour, colour and anticolour.
590   virtual void setIdColAcol();
591  
592   // Info on the subprocess.
593   virtual string name()       const {return
594     (eDgraviton ? "f fbar -> (LED G*) -> gamma gamma"
595     : "f fbar -> (U*) -> gamma gamma") ;}
596   virtual int    code()       const {return (eDgraviton ? 5026 : 5043);}
597   virtual string inFlux()     const {return "ffbarSame";}
598  
599 private:
600  
601   int    eDspin, eDcutoff, eDnGrav, eDnegInt;
602   bool   eDgraviton;
603   double eDdU, eDLambdaU, eDlambda, eDlambda2chi,
604          eDterm1, eDterm2, eDterm3, eDtff;
605  
606 };
607  
608 //==========================================================================
609  
610 // A derived class for g g -> (LED G*/U*) -> gamma gamma
611 // (virtual graviton/unparticle exchange).
612  
613 class Sigma2gg2LEDgammagamma : public Sigma2Process {
614  
615 public:
616  
617   // Constructor: bool Graviton  = true, to use LED graviton settings.
618   Sigma2gg2LEDgammagamma( bool Graviton) : eDgraviton(Graviton) {}
619  
620   // Initialize process.
621   virtual void initProc();
622  
623   // Calculate flavour-independent parts of cross section;
624   // first step when inflavours unknown.
625   virtual void sigmaKin();
626  
627   // Evaluate sigmaHat(sHat); second step for given inflavours.
628   virtual double sigmaHat();
629  
630   // Select flavour, colour and anticolour.
631   virtual void setIdColAcol();
632  
633   // Info on the subprocess.
634   virtual string name()       const {return (eDgraviton
635     ? "g g -> (LED G*) -> gamma gamma" : "g g -> (U*) -> gamma gamma") ;}
636   virtual int    code()       const {return (eDgraviton ? 5027 : 5044);}
637   virtual string inFlux()     const {return "gg";}
638  
639 private:
640  
641   int    eDspin, eDcutoff, eDnGrav;
642   bool   eDgraviton;
643   double eDdU, eDLambdaU, eDlambda, eDlambda2chi, eDsigma0, eDtff;
644  
645 };
646  
647 //==========================================================================
648  
649 // A derived class for f fbar -> (LED G*/U*) -> l lbar
650 // (virtual graviton/unparticle exchange).
651 // Does not include t-channel contributions relevant for e^+e^- to e^+e^-
652  
653 class Sigma2ffbar2LEDllbar : public Sigma2Process {
654  
655 public:
656  
657   // Constructor: bool Graviton  = true, to use LED graviton settings.
658   Sigma2ffbar2LEDllbar( bool Graviton) : eDgraviton(Graviton) {}
659  
660   // Initialize process.
661   virtual void initProc();
662  
663   // Calculate flavour-independent parts of cross section;
664   // first step when inflavours unknown.
665   virtual void sigmaKin();
666  
667   // Evaluate sigmaHat(sHat); second step for given inflavours.
668   virtual double sigmaHat();
669  
670   // Select flavour, colour and anticolour.
671   virtual void setIdColAcol();
672  
673   // Info on the subprocess.
674   virtual string name()       const {return
675     (eDgraviton ? "f fbar -> (LED G*) -> l l" : "f fbar -> (U*) -> l l") ;}
676   virtual int    code()       const {return (eDgraviton ? 5028 : 5048);}
677   virtual string inFlux()     const {return "ffbarSame";}
678   virtual bool   isSChannel() const {return true;}
679  
680 private:
681  
682   int    eDspin, eDcutoff, eDnGrav,eDnxx, eDnxy, eDnegInt;
683   bool   eDgraviton;
684   double eDdU, eDLambdaU, eDlambda, eDlambda2chi, eDtff,
685          eDmZ, eDmZS, eDGZ, eDGZS, eDabsMeU, eDdenomPropZ, eDrePropGamma,
686          eDrePropZ, eDimPropZ, eDabsAS, eDreA, eDreABW, eDpoly1, eDpoly2,
687          eDpoly3;
688  
689 };
690  
691 //==========================================================================
692  
693 // A derived class for g g -> (LED G*/U*) -> l lbar
694 // (virtual graviton/unparticle exchange).
695  
696 class Sigma2gg2LEDllbar : public Sigma2Process {
697  
698 public:
699  
700   // Constructor: bool Graviton  = true, to use LED graviton settings.
701   Sigma2gg2LEDllbar( bool Graviton) : eDgraviton(Graviton) {}
702  
703  
704   // Initialize process.
705   virtual void initProc();
706  
707   // Calculate flavour-independent parts of cross section;
708   // first step when inflavours unknown.
709   virtual void sigmaKin();
710  
711   // Evaluate sigmaHat(sHat); second step for given inflavours.
712   virtual double sigmaHat() {return eDsigma0;}
713  
714   // Select flavour, colour and anticolour.
715   virtual void setIdColAcol();
716  
717   // Info on the subprocess.
718   virtual string name()       const {return
719     (eDgraviton ? "g g -> (LED G*) -> l l" : "g g -> (U*) -> l l") ;}
720   virtual int    code()       const {return (eDgraviton ? 5029 : 5049);}
721   virtual string inFlux()     const {return "gg";}
722  
723 private:
724  
725   int    eDspin, eDcutoff, eDnGrav;
726   bool   eDgraviton;
727   double eDdU, eDLambdaU, eDlambda, eDlambda2chi, eDsigma0, eDtff;
728  
729 };
730
731 //==========================================================================
732
733 // A derived class for g g -> (LED G*) -> g g.
734
735 class Sigma2gg2LEDgg : public Sigma2Process {
736
737 public:
738
739   // Constructor.
740   Sigma2gg2LEDgg() {}
741
742   // Initialize process. 
743   virtual void initProc(); 
744
745   // Calculate flavour-independent parts of cross section.
746   virtual void sigmaKin();
747
748   // Evaluate d(sigmaHat)/d(tHat). 
749   virtual double sigmaHat() {return sigma;}
750
751   // Select flavour, colour and anticolour.
752   virtual void setIdColAcol();
753
754   // Info on the subprocess.
755   virtual string name()   const {return "g g -> (LED G*) -> g g";}
756   virtual int    code()   const {return 5030;}
757   virtual string inFlux() const {return "gg";}
758
759 private:
760
761   // Values stored for colour flow selection.
762   double sigTS, sigUS, sigTU, sigSum, sigma;
763
764   // Model parameters.
765   int eDopMode, eDnGrav, eDcutoff, eDnegInt;
766   double eDMD, eDLambdaT, eDtff;
767
768 };
769
770 //==========================================================================
771
772 // A derived class for g g -> (LED G*) -> q qbar.
773
774 class Sigma2gg2LEDqqbar : public Sigma2Process {
775
776 public:
777
778   // Constructor.
779   Sigma2gg2LEDqqbar() {}
780
781   // Initialize process. 
782   virtual void initProc(); 
783
784   // Calculate flavour-independent parts of cross section.
785   virtual void sigmaKin();
786
787   // Evaluate d(sigmaHat)/d(tHat). 
788   virtual double sigmaHat() {return sigma;}
789
790   // Select flavour, colour and anticolour.
791   virtual void setIdColAcol();
792
793   // Info on the subprocess.
794   virtual string name()   const {return "g g -> (LED G*) -> q qbar (uds)";}
795   virtual int    code()   const {return 5031;}
796   virtual string inFlux() const {return "gg";}
797
798 private:
799
800   // Number of quarks to be considered in massless approximation.
801   int    nQuarkNew;
802
803   // Values stored for colour flow selection.
804   int    idNew;
805   double mNew, m2New, sigTS, sigUS, sigSum, sigma;
806
807   // Model parameters.
808   int eDopMode, eDnGrav, eDcutoff, eDnegInt;
809   double eDMD, eDLambdaT, eDtff;
810
811 };
812  
813 //==========================================================================
814
815 // A derived class for q g -> (LED G*) -> q g.
816 // Use massless approximation also for Q since no alternative.
817
818 class Sigma2qg2LEDqg : public Sigma2Process {
819
820 public:
821
822   // Constructor.
823   Sigma2qg2LEDqg() {}
824
825   // Initialize process. 
826   virtual void initProc(); 
827
828   // Calculate flavour-independent parts of cross section.
829   virtual void sigmaKin();
830
831   // Evaluate d(sigmaHat)/d(tHat). 
832   virtual double sigmaHat() {return sigma;}
833
834   // Select flavour, colour and anticolour.
835   virtual void setIdColAcol();
836
837   // Info on the subprocess.
838   virtual string name()   const {return "q g -> (LED G*) -> q g";}
839   virtual int    code()   const {return 5032;}
840   virtual string inFlux() const {return "qg";}
841
842 private:
843
844   // Values stored for colour flow selection.
845   double mNew, m2New, sigTS, sigTU, sigSum, sigma;
846
847   // Model parameters.
848   int eDopMode, eDnGrav, eDcutoff, eDnegInt;
849   double eDMD, eDLambdaT, eDtff;
850
851 };
852  
853 //==========================================================================
854
855 // A derived class for q q(bar)' -> (LED G*) -> q q(bar)'.
856
857 class Sigma2qq2LEDqq : public Sigma2Process {
858
859 public:
860
861   // Constructor.
862   Sigma2qq2LEDqq() {}
863
864   // Initialize process. 
865   virtual void initProc(); 
866
867   // Calculate flavour-independent parts of cross section.
868   virtual void sigmaKin();
869
870   // Evaluate d(sigmaHat)/d(tHat). 
871   virtual double sigmaHat();
872
873   // Select flavour, colour and anticolour.
874   virtual void setIdColAcol();
875
876   // Info on the subprocess.
877   virtual string name()   const {return "q q(bar)' -> (LED G*) -> q q(bar)'";}
878   virtual int    code()   const {return 5033;}
879   virtual string inFlux() const {return "qq";}
880
881  private:
882
883   // Values stored for colour flow selection.
884   double sigT, sigU, sigTU, sigST, sigSum;
885   double sigGrT1, sigGrT2, sigGrU, sigGrTU, sigGrST;
886  
887   // Model parameters.
888   int eDopMode, eDnGrav, eDcutoff, eDnegInt;
889   double eDMD, eDLambdaT, eDtff;
890
891 };
892  
893 //==========================================================================
894
895 // A derived class for q qbar -> (LED G*) -> g g.
896
897 class Sigma2qqbar2LEDgg : public Sigma2Process {
898
899 public:
900
901   // Constructor.
902   Sigma2qqbar2LEDgg() {}
903
904   // Initialize process. 
905   virtual void initProc(); 
906
907   // Calculate flavour-independent parts of cross section.
908   virtual void sigmaKin();
909
910   // Evaluate d(sigmaHat)/d(tHat). 
911   virtual double sigmaHat() {return sigma;}
912
913   // Select flavour, colour and anticolour.
914   virtual void setIdColAcol();
915
916   // Info on the subprocess.
917   virtual string name()   const {return "q qbar -> (LED G*) -> g g";}
918   virtual int    code()   const {return 5034;}
919   virtual string inFlux() const {return "qqbarSame";}
920
921  private:
922
923   // Values stored for colour flow selection.
924   double sigTS, sigUS, sigSum, sigma;
925
926   // Model parameters.
927   int eDopMode, eDnGrav, eDcutoff, eDnegInt;
928   double eDMD, eDLambdaT, eDtff;
929
930 };
931   
932 //==========================================================================
933
934 // A derived class for q qbar -> (LED G*) -> q' qbar'.
935
936 class Sigma2qqbar2LEDqqbarNew : public Sigma2Process {
937
938 public:
939
940   // Constructor.
941   Sigma2qqbar2LEDqqbarNew() {}
942
943   // Initialize process. 
944   virtual void initProc(); 
945
946   // Calculate flavour-independent parts of cross section.
947   virtual void sigmaKin();
948
949   // Evaluate d(sigmaHat)/d(tHat). 
950   virtual double sigmaHat() {return sigma;}
951
952   // Select flavour, colour and anticolour.
953   virtual void setIdColAcol();
954
955   // Info on the subprocess.
956   virtual string name()  const {return "q qbar -> (LED G*) -> q' qbar' (uds)";}
957   virtual int    code()   const {return 5035;}
958   virtual string inFlux() const {return "qqbarSame";}
959
960  private:
961
962   // Number of quarks to be considered in massless approximation.
963   int    nQuarkNew;
964
965   // Values stored for colour flow selection.
966   int    idNew;
967   double mNew, m2New, sigS, sigma;
968
969   // Model parameters.
970   int eDopMode, eDnGrav, eDcutoff;
971   double eDMD, eDLambdaT, eDtff;
972
973 };
974
975 //==========================================================================
976  
977 } // end namespace Pythia8
978  
979 #endif // Pythia8_SigmaExtraDim_H