]>
Commit | Line | Data |
---|---|---|
63ba5337 | 1 | // SigmaExtraDim.h is a part of the PYTHIA event generator. |
2 | // Copyright (C) 2012 Torbjorn Sjostrand. | |
3 | // Copyright (C) 2012 Stefan Ask for the *LED* routines. | |
4 | // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details. | |
5 | // Please respect the MCnet Guidelines, see GUIDELINES for details. | |
6 | ||
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 |