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