StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
SigmaHiggs.h
1 // SigmaHiggs.h is a part of the PYTHIA event generator.
2 // Copyright (C) 2020 Torbjorn Sjostrand.
3 // Part of code written by Marc Montull, CERN summer student 2007.
4 // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
5 // Please respect the MCnet Guidelines, see GUIDELINES for details.
6 
7 // Header file for Higgs process differential cross sections.
8 // Contains classes derived from SigmaProcess via Sigma2Process.
9 
10 #ifndef Pythia8_SigmaHiggs_H
11 #define Pythia8_SigmaHiggs_H
12 
13 #include "Pythia8/SigmaProcess.h"
14 
15 namespace Pythia8 {
16 
17 //==========================================================================
18 
19 // A derived class for f fbar -> H0 (SM), H1, H2 or A3 (BSM).
20 
21 class Sigma1ffbar2H : public Sigma1Process {
22 
23 public:
24 
25  // Constructor.
26  Sigma1ffbar2H(int higgsTypeIn) : HResPtr(), mRes(), GammaRes(), m2Res(),
27  GamMRat(), sigBW(), widthOut(), higgsType(higgsTypeIn), codeSave(),
28  idRes() {}
29 
30  // Initialize process.
31  virtual void initProc();
32 
33  // Calculate flavour-independent parts of cross section.
34  virtual void sigmaKin();
35 
36  // Evaluate sigmaHat(sHat).
37  virtual double sigmaHat();
38 
39  // Select flavour, colour and anticolour.
40  virtual void setIdColAcol();
41 
42  // Evaluate weight for decay angles.
43  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
44 
45  // Info on the subprocess.
46  virtual string name() const {return nameSave;}
47  virtual int code() const {return codeSave;}
48  virtual string inFlux() const {return "ffbarSame";}
49  virtual int resonanceA() const {return idRes;}
50 
51 private:
52 
53  // An H0, H1, H2 or A3 resonance object provides coupling
54  // and propagator expressions.
55  ParticleDataEntry* HResPtr;
56  double mRes, GammaRes, m2Res, GamMRat, sigBW, widthOut;
57  int higgsType, codeSave, idRes;
58  string nameSave;
59 };
60 
61 //==========================================================================
62 
63 // A derived class for g g -> H0 (SM), H1, H2 or A3 (BSM).
64 
65 class Sigma1gg2H : public Sigma1Process {
66 
67 public:
68 
69  // Constructor.
70  Sigma1gg2H(int higgsTypeIn) : HResPtr(), mRes(), GammaRes(), m2Res(),
71  GamMRat(), sigma(), higgsType(higgsTypeIn), codeSave(), idRes() {}
72 
73  // Initialize process.
74  virtual void initProc();
75 
76  // Calculate flavour-independent parts of cross section.
77  virtual void sigmaKin();
78 
79  // Evaluate sigmaHat(sHat).
80  virtual double sigmaHat() {return sigma;}
81 
82  // Select flavour, colour and anticolour.
83  virtual void setIdColAcol();
84 
85  // Evaluate weight for decay angles.
86  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
87 
88  // Info on the subprocess.
89  virtual string name() const {return nameSave ;}
90  virtual int code() const {return codeSave;}
91  virtual string inFlux() const {return "gg";}
92  virtual int resonanceA() const {return idRes;}
93 
94 private:
95 
96  // A H0, H1, H2 or A3 resonance object provides coupling
97  // and propagator expressions.
98  ParticleDataEntry* HResPtr;
99  double mRes, GammaRes, m2Res, GamMRat, sigma;
100  int higgsType, codeSave, idRes;
101  string nameSave;
102 };
103 
104 //==========================================================================
105 
106 // A derived class for gamma gamma -> H0 (SM Higgs), H1, H2 or A3 (BSM Higgs).
107 
108 class Sigma1gmgm2H : public Sigma1Process {
109 
110 public:
111 
112  // Constructor.
113  Sigma1gmgm2H(int higgsTypeIn) : HResPtr(), mRes(), GammaRes(), m2Res(),
114  GamMRat(), sigma(), higgsType(higgsTypeIn), codeSave(), idRes() {}
115 
116  // Initialize process.
117  virtual void initProc();
118 
119  // Calculate flavour-independent parts of cross section.
120  virtual void sigmaKin();
121 
122  // Evaluate sigmaHat(sHat).
123  virtual double sigmaHat() {return sigma;}
124 
125  // Select flavour, colour and anticolour.
126  virtual void setIdColAcol();
127 
128  // Evaluate weight for decay angles.
129  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
130 
131  // Info on the subprocess.
132  virtual string name() const {return nameSave;}
133  virtual int code() const {return codeSave;}
134  virtual string inFlux() const {return "gmgm";}
135  virtual int resonanceA() const {return idRes;}
136 
137 private:
138 
139  // A H0, H1, H2 or A3 resonance object provides coupling
140  // and propagator expressions.
141  ParticleDataEntry* HResPtr;
142  double mRes, GammaRes, m2Res, GamMRat, sigma;
143  int higgsType, codeSave, idRes;
144  string nameSave;
145 };
146 
147 //==========================================================================
148 
149 // A derived class for f fbar -> H Z0.
150 // (H can be H0 SM or H1, H2, A3 from BSM).
151 class Sigma2ffbar2HZ : public Sigma2Process {
152 
153 public:
154 
155  // Constructor.
156  Sigma2ffbar2HZ(int higgsTypeIn) : mZ(), widZ(), mZS(), mwZS(), thetaWRat(),
157  sigma0(), openFracPair(), coup2Z(), higgsType(higgsTypeIn), codeSave(),
158  idRes() {}
159 
160  // Initialize process.
161  virtual void initProc();
162 
163  // Calculate flavour-independent parts of cross section.
164  virtual void sigmaKin();
165 
166  // Evaluate d(sigmaHat)/d(tHat).
167  virtual double sigmaHat();
168 
169  // Select flavour, colour and anticolour.
170  virtual void setIdColAcol();
171 
172  // Evaluate weight for decay angles.
173  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
174 
175  // Info on the subprocess.
176  virtual string name() const {return nameSave;}
177  virtual int code() const {return codeSave;}
178  virtual string inFlux() const {return "ffbarSame";}
179  virtual bool isSChannel() const {return true;}
180  virtual int id3Mass() const {return idRes;}
181  virtual int id4Mass() const {return 23;}
182  virtual int resonanceA() const {return 23;}
183  virtual int gmZmode() const {return 2;}
184 
185 private:
186 
187  // Store Z0 mass and width.
188  double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, openFracPair, coup2Z;
189  int higgsType, codeSave, idRes;
190  string nameSave;
191 };
192 
193 //==========================================================================
194 
195 // A derived class for f fbar -> H W+- (Standard Model Higgs).
196 // (H can be H0 SM or H1, H2, A3 from BSM).
197 
198 class Sigma2ffbar2HW : public Sigma2Process {
199 
200 public:
201 
202  // Constructor.
203  Sigma2ffbar2HW(int higgsTypeIn) : mW(), widW(), mWS(), mwWS(), thetaWRat(),
204  sigma0(), openFracPairPos(), openFracPairNeg(), coup2W(),
205  higgsType(higgsTypeIn), codeSave(), idRes() {}
206 
207  // Initialize process.
208  virtual void initProc();
209 
210  // Calculate flavour-independent parts of cross section.
211  virtual void sigmaKin();
212 
213  // Evaluate d(sigmaHat)/d(tHat).
214  virtual double sigmaHat();
215 
216  // Select flavour, colour and anticolour.
217  virtual void setIdColAcol();
218 
219  // Evaluate weight for decay angles.
220  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
221 
222  // Info on the subprocess.
223  virtual string name() const {return nameSave;}
224  virtual int code() const {return codeSave;}
225  virtual string inFlux() const {return "ffbarChg";}
226  virtual bool isSChannel() const {return true;}
227  virtual int id3Mass() const {return idRes;}
228  virtual int id4Mass() const {return 24;}
229  virtual int resonanceA() const {return 24;}
230 
231 private:
232 
233  // Store W+- mass and width, and couplings.
234  double mW, widW, mWS, mwWS, thetaWRat, sigma0, openFracPairPos,
235  openFracPairNeg, coup2W;
236  int higgsType, codeSave, idRes;
237  string nameSave;
238 };
239 
240 //==========================================================================
241 
242 // A derived class for f f' -> H f f' (Z0 Z0 fusion of SM or BSM Higgs).
243 // (H can be H0 SM or H1, H2, A3 from BSM).
244 
245 class Sigma3ff2HfftZZ : public Sigma3Process {
246 
247 public:
248 
249  // Constructor.
250  Sigma3ff2HfftZZ(int higgsTypeIn) : mZS(), prefac(), sigma1(), sigma2(),
251  openFrac(), coup2Z(), higgsType(higgsTypeIn), codeSave(), idRes() {}
252 
253  // Initialize process.
254  virtual void initProc();
255 
256  // Calculate flavour-independent parts of cross section.
257  virtual void sigmaKin();
258 
259  // Evaluate sigmaHat(sHat).
260  virtual double sigmaHat();
261 
262  // Select flavour, colour and anticolour.
263  virtual void setIdColAcol();
264 
265  // Evaluate weight for decay angles.
266  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
267 
268  // Info on the subprocess.
269  virtual string name() const {return nameSave;}
270  virtual int code() const {return codeSave;}
271  virtual string inFlux() const {return "ff";}
272  virtual int id3Mass() const {return idRes;}
273 
274  // Instructions for 3-body phase space with t-channel propagators.
275  virtual int idTchan1() const {return 23;}
276  virtual int idTchan2() const {return 23;}
277  virtual double tChanFracPow1() const {return 0.05;}
278  virtual double tChanFracPow2() const {return 0.9;}
279  virtual bool useMirrorWeight() const {return true;}
280 
281 private:
282 
283  // Store standard factors.
284  double mZS, prefac, sigma1, sigma2, openFrac, coup2Z;
285  int higgsType, codeSave, idRes;
286  string nameSave;
287 };
288 
289 //==========================================================================
290 
291 // A derived class for f_1 f_2 -> H f_3 f_4 (W+ W- fusion of SM or BSM Higgs).
292 // (H can be H0 SM or H1, H2, A3 from BSM).
293 
294 class Sigma3ff2HfftWW : public Sigma3Process {
295 
296 public:
297 
298  // Constructor.
299  Sigma3ff2HfftWW(int higgsTypeIn) : mWS(), prefac(), sigma0(), openFrac(),
300  coup2W(), higgsType(higgsTypeIn), codeSave(), idRes() {}
301 
302  // Initialize process.
303  virtual void initProc();
304 
305  // Calculate flavour-independent parts of cross section.
306  virtual void sigmaKin();
307 
308  // Evaluate sigmaHat(sHat).
309  virtual double sigmaHat();
310 
311  // Select flavour, colour and anticolour.
312  virtual void setIdColAcol();
313 
314  // Evaluate weight for decay angles.
315  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
316 
317  // Info on the subprocess.
318  virtual string name() const {return nameSave;}
319  virtual int code() const {return codeSave;}
320  virtual string inFlux() const {return "ff";}
321  virtual int id3Mass() const {return idRes;}
322 
323  // Instructions for 3-body phase space with t-channel propagators.
324  virtual int idTchan1() const {return 24;}
325  virtual int idTchan2() const {return 24;}
326  virtual double tChanFracPow1() const {return 0.05;}
327  virtual double tChanFracPow2() const {return 0.9;}
328  virtual bool useMirrorWeight() const {return true;}
329 
330 private:
331 
332  // Store standard prefactor.
333  double mWS, prefac, sigma0, openFrac, coup2W;
334  int higgsType, codeSave, idRes;
335  string nameSave;
336 };
337 
338 //==========================================================================
339 
340 // A derived class for g g -> H Q Qbar (Q Qbar fusion of SM or BSM Higgs).
341 // (H can be H0 SM or H1, H2, A3 from BSM).
342 
343 class Sigma3gg2HQQbar : public Sigma3Process {
344 
345 public:
346 
347  // Constructor.
348  Sigma3gg2HQQbar(int idIn, int higgsTypeIn) : prefac(), sigma(),
349  openFracTriplet(), coup2Q(), idNew(idIn), higgsType(higgsTypeIn),
350  codeSave(), idRes() {}
351 
352  // Initialize process.
353  virtual void initProc();
354 
355  // Calculate flavour-independent parts of cross section.
356  virtual void sigmaKin();
357 
358  // Evaluate sigmaHat(sHat).
359  virtual double sigmaHat() {return sigma;}
360 
361  // Select flavour, colour and anticolour.
362  virtual void setIdColAcol();
363 
364  // Evaluate weight for decay angles.
365  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
366 
367  // Info on the subprocess.
368  virtual string name() const {return nameSave;}
369  virtual int code() const {return codeSave;}
370  virtual string inFlux() const {return "gg";}
371  virtual int id3Mass() const {return idRes;}
372  virtual int id4Mass() const {return idNew;}
373  virtual int id5Mass() const {return idNew;}
374 
375  // Instructions for 3-body phase space with t-channel propagators.
376  virtual int idTchan1() const {return idNew;}
377  virtual int idTchan2() const {return idNew;}
378  virtual double tChanFracPow1() const {return 0.4;}
379  virtual double tChanFracPow2() const {return 0.2;}
380  virtual bool useMirrorWeight() const {return false;}
381 
382 private:
383 
384  // Store flavour-specific process information and standard prefactor.
385  double prefac, sigma, openFracTriplet, coup2Q;
386  int idNew, higgsType, codeSave, idRes;
387  string nameSave;
388 
389 };
390 
391 //==========================================================================
392 
393 // A derived class for q qbar -> H Q Qbar (Q Qbar fusion of SM or BSM Higgs).
394 // (H can be H0 SM or H1, H2, A3 from BSM).
395 
396 class Sigma3qqbar2HQQbar : public Sigma3Process {
397 
398 public:
399 
400  // Constructor.
401  Sigma3qqbar2HQQbar(int idIn, int higgsTypeIn) : prefac(), sigma(),
402  openFracTriplet(), coup2Q(), idNew(idIn), higgsType(higgsTypeIn),
403  codeSave(), idRes() {}
404 
405  // Initialize process.
406  virtual void initProc();
407 
408  // Calculate flavour-independent parts of cross section.
409  virtual void sigmaKin();
410 
411  // Evaluate sigmaHat(sHat).
412  virtual double sigmaHat() {return sigma;}
413 
414  // Select flavour, colour and anticolour.
415  virtual void setIdColAcol();
416 
417  // Evaluate weight for decay angles.
418  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
419 
420  // Info on the subprocess.
421  virtual string name() const {return nameSave;}
422  virtual int code() const {return codeSave;}
423  virtual string inFlux() const {return "qqbarSame";}
424  virtual int id3Mass() const {return idRes;}
425  virtual int id4Mass() const {return idNew;}
426  virtual int id5Mass() const {return idNew;}
427 
428  // Instructions for 3-body phase space with t-channel propagators.
429  virtual int idTchan1() const {return idNew;}
430  virtual int idTchan2() const {return idNew;}
431  virtual double tChanFracPow1() const {return 0.4;}
432  virtual double tChanFracPow2() const {return 0.2;}
433  virtual bool useMirrorWeight() const {return false;}
434 
435 private:
436 
437  // Store flavour-specific process information and standard prefactor.
438  double prefac, sigma, openFracTriplet, coup2Q;
439  int idNew, higgsType, codeSave, idRes;
440  string nameSave;
441 
442 };
443 
444 //==========================================================================
445 
446 // A derived class for q g -> H q (SM or BSM Higgs).
447 // (H can be H0 SM or H1, H2, A3 from BSM).
448 
449 class Sigma2qg2Hq : public Sigma2Process {
450 
451 public:
452 
453  // Constructor.
454  Sigma2qg2Hq(int idIn, int higgsTypeIn) : m2W(), thetaWRat(), sigma(),
455  openFrac(), idNew(idIn), higgsType(higgsTypeIn), codeSave(), idRes() {}
456 
457  // Initialize process.
458  virtual void initProc();
459 
460  // Calculate flavour-independent parts of cross section.
461  virtual void sigmaKin();
462 
463  // Evaluate sigmaHat(sHat).
464  virtual double sigmaHat();
465 
466  // Select flavour, colour and anticolour.
467  virtual void setIdColAcol();
468 
469  // Evaluate weight for decay angles.
470  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
471 
472  // Info on the subprocess.
473  virtual string name() const {return nameSave;}
474  virtual int code() const {return codeSave;}
475  virtual string inFlux() const {return "qg";}
476  virtual int id3Mass() const {return idRes;}
477  virtual int id4Mass() const {return idNew;}
478 
479 private:
480 
481  // Store flavour-specific process information and standard prefactor.
482  double m2W, thetaWRat, sigma, openFrac;
483  int idNew, higgsType, codeSave, idRes;
484  string nameSave;
485 
486 };
487 
488 //==========================================================================
489 
490 // A derived class for g g -> H0 g (SM or BSM Higgs via heavy top loop).
491 // (H can be H0 SM or H1, H2, A3 from BSM).
492 
493 class Sigma2gg2Hglt : public Sigma2Process {
494 
495 public:
496 
497  // Constructor.
498  Sigma2gg2Hglt(int higgsTypeIn) : widHgg(), sigma(), openFrac(),
499  higgsType(higgsTypeIn), codeSave(), idRes() {}
500 
501  // Initialize process.
502  virtual void initProc();
503 
504  // Calculate flavour-independent parts of cross section.
505  virtual void sigmaKin();
506 
507  // Evaluate d(sigmaHat)/d(tHat).
508  virtual double sigmaHat() {return sigma;}
509 
510  // Select flavour, colour and anticolour.
511  virtual void setIdColAcol();
512 
513  // Evaluate weight for decay angles.
514  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
515 
516  // Info on the subprocess.
517  virtual string name() const {return nameSave;}
518  virtual int code() const {return codeSave;}
519  virtual string inFlux() const {return "gg";}
520  virtual int id3Mass() const {return idRes;}
521 
522 private:
523 
524  // Store standard prefactor.
525  double widHgg, sigma, openFrac;
526  int higgsType, codeSave, idRes;
527  string nameSave;
528 };
529 
530 //==========================================================================
531 
532 // A derived class for q g -> H q (SM or BSM Higgs via heavy top loop).
533 // (H can be H0 SM or H1, H2, A3 from BSM).
534 
535 class Sigma2qg2Hqlt : public Sigma2Process {
536 
537 public:
538 
539  // Constructor.
540  Sigma2qg2Hqlt(int higgsTypeIn) : widHgg(), sigma(), openFrac(),
541  higgsType(higgsTypeIn), codeSave(), idRes() {}
542 
543  // Initialize process.
544  virtual void initProc();
545 
546  // Calculate flavour-independent parts of cross section.
547  virtual void sigmaKin();
548 
549  // Evaluate d(sigmaHat)/d(tHat).
550  virtual double sigmaHat() {return sigma;}
551 
552  // Select flavour, colour and anticolour.
553  virtual void setIdColAcol();
554 
555  // Evaluate weight for decay angles.
556  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
557 
558  // Info on the subprocess.
559  virtual string name() const {return nameSave;}
560  virtual int code() const {return codeSave;}
561  virtual string inFlux() const {return "qg";}
562  virtual int id3Mass() const {return idRes;}
563 
564 private:
565 
566  // Store standard prefactor.
567  double widHgg, sigma, openFrac;
568  int higgsType, codeSave, idRes;
569  string nameSave;
570 };
571 
572 //==========================================================================
573 
574 // A derived class for q qbar -> H g (SM or BSM Higgs via heavy top loop).
575 // (H can be H0 SM or H1, H2, A3 from BSM).
576 
577 class Sigma2qqbar2Hglt : public Sigma2Process {
578 
579 public:
580 
581  // Constructor.
582  Sigma2qqbar2Hglt(int higgsTypeIn) : widHgg(), sigma(), openFrac(),
583  higgsType(higgsTypeIn), codeSave(), idRes() {}
584 
585  // Initialize process.
586  virtual void initProc();
587 
588  // Calculate flavour-independent parts of cross section.
589  virtual void sigmaKin();
590 
591  // Evaluate d(sigmaHat)/d(tHat).
592  virtual double sigmaHat() {return sigma;}
593 
594  // Select flavour, colour and anticolour.
595  virtual void setIdColAcol();
596 
597  // Evaluate weight for decay angles.
598  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
599 
600  // Info on the subprocess.
601  virtual string name() const {return nameSave;}
602  virtual int code() const {return codeSave;}
603  virtual string inFlux() const {return "qqbarSame";}
604  virtual int id3Mass() const {return idRes;}
605 
606 private:
607 
608  // Store standard prefactor.
609  double widHgg, sigma, openFrac;
610  int higgsType, codeSave, idRes;
611  string nameSave;
612 };
613 
614 //==========================================================================
615 
616 // A derived class for f fbar' -> H+-.
617 
618 class Sigma1ffbar2Hchg : public Sigma1Process {
619 
620 public:
621 
622  // Constructor.
623  Sigma1ffbar2Hchg() : HResPtr(), mRes(), GammaRes(), m2Res(), GamMRat(),
624  m2W(), thetaWRat(), tan2Beta(), sigBW(), widthOutPos(), widthOutNeg() {}
625 
626  // Initialize process.
627  virtual void initProc();
628 
629  // Calculate flavour-independent parts of cross section.
630  virtual void sigmaKin();
631 
632  // Evaluate sigmaHat(sHat).
633  virtual double sigmaHat();
634 
635  // Select flavour, colour and anticolour.
636  virtual void setIdColAcol();
637 
638  // Evaluate weight for decay angles.
639  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
640 
641  // Info on the subprocess.
642  virtual string name() const {return "f fbar' -> H+-";}
643  virtual int code() const {return 1061;}
644  virtual string inFlux() const {return "ffbarChg";}
645  virtual int resonanceA() const {return 37;}
646 
647 private:
648 
649  // A H0 resonance object provides coupling and propagator expressions.
650  ParticleDataEntry* HResPtr;
651  double mRes, GammaRes, m2Res, GamMRat, m2W, thetaWRat, tan2Beta, sigBW,
652  widthOutPos, widthOutNeg;
653 
654 };
655 
656 //==========================================================================
657 
658 // A derived class for q g -> H+- q'.
659 
660 class Sigma2qg2Hchgq : public Sigma2Process {
661 
662 public:
663 
664  // Constructor.
665  Sigma2qg2Hchgq(int idIn, int codeIn, string nameIn) : idNew(idIn),
666  codeSave(codeIn), idOld(), idUp(), idDn(), nameSave(nameIn), m2W(),
667  thetaWRat(), tan2Beta(), sigma(), openFracPos(), openFracNeg() {}
668 
669  // Initialize process.
670  virtual void initProc();
671 
672  // Calculate flavour-independent parts of cross section.
673  virtual void sigmaKin();
674 
675  // Evaluate sigmaHat(sHat).
676  virtual double sigmaHat();
677 
678  // Select flavour, colour and anticolour.
679  virtual void setIdColAcol();
680 
681  // Evaluate weight for decay angles.
682  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
683 
684  // Info on the subprocess.
685  virtual string name() const {return nameSave;}
686  virtual int code() const {return codeSave;}
687  virtual string inFlux() const {return "qg";}
688  virtual int id3Mass() const {return 37;}
689  virtual int id4Mass() const {return idNew;}
690 
691 private:
692 
693  // Store flavour-specific process information and standard prefactor.
694  int idNew, codeSave, idOld, idUp, idDn;
695  string nameSave;
696  double m2W, thetaWRat, tan2Beta, sigma, openFracPos, openFracNeg;
697 
698 };
699 
700 //==========================================================================
701 
702 // A derived class for f fbar -> A0(H_3) h0(H_1) or A0(H_3) H0(H_2).
703 
704 class Sigma2ffbar2A3H12 : public Sigma2Process {
705 
706 public:
707 
708  // Constructor.
709  Sigma2ffbar2A3H12(int higgsTypeIn) : higgsType(higgsTypeIn), higgs12(),
710  codeSave(), coupZA3H12(), m2Z(), mGammaZ(), thetaWRat(), openFrac(),
711  sigma0() {}
712 
713  // Initialize process.
714  virtual void initProc();
715 
716  // Calculate flavour-independent parts of cross section.
717  virtual void sigmaKin();
718 
719  // Evaluate sigmaHat(sHat).
720  virtual double sigmaHat();
721 
722  // Select flavour, colour and anticolour.
723  virtual void setIdColAcol();
724 
725  // Evaluate weight for decay angles.
726  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
727 
728  // Info on the subprocess.
729  virtual string name() const {return nameSave;}
730  virtual int code() const {return codeSave;}
731  virtual string inFlux() const {return "ffbarSame";}
732  virtual int id3Mass() const {return 36;}
733  virtual int id4Mass() const {return higgs12;}
734 
735 private:
736 
737  // Store flavour-specific process information and standard prefactor.
738  int higgsType, higgs12, codeSave;
739  string nameSave;
740  double coupZA3H12, m2Z, mGammaZ, thetaWRat, openFrac, sigma0;
741 
742 };
743 
744 //==========================================================================
745 
746 // A derived class for f fbar -> H+- h0(H_1) or H+- H0(H_2).
747 
748 class Sigma2ffbar2HchgH12 : public Sigma2Process {
749 
750 public:
751 
752  // Constructor.
753  Sigma2ffbar2HchgH12(int higgsTypeIn) : higgsType(higgsTypeIn), higgs12(),
754  codeSave(), coupWHchgH12(), m2W(), mGammaW(), thetaWRat(), openFracPos(),
755  openFracNeg(), sigma0() {}
756 
757  // Initialize process.
758  virtual void initProc();
759 
760  // Calculate flavour-independent parts of cross section.
761  virtual void sigmaKin();
762 
763  // Evaluate sigmaHat(sHat).
764  virtual double sigmaHat();
765 
766  // Select flavour, colour and anticolour.
767  virtual void setIdColAcol();
768 
769  // Evaluate weight for decay angles.
770  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
771 
772  // Info on the subprocess.
773  virtual string name() const {return nameSave;}
774  virtual int code() const {return codeSave;}
775  virtual string inFlux() const {return "ffbarChg";}
776  virtual int id3Mass() const {return 37;}
777  virtual int id4Mass() const {return higgs12;}
778 
779 private:
780 
781  // Store flavour-specific process information and standard prefactor.
782  int higgsType, higgs12, codeSave;
783  string nameSave;
784  double coupWHchgH12, m2W, mGammaW, thetaWRat, openFracPos, openFracNeg,
785  sigma0;
786 
787 };
788 
789 //==========================================================================
790 
791 // A derived class for f fbar -> H+ H-.
792 
793 class Sigma2ffbar2HposHneg : public Sigma2Process {
794 
795 public:
796 
797  // Constructor.
798  Sigma2ffbar2HposHneg() : m2Z(), mGammaZ(), thetaWRat(), eH(), lH(),
799  openFrac(), gamSig(), intSig(), resSig() {}
800 
801  // Initialize process.
802  virtual void initProc();
803 
804  // Calculate flavour-independent parts of cross section.
805  virtual void sigmaKin();
806 
807  // Evaluate sigmaHat(sHat).
808  virtual double sigmaHat();
809 
810  // Select flavour, colour and anticolour.
811  virtual void setIdColAcol();
812 
813  // Evaluate weight for decay angles.
814  virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
815 
816  // Info on the subprocess.
817  virtual string name() const {return "f fbar -> H+ H-";}
818  virtual int code() const {return 1085;}
819  virtual string inFlux() const {return "ffbarSame";}
820  virtual int id3Mass() const {return 37;}
821  virtual int id4Mass() const {return 37;}
822 
823 private:
824 
825  // Store flavour-specific process information and standard prefactor.
826  double m2Z, mGammaZ, thetaWRat, eH, lH, openFrac, gamSig, intSig, resSig;
827 
828 };
829 
830 //==========================================================================
831 
832 } // end namespace Pythia8
833 
834 #endif // Pythia8_SigmaHiggs_H
Definition: AgUStep.h:26