4d45d85216fbfd105ed7522afcd0e7e97d85fcc4
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8130 / include / ResonanceWidths.h
1 // ResonanceWidths.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2008 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 // Header file for resonance properties: dynamical widths etc. 
7 // ResonanceWidths: base class for all resonances.
8 // ResonanceGmZ, ...: derived classes for individual resonances.
9
10 #ifndef Pythia8_ResonanceWidths_H
11 #define Pythia8_ResonanceWidths_H
12
13 #include "Basics.h"
14 #include "Info.h"
15 #include "ParticleData.h"
16 #include "PythiaStdlib.h"
17 #include "Settings.h"
18 #include "StandardModel.h"
19
20 namespace Pythia8 {
21
22 //**************************************************************************
23
24 // Forward references to ParticleData and StandardModel classes.
25 class DecayChannel;
26 class DecayTable;
27 class ParticleDataEntry;
28 class AlphaStrong;
29 class AlphaEM;
30   
31 //**************************************************************************
32
33 // The ResonanceWidths is the base class. Also used for generic resonaces.
34
35 class ResonanceWidths {
36
37 public: 
38
39   // Destructor.
40   virtual ~ResonanceWidths() {}
41
42   // Initialize static data members in base class.
43   static void initStatic(Info* infoPtrIn);
44
45   // Set up standard properties.
46   bool initBasic(int idResIn);
47  
48   // Calculate and store partial and total widths at the nominal mass. 
49   void init();
50
51   // Return identity of particle species.
52   int id() const {return idRes;}
53  
54   // Calculate the total/open width for given mass, charge and instate.
55   double width(int idSgn, double mHatIn, int idInFlavIn = 0,  
56     bool openOnly = false, bool setBR = false, int idOutFlav1 = 0, 
57     int idOutFlav2 = 0); 
58
59   // Special case to calculate open final-state width.
60   double widthOpen(int idSgn, double mHatIn, int idIn = 0) {
61     return width( idSgn, mHatIn, idIn, true, false);}  
62
63   // Special case to store open final-state widths for channel selection.
64   double widthStore(int idSgn, double mHatIn, int idIn = 0) {
65     return width( idSgn, mHatIn, idIn, true, true);}  
66
67   // Return fraction of width open for particle and antiparticle.
68   double openFrac(int idSgn) {return (idSgn > 0) ? openPos : openNeg;}
69
70   // Return forced rescaling factor of resonance width.
71   double widthRescaleFactor() {return forceFactor;} 
72
73   // Special case to calculate one final-state width.
74   // Currently only used for Higgs -> qqbar, g g or gamma gamma. 
75   double widthChan(double mHatIn, int idOutFlav1, int idOutFlav2) {
76     return width( 1, mHatIn, 0, false, false, idOutFlav1, idOutFlav2);}  
77
78 protected:
79
80   // Constructor.
81   ResonanceWidths() {}
82
83   // Static initialization data, normally only set once.
84   static int    alphaSorder, alphaEMorder;
85   static double alphaSvalue, minWidth, minThreshold;
86
87   // Static alphaStrong and alphaElectromagnetic calculation.
88   static AlphaStrong alphaS;
89   static AlphaEM     alphaEM;
90
91   // Constants: could only be changed in the code itself.
92   static const int    NPOINT;
93   static const double MASSMARGIN;
94
95   // Pointer to various information on the generation.
96   static Info* infoPtr;
97
98   // Pointer to properties of the particle species.
99   ParticleDataEntry* particlePtr;
100
101   // Particle properties always locally present.
102   int    idRes, hasAntiRes;
103   bool   doForceWidth;
104   double mRes, GammaRes, m2Res, GamMRat, openPos, openNeg, forceFactor;
105
106   // Properties for currently studied decay channel(s).
107   int    iChannel, onMode, meMode, mult, id1, id2, id3, id1Abs, 
108          id2Abs, id3Abs, idInFlav;
109   double widNow, mHat, mf1, mf2, mf3, mr1, mr2, mr3, ps, kinFac,
110          alpEM, alpS, colQ, preFac; 
111  
112   // Initialize constants.
113   virtual void initConstants() {} 
114  
115   // Calculate various common prefactors for the current mass.
116   // Optional argument calledFromInit only used for Z0.
117   virtual void calcPreFac(bool = false) {}
118
119   // Calculate width for currently considered channel.
120   // Optional argument calledFromInit only used for Z0.
121   virtual void calcWidth(bool = false) {}
122
123   // Simple routines for matrix-element integration over Breit-Wigners.
124   double numInt1BW(double mHatIn, double m1, double Gamma1, double mMin1, 
125     double m2, int psMode = 1);
126   double numInt2BW(double mHatIn, double m1, double Gamma1, double mMin1, 
127     double m2, double Gamma2, double mMin2, int psMode = 1);
128
129 };
130   
131 //**************************************************************************
132
133 // The ResonanceGeneric class handles a generic resonance.
134 // Only needs a constructor; for the rest uses defaults in base class. 
135
136 class ResonanceGeneric : public ResonanceWidths {
137
138 public:
139
140   // Constructor. 
141   ResonanceGeneric(int idResIn) {initBasic(idResIn);} 
142
143 };
144   
145 //**************************************************************************
146
147 // The ResonanceGmZ class handles the gamma*/Z0 resonance.
148
149 class ResonanceGmZ : public ResonanceWidths {
150
151 public:
152
153   // Constructor. 
154   ResonanceGmZ(int idResIn) {initBasic(idResIn);} 
155
156 private: 
157
158   // Locally stored properties and couplings.
159   int    gmZmode;
160   double thetaWRat, ei2, eivi, vi2ai2, gamNorm, intNorm, resNorm;
161  
162   // Initialize constants.
163   virtual void initConstants(); 
164  
165   // Calculate various common prefactors for the current mass.
166   virtual void calcPreFac(bool = false);
167
168   // Caclulate width for currently considered channel.
169   virtual void calcWidth(bool calledFromInit = false);
170
171 };
172   
173 //**************************************************************************
174
175 // The ResonanceW class handles the W+- resonance.
176
177 class ResonanceW : public ResonanceWidths {
178
179 public:
180
181   // Constructor. 
182   ResonanceW(int idResIn) {initBasic(idResIn);} 
183
184 private: 
185
186   // Locally stored properties and couplings.
187   double thetaWRat, alpEM;
188  
189   // Initialize constants.
190   virtual void initConstants(); 
191  
192   // Calculate various common prefactors for the current mass.
193   virtual void calcPreFac(bool = false);
194
195   // Caclulate width for currently considered channel.
196   virtual void calcWidth(bool = false);
197
198 };
199   
200 //**************************************************************************
201
202 // The ResonanceTop class handles the top/antitop resonance.
203
204 class ResonanceTop : public ResonanceWidths {
205
206 public:
207
208   // Constructor. 
209   ResonanceTop(int idResIn) {initBasic(idResIn);} 
210  
211 private: 
212
213   // Locally stored properties and couplings.
214   double thetaWRat, m2W;
215  
216   // Initialize constants.
217   virtual void initConstants(); 
218  
219   // Calculate various common prefactors for the current mass.
220   virtual void calcPreFac(bool = false);
221
222   // Caclulate width for currently considered channel.
223   virtual void calcWidth(bool = false);
224
225 };
226   
227 //**************************************************************************
228
229 // The ResonanceFour class handles fourth-generation resonances.
230
231 class ResonanceFour : public ResonanceWidths {
232
233 public:
234
235   // Constructor. 
236   ResonanceFour(int idResIn) {initBasic(idResIn);} 
237  
238 private: 
239
240   // Locally stored properties and couplings.
241   double thetaWRat, m2W;
242  
243   // Initialize constants.
244   virtual void initConstants(); 
245  
246   // Calculate various common prefactors for the current mass.
247   virtual void calcPreFac(bool = false);
248
249   // Caclulate width for currently considered channel.
250   virtual void calcWidth(bool = false);
251
252 };
253   
254 //**************************************************************************
255
256 // The ResonanceH class handles the SM and BSM Higgs resonance.
257 // higgsType = 0 : SM H; = 1: h^0/H_1; = 2 : H^0/H_2; = 3 : A^0/A_3.
258
259 class ResonanceH : public ResonanceWidths {
260
261 public:
262
263   // Constructor. 
264   ResonanceH(int higgsTypeIn, int idResIn) : higgsType(higgsTypeIn)
265     {initBasic(idResIn);} 
266
267 private: 
268
269   // Constants: could only be changed in the code itself.
270   static const double MASSMIN, GAMMAMARGIN;
271
272   // Higgs type in current instance.
273   int    higgsType;
274
275   // Locally stored properties and couplings.
276   bool   useCubicWidth, useRunLoopMass; 
277   double sin2tW, cos2tW, mT, mZ, mW, mHchg, GammaT, GammaZ, GammaW,
278          coup2d, coup2u, coup2l, coup2Z, coup2W, coup2Hchg, coup2H1H1, 
279          coup2A3A3, coup2H1Z, coup2A3Z, coup2A3H1, coup2HchgW,
280          kinFacT[101], kinFacZ[101], kinFacW[101];
281  
282   // Initialize constants.
283   virtual void initConstants(); 
284  
285   // Calculate various common prefactors for the current mass.
286   virtual void calcPreFac(bool = false);
287
288   // Caclulate width for currently considered channel.
289   virtual void calcWidth(bool = false);
290
291   // Sum up loop contributions in Higgs -> g + g.
292   double eta2gg();
293
294   // Sum up loop contributions in Higgs -> gamma + gamma.
295   double eta2gaga();
296
297   // Sum up loop contributions in Higgs -> gamma + Z0.
298   double eta2gaZ();
299
300 };
301   
302 //**************************************************************************
303
304 // The ResonanceHchg class handles the H+- resonance.
305
306 class ResonanceHchg : public ResonanceWidths {
307
308 public:
309
310   // Constructor. 
311   ResonanceHchg(int idResIn) {initBasic(idResIn);} 
312
313 private: 
314
315   // Locally stored properties and couplings.
316   bool   useCubicWidth; 
317   double thetaWRat, mW, tanBeta, tan2Beta, coup2H1W;
318  
319   // Initialize constants.
320   virtual void initConstants(); 
321  
322   // Calculate various common prefactors for the current mass.
323   virtual void calcPreFac(bool = false);
324
325   // Caclulate width for currently considered channel.
326   virtual void calcWidth(bool = false);
327
328 };
329   
330 //**************************************************************************
331
332 // The ResonanceZprime class handles the gamma*/Z0 /Z'^0 resonance.
333
334 class ResonanceZprime : public ResonanceWidths {
335
336 public:
337
338   // Constructor. 
339   ResonanceZprime(int idResIn) {initBasic(idResIn);} 
340
341 private: 
342
343   // Locally stored properties and couplings.
344   int    gmZmode;
345   double sin2tW, cos2tW, thetaWRat, mZ, GammaZ, m2Z, GamMRatZ, afZp[20], 
346          vfZp[20], coupZpWW, ei2, eivi, vai2, eivpi, vaivapi, vapi2,
347          gamNorm, gamZNorm, ZNorm, gamZpNorm, ZZpNorm, ZpNorm;
348  
349   // Initialize constants.
350   virtual void initConstants(); 
351  
352   // Calculate various common prefactors for the current mass.
353   virtual void calcPreFac(bool = false);
354
355   // Caclulate width for currently considered channel.
356   virtual void calcWidth(bool calledFromInit = false);
357
358 };
359   
360 //**************************************************************************
361
362 // The ResonanceWprime class handles the W'+- resonance.
363
364 class ResonanceWprime : public ResonanceWidths {
365
366 public:
367
368   // Constructor. 
369   ResonanceWprime(int idResIn) {initBasic(idResIn);} 
370
371 private: 
372
373   // Locally stored properties and couplings.
374   double thetaWRat, cos2tW, alpEM, aqWp, vqWp, alWp, vlWp, coupWpWZ;
375  
376   // Initialize constants.
377   virtual void initConstants(); 
378  
379   // Calculate various common prefactors for the current mass.
380   virtual void calcPreFac(bool = false);
381
382   // Caclulate width for currently considered channel.
383   virtual void calcWidth(bool = false);
384
385 };
386   
387 //**************************************************************************
388
389 // The ResonanceRhorizontal class handles the R^0 resonance.
390
391 class ResonanceRhorizontal : public ResonanceWidths {
392
393 public:
394
395   // Constructor. 
396   ResonanceRhorizontal(int idResIn) {initBasic(idResIn);} 
397
398 private: 
399
400   // Locally stored properties and couplings.
401   double thetaWRat;
402  
403   // Initialize constants.
404   virtual void initConstants(); 
405  
406   // Calculate various common prefactors for the current mass.
407   virtual void calcPreFac(bool = false);
408
409   // Caclulate width for currently considered channel.
410   virtual void calcWidth(bool = false);
411
412 };
413    
414 //**************************************************************************
415
416 // The ResonanceExcited class handles excited-fermion resonances.
417
418 class ResonanceExcited : public ResonanceWidths {
419
420 public:
421
422   // Constructor. 
423   ResonanceExcited(int idResIn) {initBasic(idResIn);} 
424
425 private: 
426
427   // Locally stored properties and couplings.
428   double Lambda, coupF, coupFprime, coupFcol, sin2tW, cos2tW;
429  
430   // Initialize constants.
431   virtual void initConstants(); 
432  
433   // Calculate various common prefactors for the current mass.
434   virtual void calcPreFac(bool = false);
435
436   // Caclulate width for currently considered channel.
437   virtual void calcWidth(bool = false);
438
439 };
440   
441 //**************************************************************************
442
443 // The ResonanceGraviton class handles the excited Graviton resonance.
444
445 class ResonanceGraviton : public ResonanceWidths {
446
447 public:
448
449   // Constructor. 
450   ResonanceGraviton(int idResIn) {initBasic(idResIn);} 
451  
452 private: 
453
454   // Locally stored properties and couplings.
455   double kappaMG;
456  
457   // Initialize constants.
458   virtual void initConstants(); 
459  
460   // Calculate various common prefactors for the current mass.
461   virtual void calcPreFac(bool = false);
462
463   // Caclulate width for currently considered channel.
464   virtual void calcWidth(bool = false);
465
466 };
467
468 //**************************************************************************
469
470 // The ResonanceLeptoquark class handles the LQ/LQbar resonance.
471
472 class ResonanceLeptoquark : public ResonanceWidths {
473
474 public:
475
476   // Constructor. 
477   ResonanceLeptoquark(int idResIn) {initBasic(idResIn);} 
478
479 private: 
480
481   // Locally stored properties and couplings.
482   double kCoup;
483  
484   // Initialize constants.
485   virtual void initConstants(); 
486  
487   // Calculate various common prefactors for the current mass.
488   virtual void calcPreFac(bool = false);
489
490   // Caclulate width for currently considered channel.
491   virtual void calcWidth(bool = false);
492
493 };
494
495 //**************************************************************************
496
497 // The ResonanceNuRight class handles righthanded Majorana neutrinos.
498
499 class ResonanceNuRight : public ResonanceWidths {
500
501 public:
502
503   // Constructor. 
504   ResonanceNuRight(int idResIn) {initBasic(idResIn);} 
505
506 private: 
507
508   // Locally stored properties and couplings.
509   double thetaWRat, mWR;
510  
511   // Initialize constants.
512   virtual void initConstants(); 
513  
514   // Calculate various common prefactors for the current mass.
515   virtual void calcPreFac(bool = false);
516
517   // Caclulate width for currently considered channel.
518   virtual void calcWidth(bool = false);
519
520 };
521   
522 //**************************************************************************
523
524 // The ResonanceZRight class handles the Z_R^0 resonance.
525
526 class ResonanceZRight : public ResonanceWidths {
527
528 public:
529
530   // Constructor. 
531   ResonanceZRight(int idResIn) {initBasic(idResIn);} 
532
533 private: 
534
535   // Locally stored properties and couplings.
536   double sin2tW, thetaWRat;
537  
538   // Initialize constants.
539   virtual void initConstants(); 
540  
541   // Calculate various common prefactors for the current mass.
542   virtual void calcPreFac(bool = false);
543
544   // Caclulate width for currently considered channel.
545   virtual void calcWidth(bool = false);
546
547 };
548   
549 //**************************************************************************
550
551 // The ResonanceWRight class handles the W_R+- resonance.
552
553 class ResonanceWRight : public ResonanceWidths {
554
555 public:
556
557   // Constructor. 
558   ResonanceWRight(int idResIn) {initBasic(idResIn);} 
559   
560 private: 
561
562   // Locally stored properties and couplings.
563   double thetaWRat;
564  
565   // Initialize constants.
566   virtual void initConstants(); 
567  
568   // Calculate various common prefactors for the current mass.
569   virtual void calcPreFac(bool = false);
570
571   // Caclulate width for currently considered channel.
572   virtual void calcWidth(bool = false);
573
574 };
575   
576 //**************************************************************************
577
578 // The ResonanceHchgchgLeft class handles the H++/H-- (left) resonance.
579
580 class ResonanceHchgchgLeft : public ResonanceWidths {
581
582 public:
583
584   // Constructor. 
585   ResonanceHchgchgLeft(int idResIn) {initBasic(idResIn);} 
586  
587 private: 
588
589   // Locally stored properties and couplings.
590   double yukawa[4][4], gL, vL, mW;
591  
592   // Initialize constants.
593   virtual void initConstants(); 
594  
595   // Calculate various common prefactors for the current mass.
596   virtual void calcPreFac(bool = false);
597
598   // Caclulate width for currently considered channel.
599   virtual void calcWidth(bool = false);
600
601 };
602    
603 //**************************************************************************
604
605 // The ResonanceHchgchgRight class handles the H++/H-- (right) resonance.
606
607 class ResonanceHchgchgRight : public ResonanceWidths {
608
609 public:
610
611   // Constructor. 
612   ResonanceHchgchgRight(int idResIn) {initBasic(idResIn);} 
613  
614 private: 
615
616   // Locally stored properties and couplings.
617   int    idWR;
618   double yukawa[4][4], gR;
619  
620   // Initialize constants.
621   virtual void initConstants(); 
622  
623   // Calculate various common prefactors for the current mass.
624   virtual void calcPreFac(bool = false);
625
626   // Caclulate width for currently considered channel.
627   virtual void calcWidth(bool = false);
628
629 };
630   
631 //**************************************************************************
632
633 } // end namespace Pythia8
634
635 #endif // Pythia8_ResonanceWidths_H