Line data Source code
1 : // SigmaHiggs.h is a part of the PYTHIA event generator.
2 : // Copyright (C) 2015 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 0 : class Sigma1ffbar2H : public Sigma1Process {
22 :
23 : public:
24 :
25 : // Constructor.
26 0 : 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 0 : virtual string name() const {return nameSave;}
45 0 : virtual int code() const {return codeSave;}
46 0 : virtual string inFlux() const {return "ffbarSame";}
47 0 : 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 0 : class Sigma1gg2H : public Sigma1Process {
64 :
65 : public:
66 :
67 : // Constructor.
68 0 : 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 0 : 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 0 : virtual string name() const {return nameSave ;}
87 0 : virtual int code() const {return codeSave;}
88 0 : virtual string inFlux() const {return "gg";}
89 0 : 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 0 : class Sigma1gmgm2H : public Sigma1Process {
106 :
107 : public:
108 :
109 : // Constructor.
110 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
129 0 : virtual int code() const {return codeSave;}
130 0 : virtual string inFlux() const {return "gmgm";}
131 0 : 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 0 : class Sigma2ffbar2HZ : public Sigma2Process {
148 :
149 : public:
150 :
151 : // Constructor.
152 0 : 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 0 : virtual string name() const {return nameSave;}
171 0 : virtual int code() const {return codeSave;}
172 0 : virtual string inFlux() const {return "ffbarSame";}
173 0 : virtual bool isSChannel() const {return true;}
174 0 : virtual int id3Mass() const {return idRes;}
175 0 : virtual int id4Mass() const {return 23;}
176 0 : virtual int resonanceA() const {return 23;}
177 0 : 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 0 : class Sigma2ffbar2HW : public Sigma2Process {
193 :
194 : public:
195 :
196 : // Constructor.
197 0 : 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 0 : virtual string name() const {return nameSave;}
216 0 : virtual int code() const {return codeSave;}
217 0 : virtual string inFlux() const {return "ffbarChg";}
218 0 : virtual bool isSChannel() const {return true;}
219 0 : virtual int id3Mass() const {return idRes;}
220 0 : virtual int id4Mass() const {return 24;}
221 0 : 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 0 : class Sigma3ff2HfftZZ : public Sigma3Process {
238 :
239 : public:
240 :
241 : // Constructor.
242 0 : 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 0 : virtual string name() const {return nameSave;}
261 0 : virtual int code() const {return codeSave;}
262 0 : virtual string inFlux() const {return "ff";}
263 0 : virtual int id3Mass() const {return idRes;}
264 :
265 : // Instructions for 3-body phase space with t-channel propagators.
266 0 : virtual int idTchan1() const {return 23;}
267 0 : virtual int idTchan2() const {return 23;}
268 0 : virtual double tChanFracPow1() const {return 0.05;}
269 0 : virtual double tChanFracPow2() const {return 0.9;}
270 0 : 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 0 : class Sigma3ff2HfftWW : public Sigma3Process {
286 :
287 : public:
288 :
289 : // Constructor.
290 0 : 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 0 : virtual string name() const {return nameSave;}
309 0 : virtual int code() const {return codeSave;}
310 0 : virtual string inFlux() const {return "ff";}
311 0 : virtual int id3Mass() const {return idRes;}
312 :
313 : // Instructions for 3-body phase space with t-channel propagators.
314 0 : virtual int idTchan1() const {return 24;}
315 0 : virtual int idTchan2() const {return 24;}
316 0 : virtual double tChanFracPow1() const {return 0.05;}
317 0 : virtual double tChanFracPow2() const {return 0.9;}
318 0 : 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 0 : class Sigma3gg2HQQbar : public Sigma3Process {
334 :
335 : public:
336 :
337 : // Constructor.
338 0 : Sigma3gg2HQQbar(int idIn, int higgsTypeIn) : idNew(idIn),
339 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
358 0 : virtual int code() const {return codeSave;}
359 0 : virtual string inFlux() const {return "gg";}
360 0 : virtual int id3Mass() const {return idRes;}
361 0 : virtual int id4Mass() const {return idNew;}
362 0 : virtual int id5Mass() const {return idNew;}
363 :
364 : // Instructions for 3-body phase space with t-channel propagators.
365 0 : virtual int idTchan1() const {return idNew;}
366 0 : virtual int idTchan2() const {return idNew;}
367 0 : virtual double tChanFracPow1() const {return 0.4;}
368 0 : virtual double tChanFracPow2() const {return 0.2;}
369 0 : 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 0 : class Sigma3qqbar2HQQbar : public Sigma3Process {
386 :
387 : public:
388 :
389 : // Constructor.
390 0 : Sigma3qqbar2HQQbar(int idIn, int higgsTypeIn) : idNew(idIn),
391 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
410 0 : virtual int code() const {return codeSave;}
411 0 : virtual string inFlux() const {return "qqbarSame";}
412 0 : virtual int id3Mass() const {return idRes;}
413 0 : virtual int id4Mass() const {return idNew;}
414 0 : virtual int id5Mass() const {return idNew;}
415 :
416 : // Instructions for 3-body phase space with t-channel propagators.
417 0 : virtual int idTchan1() const {return idNew;}
418 0 : virtual int idTchan2() const {return idNew;}
419 0 : virtual double tChanFracPow1() const {return 0.4;}
420 0 : virtual double tChanFracPow2() const {return 0.2;}
421 0 : 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 0 : class Sigma2qg2Hq : public Sigma2Process {
438 :
439 : public:
440 :
441 : // Constructor.
442 0 : Sigma2qg2Hq(int idIn, int higgsTypeIn) : idNew(idIn),
443 0 : 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 0 : virtual string name() const {return nameSave;}
462 0 : virtual int code() const {return codeSave;}
463 0 : virtual string inFlux() const {return "qg";}
464 0 : virtual int id3Mass() const {return idRes;}
465 0 : 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 0 : class Sigma2gg2Hglt : public Sigma2Process {
482 :
483 : public:
484 :
485 : // Constructor.
486 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
505 0 : virtual int code() const {return codeSave;}
506 0 : virtual string inFlux() const {return "gg";}
507 0 : 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 0 : class Sigma2qg2Hqlt : public Sigma2Process {
523 :
524 : public:
525 :
526 : // Constructor.
527 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
546 0 : virtual int code() const {return codeSave;}
547 0 : virtual string inFlux() const {return "qg";}
548 0 : 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 0 : class Sigma2qqbar2Hglt : public Sigma2Process {
564 :
565 : public:
566 :
567 : // Constructor.
568 0 : 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 0 : 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 0 : virtual string name() const {return nameSave;}
587 0 : virtual int code() const {return codeSave;}
588 0 : virtual string inFlux() const {return "qqbarSame";}
589 0 : 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 0 : class Sigma1ffbar2Hchg : public Sigma1Process {
604 :
605 : public:
606 :
607 : // Constructor.
608 0 : 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 0 : virtual string name() const {return "f fbar' -> H+-";}
627 0 : virtual int code() const {return 961;}
628 0 : virtual string inFlux() const {return "ffbarChg";}
629 0 : 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 0 : class Sigma2qg2Hchgq : public Sigma2Process {
645 :
646 : public:
647 :
648 : // Constructor.
649 0 : Sigma2qg2Hchgq(int idIn, int codeIn, string nameIn) : idNew(idIn),
650 0 : 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 0 : virtual string name() const {return nameSave;}
669 0 : virtual int code() const {return codeSave;}
670 0 : virtual string inFlux() const {return "qg";}
671 0 : virtual int id3Mass() const {return 37;}
672 0 : 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 0 : class Sigma2ffbar2A3H12 : public Sigma2Process {
688 :
689 : public:
690 :
691 : // Constructor.
692 0 : 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 0 : virtual string name() const {return nameSave;}
711 0 : virtual int code() const {return codeSave;}
712 0 : virtual string inFlux() const {return "ffbarSame";}
713 0 : virtual int id3Mass() const {return 36;}
714 0 : 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 0 : class Sigma2ffbar2HchgH12 : public Sigma2Process {
730 :
731 : public:
732 :
733 : // Constructor.
734 0 : 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 0 : virtual string name() const {return nameSave;}
753 0 : virtual int code() const {return codeSave;}
754 0 : virtual string inFlux() const {return "ffbarChg";}
755 0 : virtual int id3Mass() const {return 37;}
756 0 : 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 0 : class Sigma2ffbar2HposHneg : public Sigma2Process {
773 :
774 : public:
775 :
776 : // Constructor.
777 0 : 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 0 : virtual string name() const {return "f fbar -> H+ H-";}
796 0 : virtual int code() const {return 1085;}
797 0 : virtual string inFlux() const {return "ffbarSame";}
798 0 : virtual int id3Mass() const {return 37;}
799 0 : 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
|
