Coverity 21249-21243
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8175 / include / SigmaExtraDim.h
CommitLineData
c6b60c38 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
15namespace Pythia8 {
16
17//==========================================================================
18
19// A derived class for g g -> G^* (excited graviton state).
20
21class Sigma1gg2GravitonStar : public Sigma1Process {
22
23public:
24
25 // Constructor.
720fbe87 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 }
c6b60c38 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
54private:
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
73class Sigma1ffbar2GravitonStar : public Sigma1Process {
74
75public:
76
77 // Constructor.
720fbe87 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 }
c6b60c38 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
106private:
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
125class Sigma1qqbar2KKgluonStar : public Sigma1Process {
126
127public:
128
129 // Constructor.
720fbe87 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 }
c6b60c38 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
160private:
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
185class Sigma2gg2GravitonStarg : public Sigma2Process {
186
187public:
188
189 // Constructor.
720fbe87 190 Sigma2gg2GravitonStarg() : idGstar(0),
191 mRes(0), GammaRes(0), m2Res(0), GamMRat(0), kappaMG(0), openFrac(0), sigma(0) {}
c6b60c38 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
214private:
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
226class Sigma2qg2GravitonStarq : public Sigma2Process {
227
228public:
229
230 // Constructor.
720fbe87 231 Sigma2qg2GravitonStarq() : idGstar(0),
232 mRes(0), GammaRes(0), m2Res(0), GamMRat(0), kappaMG(0), openFrac(0), sigma(0) {}
c6b60c38 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
255private:
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
267class Sigma2qqbar2GravitonStarg : public Sigma2Process {
268
269public:
270
271 // Constructor.
720fbe87 272 Sigma2qqbar2GravitonStarg() : idGstar(0),
273 mRes(0), GammaRes(0), m2Res(0), GamMRat(0), kappaMG(0), openFrac(0), sigma(0) {}
c6b60c38 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
296private:
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
310class Sigma2ffbar2TEVffbar : public Sigma2Process {
311
312public:
313
314 // Constructor.
720fbe87 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) {}
c6b60c38 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
359private:
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
384class Sigma2gg2LEDUnparticleg : public Sigma2Process {
385
386public:
387
388 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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){}
c6b60c38 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
415private:
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
429class Sigma2qg2LEDUnparticleq : public Sigma2Process {
430
431public:
432
433 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
459private:
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
473class Sigma2qqbar2LEDUnparticleg : public Sigma2Process {
474
475public:
476
477 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
504private:
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
518class Sigma2ffbar2LEDUnparticleZ : public Sigma2Process {
519
520public:
521
522 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
552private:
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
571class Sigma2ffbar2LEDUnparticlegamma : public Sigma2Process {
572
573public:
574
575 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
603private:
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
622class Sigma2ffbar2LEDgammagamma : public Sigma2Process {
623
624public:
625
626 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
651private:
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
665class Sigma2gg2LEDgammagamma : public Sigma2Process {
666
667public:
668
669 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
692private:
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
706class Sigma2ffbar2LEDllbar : public Sigma2Process {
707
708public:
709
710 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
737private:
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
753class Sigma2gg2LEDllbar : public Sigma2Process {
754
755public:
756
757 // Constructor: bool Graviton = true, to use LED graviton settings.
720fbe87 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) {}
c6b60c38 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
781private:
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
793class Sigma2gg2LEDgg : public Sigma2Process {
794
795public:
796
797 // Constructor.
720fbe87 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) {}
c6b60c38 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
819private:
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
834class Sigma2gg2LEDqqbar : public Sigma2Process {
835
836public:
837
838 // Constructor.
720fbe87 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) {}
c6b60c38 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
861private:
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
881class Sigma2qg2LEDqg : public Sigma2Process {
882
883public:
884
885 // Constructor.
720fbe87 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) {}
c6b60c38 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
907private:
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
922class Sigma2qq2LEDqq : public Sigma2Process {
923
924public:
925
926 // Constructor.
720fbe87 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) {}
c6b60c38 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
965class Sigma2qqbar2LEDgg : public Sigma2Process {
966
967public:
968
969 // Constructor.
720fbe87 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) {}
c6b60c38 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
1006class Sigma2qqbar2LEDqqbarNew : public Sigma2Process {
1007
1008public:
1009
1010 // Constructor.
720fbe87 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) {}
c6b60c38 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