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