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