PYTHIA8/pythia8145/include/SigmaHiggs.h

   1 // SigmaHiggs.h is a part of the PYTHIA event generator.
   2 // Copyright (C) 2010 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 "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