PYTHIA8/pythia8130/include/SigmaEW.h

   1 // SigmaEW.h is a part of the PYTHIA event generator.
   2 // Copyright (C) 2008 Torbjorn Sjostrand.
   3 // PYTHIA is licenced under the GNU GPL version 2, see COPYING for details.
   4 // Please respect the MCnet Guidelines, see GUIDELINES for details.
   5
   6 // Header file for electroweak process differential cross sections.
   7 // Contains classes derived from SigmaProcess via Sigma(1/2)Process.
   8
   9 #ifndef Pythia8_SigmaEW_H
  10 #define Pythia8_SigmaEW_H
  11
  12 #include "PythiaComplex.h"
  13 #include "SigmaProcess.h"
  14
  15 namespace Pythia8 {
  16
  17
  18 //**************************************************************************
  19
  20 // A derived class for q g -> q gamma (q = u, d, s, c, b).
  21 // Use massless approximation also for Q since no alternative.
  22
  23 class Sigma2qg2qgamma : public Sigma2Process {
  24
  25 public:
  26
  27   // Constructor.
  28   Sigma2qg2qgamma() {}
  29
  30   // Calculate flavour-independent parts of cross section.
  31   virtual void sigmaKin();
  32
  33   // Evaluate d(sigmaHat)/d(tHat).
  34   virtual double sigmaHat();
  35
  36   // Select flavour, colour and anticolour.
  37   virtual void setIdColAcol();
  38
  39   // Info on the subprocess.
  40   virtual string name()   const {return "q g -> q gamma (udscb)";}
  41   virtual int    code()   const {return 201;}
  42   virtual string inFlux() const {return "qg";}
  43
  44 private:
  45
  46   // Values stored for later use.
  47   double mNew, m2New, sigUS, sigma0;
  48
  49 };
  50
  51 //**************************************************************************
  52
  53 // A derived class for q qbar -> g gamma.
  54
  55 class Sigma2qqbar2ggamma : public Sigma2Process {
  56
  57 public:
  58
  59   // Constructor.
  60   Sigma2qqbar2ggamma() {}
  61
  62   // Calculate flavour-independent parts of cross section.
  63   virtual void sigmaKin();
  64
  65   // Evaluate d(sigmaHat)/d(tHat).
  66   virtual double sigmaHat();
  67
  68   // Select flavour, colour and anticolour.
  69   virtual void setIdColAcol();
  70
  71   // Info on the subprocess.
  72   virtual string name()   const {return "q qbar -> g gamma";}
  73   virtual int    code()   const {return 202;}
  74   virtual string inFlux() const {return "qqbarSame";}
  75
  76 private:
  77
  78   // Values stored for later use.
  79   double sigma0;
  80
  81 };
  82
  83 //**************************************************************************
  84
  85 // A derived class for g g -> g gamma.
  86
  87 class Sigma2gg2ggamma : public Sigma2Process {
  88
  89 public:
  90
  91   // Constructor.
  92   Sigma2gg2ggamma() {}
  93
  94   // Initialize process.
  95   virtual void initProc();
  96
  97   // Calculate flavour-independent parts of cross section.
  98   virtual void sigmaKin();
  99
 100   // Evaluate d(sigmaHat)/d(tHat).
 101   virtual double sigmaHat() {return sigma;}
 102
 103   // Select flavour, colour and anticolour.
 104   virtual void setIdColAcol();
 105
 106   // Info on the subprocess.
 107   virtual string name()   const {return "g g -> g gamma";}
 108   virtual int    code()   const {return 203;}
 109   virtual string inFlux() const {return "gg";}
 110
 111 private:
 112
 113   // Values stored for later use.
 114   double chargeSum, sigma;
 115
 116 };
 117
 118 //**************************************************************************
 119
 120 // A derived class for f fbar -> gamma gamma.
 121
 122 class Sigma2ffbar2gammagamma : public Sigma2Process {
 123
 124 public:
 125
 126   // Constructor.
 127   Sigma2ffbar2gammagamma() {}
 128
 129   // Calculate flavour-independent parts of cross section.
 130   virtual void sigmaKin();
 131
 132   // Evaluate d(sigmaHat)/d(tHat).
 133   virtual double sigmaHat();
 134
 135   // Select flavour, colour and anticolour.
 136   virtual void setIdColAcol();
 137
 138   // Info on the subprocess.
 139   virtual string name()   const {return "f fbar -> gamma gamma";}
 140   virtual int    code()   const {return 204;}
 141   virtual string inFlux() const {return "ffbarSame";}
 142
 143 private:
 144
 145   // Values stored for later use.
 146   double sigTU, sigma0;
 147
 148 };
 149
 150 //**************************************************************************
 151
 152 // A derived class for g g -> gamma gamma.
 153
 154 class Sigma2gg2gammagamma : public Sigma2Process {
 155
 156 public:
 157
 158   // Constructor.
 159   Sigma2gg2gammagamma() {}
 160
 161   // Initialize process.
 162   virtual void initProc();
 163
 164   // Calculate flavour-independent parts of cross section.
 165   virtual void sigmaKin();
 166
 167   // Evaluate d(sigmaHat)/d(tHat).
 168   virtual double sigmaHat() {return sigma;}
 169
 170   // Select flavour, colour and anticolour.
 171   virtual void setIdColAcol();
 172
 173   // Info on the subprocess.
 174   virtual string name()   const {return "g g -> gamma gamma";}
 175   virtual int    code()   const {return 205;}
 176   virtual string inFlux() const {return "gg";}
 177
 178 private:
 179
 180   double charge2Sum, sigma;
 181
 182 };
 183
 184 //**************************************************************************
 185
 186 // A derived class for f f' -> f f' via t-channel gamma*/Z0 exchange.
 187
 188 class Sigma2ff2fftgmZ : public Sigma2Process {
 189
 190 public:
 191
 192   // Constructor.
 193   Sigma2ff2fftgmZ() {}
 194
 195   // Initialize process.
 196   virtual void initProc();
 197
 198   // Calculate flavour-independent parts of cross section.
 199   virtual void sigmaKin();
 200
 201   // Evaluate sigmaHat(sHat).
 202   virtual double sigmaHat();
 203
 204   // Select flavour, colour and anticolour.
 205   virtual void setIdColAcol();
 206
 207   // Info on the subprocess.
 208   virtual string name()   const {return "f f' -> f f' (t-channel gamma*/Z0)";}
 209   virtual int    code()   const {return 211;}
 210   virtual string inFlux() const {return "ff";}
 211
 212 private:
 213
 214   //  Z parameters for propagator.
 215   int    gmZmode;
 216   double mZ, mZS, thetaWRat, sigmagmgm, sigmagmZ, sigmaZZ;
 217
 218 };
 219
 220 //**************************************************************************
 221
 222 // A derived class for f_1 f_2 -> f_3 f_4 via t-channel W+- exchange.
 223
 224 class Sigma2ff2fftW : public Sigma2Process {
 225
 226 public:
 227
 228   // Constructor.
 229   Sigma2ff2fftW() {}
 230
 231   // Initialize process.
 232   virtual void initProc();
 233
 234   // Calculate flavour-independent parts of cross section.
 235   virtual void sigmaKin();
 236
 237   // Evaluate sigmaHat(sHat).
 238   virtual double sigmaHat();
 239
 240   // Select flavour, colour and anticolour.
 241   virtual void setIdColAcol();
 242
 243   // Info on the subprocess.
 244   virtual string name()   const {return "f_1 f_2 -> f_3 f_4 (t-channel W+-)";}
 245   virtual int    code()   const {return 212;}
 246   virtual string inFlux() const {return "ff";}
 247
 248 private:
 249
 250   //  W parameters for propagator.
 251   double mW, mWS, thetaWRat, sigma0;
 252
 253 };
 254
 255 //**************************************************************************
 256
 257 // A derived class for q q' -> Q q" via t-channel W+- exchange.
 258 // Related to Sigma2ff2fftW class, but with massive matrix elements.
 259
 260 class Sigma2qq2QqtW : public Sigma2Process {
 261
 262 public:
 263
 264   // Constructor.
 265   Sigma2qq2QqtW(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
 266
 267   // Initialize process.
 268   virtual void initProc();
 269
 270   // Calculate flavour-independent parts of cross section.
 271   virtual void sigmaKin();
 272
 273   // Evaluate sigmaHat(sHat).
 274   virtual double sigmaHat();
 275
 276   // Select flavour, colour and anticolour.
 277   virtual void setIdColAcol();
 278
 279   // Evaluate weight for W decay angles in top decay (else inactive).
 280   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 281
 282   // Info on the subprocess.
 283   virtual string name()    const {return nameSave;}
 284   virtual int    code()    const {return codeSave;}
 285   virtual string inFlux()  const {return "ff";}
 286   virtual int    id3Mass() const {return idNew;}
 287
 288 private:
 289
 290   // Values stored for process type. W parameters for propagator.
 291   int    idNew, codeSave;
 292   string nameSave;
 293   double mW, mWS, thetaWRat, sigma0, openFracPos, openFracNeg;
 294
 295 };
 296
 297 //**************************************************************************
 298
 299 // A derived class for f fbar -> gamma*/Z0.
 300
 301 class Sigma1ffbar2gmZ : public Sigma1Process {
 302
 303 public:
 304
 305   // Constructor.
 306   Sigma1ffbar2gmZ() {}
 307
 308   // Initialize process.
 309   virtual void initProc();
 310
 311   // Calculate flavour-independent parts of cross section.
 312   virtual void sigmaKin();
 313
 314   // Evaluate sigmaHat(sHat).
 315   virtual double sigmaHat();
 316
 317   // Select flavour, colour and anticolour.
 318   virtual void setIdColAcol();
 319
 320   // Evaluate weight for Z decay angle.
 321   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 322
 323   // Info on the subprocess.
 324   virtual string name()       const {return "f fbar -> gamma*/Z0";}
 325   virtual int    code()       const {return 221;}
 326   virtual string inFlux()     const {return "ffbarSame";}
 327   virtual int    resonanceA() const {return 23;}
 328
 329 private:
 330
 331   // Parameters set at initialization or for each new event.
 332   int    gmZmode;
 333   double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
 334          gamSum, intSum, resSum, gamProp, intProp, resProp;
 335
 336   // Pointer to properties of the particle species, to access decay channels.
 337   ParticleDataEntry* particlePtr;
 338
 339 };
 340
 341 //**************************************************************************
 342
 343 // A derived class for f fbar' -> W+-.
 344
 345 class Sigma1ffbar2W : public Sigma1Process {
 346
 347 public:
 348
 349   // Constructor.
 350   Sigma1ffbar2W() {}
 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();
 360
 361   // Select flavour, colour and anticolour.
 362   virtual void setIdColAcol();
 363
 364   // Evaluate weight for W decay angle.
 365   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 366
 367   // Info on the subprocess.
 368   virtual string name()       const {return "f fbar' -> W+-";}
 369   virtual int    code()       const {return 222;}
 370   virtual string inFlux()     const {return "ffbarChg";}
 371   virtual int    resonanceA() const {return 24;}
 372
 373 private:
 374
 375   // Parameters set at initialization.
 376   double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0Pos, sigma0Neg;
 377
 378   // Pointer to properties of the particle species, to access decay channels.
 379   ParticleDataEntry* particlePtr;
 380
 381 };
 382
 383 //**************************************************************************
 384
 385 // A derived class for f fbar -> gamma* -> f' fbar', summed over light f'.
 386 // Allows pT-ordered evolution for multiple interactions.
 387
 388 class Sigma2ffbar2ffbarsgm : public Sigma2Process {
 389
 390 public:
 391
 392   // Constructor.
 393   Sigma2ffbar2ffbarsgm() {}
 394
 395   // Calculate flavour-independent parts of cross section.
 396   virtual void sigmaKin();
 397
 398   // Evaluate sigmaHat(sHat).
 399   virtual double sigmaHat();
 400
 401   // Select flavour, colour and anticolour.
 402   virtual void setIdColAcol();
 403
 404   // Info on the subprocess.
 405   virtual string name()       const {
 406     return "f fbar -> f' fbar' (s-channel gamma*)";}
 407   virtual int    code()       const {return 223;}
 408   virtual string inFlux()     const {return "ffbarSame";}
 409   virtual bool   isSChannel() const {return true;}
 410
 411 private:
 412
 413   // Values stored for later use.
 414   int    idNew;
 415   double sigma0;
 416
 417 };
 418
 419 //**************************************************************************
 420
 421 // A derived class for f fbar -> gamma*/Z0 -> F Fbar, for one heavy F.
 422 // Allows pT cuts as for other 2 -> 2 processes.
 423
 424 class Sigma2ffbar2FFbarsgmZ : public Sigma2Process {
 425
 426 public:
 427
 428   // Constructor.
 429   Sigma2ffbar2FFbarsgmZ(int idIn, int codeIn) : idNew(idIn),
 430     codeSave(codeIn) {}
 431
 432   // Initialize process.
 433   virtual void initProc();
 434
 435   // Calculate flavour-independent parts of cross section.
 436   virtual void sigmaKin();
 437
 438   // Evaluate sigmaHat(sHat).
 439   virtual double sigmaHat();
 440
 441   // Select flavour, colour and anticolour.
 442   virtual void setIdColAcol();
 443
 444   // Evaluate weight for W decay angles in top decay (else inactive).
 445   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 446
 447   // Info on the subprocess.
 448   virtual string name()       const {return nameSave;}
 449   virtual int    code()       const {return codeSave;}
 450   virtual string inFlux()     const {return "ffbarSame";}
 451   virtual bool   isSChannel() const {return true;}
 452   virtual int    id3Mass()    const {return idNew;}
 453   virtual int    id4Mass()    const {return idNew;}
 454   virtual int    resonanceA() const {return 23;}
 455
 456 private:
 457
 458   // Values stored for process type. Z parameters for propagator.
 459   int    idNew, codeSave, gmZmode;
 460   string nameSave;
 461   bool   isPhysical;
 462   double ef, vf, af, mRes, GammaRes, m2Res, GamMRat, thetaWRat,
 463          mr, betaf, cosThe, gamProp, intProp, resProp, openFracPair;
 464
 465 };
 466
 467 //**************************************************************************
 468
 469 // A derived class for f fbar' -> W+- -> F fbar", for one or two heavy F.
 470 // Allows pT cuts as for other 2 -> 2 processes.
 471
 472 class Sigma2ffbar2FfbarsW : public Sigma2Process {
 473
 474 public:
 475
 476   // Constructor.
 477   Sigma2ffbar2FfbarsW(int idIn, int idIn2, int codeIn) : idNew(idIn),
 478     idNew2(idIn2), codeSave(codeIn) {}
 479
 480   // Initialize process.
 481   virtual void initProc();
 482
 483   // Calculate flavour-independent parts of cross section.
 484   virtual void sigmaKin();
 485
 486   // Evaluate sigmaHat(sHat).
 487   virtual double sigmaHat();
 488
 489   // Select flavour, colour and anticolour.
 490   virtual void setIdColAcol();
 491
 492   // Evaluate weight for W decay angles in top decay (else inactive).
 493   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 494
 495   // Info on the subprocess.
 496   virtual string name()       const {return nameSave;}
 497   virtual int    code()       const {return codeSave;}
 498   virtual string inFlux()     const {return "ffbarChg";}
 499   virtual bool   isSChannel() const {return true;}
 500   virtual int    id3Mass()    const {return idNew;}
 501   virtual int    id4Mass()    const {return idPartner;}
 502   virtual int    resonanceA() const {return 24;}
 503
 504 private:
 505
 506   // Values stored for process type. W parameters for propagator.
 507   int    idNew, idNew2, codeSave, idPartner;
 508   string nameSave;
 509   bool   isPhysical;
 510   double V2New, mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
 511          openFracPos, openFracNeg;
 512
 513 };
 514
 515 //**************************************************************************
 516
 517 // An intermediate class for f fbar -> gamma*/Z0/W+- gamma*/Z0/W-+.
 518
 519 class Sigma2ffbargmZWgmZW : public Sigma2Process {
 520
 521 public:
 522
 523   // Constructor.
 524   Sigma2ffbargmZWgmZW() {}
 525
 526 protected:
 527
 528   // Internal products.
 529   Vec4    pRot[7];
 530   complex hA[7][7];
 531   complex hC[7][7];
 532
 533   // Calculate and store internal products.
 534   void setupProd( Event& process, int i1, int i2, int i3, int i4,
 535     int i5, int i6);
 536
 537   // Evaluate the F function of Gunion and Kunszt.
 538   complex fGK(int i1, int i2, int i3, int i4, int i5, int i6);
 539
 540   // Evaluate the Xi function of Gunion and Kunszt.
 541   double xiGK( double tHnow, double uHnow);
 542
 543   // Evaluate the Xj function of Gunion and Kunszt.
 544   double xjGK( double tHnow, double uHnow);
 545
 546 private:
 547
 548 };
 549
 550 //**************************************************************************
 551
 552 // A derived class for f fbar -> gamma*/Z0 gamma*/Z0.
 553
 554 class Sigma2ffbar2gmZgmZ : public Sigma2ffbargmZWgmZW {
 555
 556 public:
 557
 558   // Constructor.
 559   Sigma2ffbar2gmZgmZ() {}
 560
 561   // Initialize process.
 562   virtual void initProc();
 563
 564   // Calculate flavour-independent parts of cross section.
 565   virtual void sigmaKin();
 566
 567   // Evaluate d(sigmaHat)/d(tHat).
 568   virtual double sigmaHat();
 569
 570   // Select flavour, colour and anticolour.
 571   virtual void setIdColAcol();
 572
 573   // Evaluate weight for simultaneous flavour choices.
 574   virtual double weightDecayFlav( Event& process);
 575
 576   // Evaluate weight for decay angles of the two gamma*/Z0.
 577   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 578
 579   // Info on the subprocess.
 580   virtual string name()    const {return "f fbar -> gamma*/Z0 gamma*/Z0";}
 581   virtual int    code()    const {return 231;}
 582   virtual string inFlux()  const {return "ffbarSame";}
 583   virtual int    id3Mass() const {return 23;}
 584   virtual int    id4Mass() const {return 23;}
 585
 586 private:
 587
 588   // Parameters set at initialization or for each new event.
 589   int    gmZmode, i1, i2, i3, i4, i5, i6;
 590   double mRes, GammaRes, m2Res, GamMRat, thetaWRat, sigma0,
 591          gamSum3, intSum3, resSum3, gamProp3, intProp3, resProp3,
 592          gamSum4, intSum4, resSum4, gamProp4, intProp4, resProp4,
 593          c3LL, c3LR, c3RL, c3RR, c4LL, c4LR, c4RL, c4RR, flavWt;
 594
 595   // Pointer to properties of the particle species, to access decay channels.
 596   ParticleDataEntry* particlePtr;
 597
 598 };
 599
 600 //**************************************************************************
 601
 602 // A derived class for f fbar' -> Z0 W+-. (Here pure Z0, unfortunately.)
 603
 604 class Sigma2ffbar2ZW : public Sigma2ffbargmZWgmZW {
 605
 606 public:
 607
 608   // Constructor.
 609   Sigma2ffbar2ZW() {}
 610
 611   // Initialize process.
 612   virtual void initProc();
 613
 614   // Calculate flavour-independent parts of cross section.
 615   virtual void sigmaKin();
 616
 617   // Evaluate d(sigmaHat)/d(tHat).
 618   virtual double sigmaHat();
 619
 620   // Select flavour, colour and anticolour.
 621   virtual void setIdColAcol();
 622
 623   // Evaluate weight for Z0 and W+- decay angles.
 624   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 625
 626   // Info on the subprocess.
 627   virtual string name()       const {return "f fbar' -> Z0 W+- (no gamma*!)";}
 628   virtual int    code()       const {return 232;}
 629   virtual string inFlux()     const {return "ffbarChg";}
 630   virtual int    id3Mass()    const {return 23;}
 631   virtual int    id4Mass()    const {return 24;}
 632   virtual int    resonanceA() const {return 24;}
 633
 634 private:
 635
 636   // Store W+- mass and width, and couplings.
 637   double mW, widW, mWS, mwWS, sin2thetaW, cos2thetaW, thetaWRat,
 638          thetaWpt, thetaWmm, lun, lde, sigma0, openFracPos, openFracNeg;
 639
 640 };
 641
 642 //**************************************************************************
 643
 644 // A derived class for f fbar -> W+ W-.
 645
 646 class Sigma2ffbar2WW : public Sigma2ffbargmZWgmZW {
 647
 648 public:
 649
 650   // Constructor.
 651   Sigma2ffbar2WW() {}
 652
 653   // Initialize process.
 654   virtual void initProc();
 655
 656   // Calculate flavour-independent parts of cross section.
 657   virtual void sigmaKin();
 658
 659   // Evaluate d(sigmaHat)/d(tHat).
 660   virtual double sigmaHat();
 661
 662   // Select flavour, colour and anticolour.
 663   virtual void setIdColAcol();
 664
 665   // Evaluate weight for W+ and W- decay angles.
 666   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 667
 668   // Info on the subprocess.
 669   virtual string name()       const {return "f fbar -> W+ W-";}
 670   virtual int    code()       const {return 233;}
 671   virtual int    id3Mass()    const {return 24;}
 672   virtual string inFlux()     const {return "ffbarSame";}
 673   virtual int    id4Mass()    const {return -24;}
 674   virtual int    resonanceA() const {return 23;}
 675
 676 private:
 677
 678   // Store Z0 mass and width.
 679   double mZ, widZ, mZS, mwZS, thetaWRat, sigma0, cgg, cgZ, cZZ, cfg,
 680     cfZ, cff, gSS, gTT, gST, gUU, gSU, openFracPair;
 681
 682 };
 683
 684 //**************************************************************************
 685
 686 // An intermediate class for f fbar -> gamma*/Z0 g/gamma and permutations.
 687
 688 class Sigma2ffbargmZggm : public Sigma2Process {
 689
 690 public:
 691
 692   // Constructor.
 693   Sigma2ffbargmZggm() {}
 694
 695   // Initialize process.
 696   virtual void initProc();
 697
 698   // Evaluate weight for gamma&/Z0 decay angle.
 699   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 700
 701 protected:
 702
 703   // Parameters set at initialization or for each new event.
 704   int    gmZmode;
 705   double mRes, GammaRes, m2Res, GamMRat, thetaWRat,
 706          gamSum, intSum, resSum, gamProp, intProp, resProp;
 707
 708   // Evaluate current sum of flavour couplings times phase space.
 709   void flavSum();
 710
 711   // Evaluate current propagator terms of cross section.
 712   void propTerm();
 713
 714 private:
 715
 716   // Pointer to properties of the particle species, to access decay channels.
 717   ParticleDataEntry* particlePtr;
 718
 719 };
 720
 721 //**************************************************************************
 722
 723 // A derived class for q qbar -> gamma*/Z0 g.
 724
 725 class Sigma2qqbar2gmZg : public Sigma2ffbargmZggm {
 726
 727 public:
 728
 729   // Constructor.
 730   Sigma2qqbar2gmZg() {}
 731
 732   // Calculate flavour-independent parts of cross section.
 733   virtual void sigmaKin();
 734
 735   // Evaluate d(sigmaHat)/d(tHat).
 736   virtual double sigmaHat();
 737
 738   // Select flavour, colour and anticolour.
 739   virtual void setIdColAcol();
 740
 741   // Info on the subprocess.
 742   virtual string name()    const {return "q qbar -> gamma*/Z0 g";}
 743   virtual int    code()    const {return 241;}
 744   virtual string inFlux()  const {return "qqbarSame";}
 745   virtual int    id3Mass() const {return 23;}
 746
 747 private:
 748
 749   // Values stored for later use.
 750   double sigma0;
 751
 752 };
 753
 754 //**************************************************************************
 755
 756 // A derived class for q g -> gamma*/Z0 q.
 757
 758 class Sigma2qg2gmZq : public Sigma2ffbargmZggm {
 759
 760 public:
 761
 762   // Constructor.
 763   Sigma2qg2gmZq() {}
 764
 765   // Calculate flavour-independent parts of cross section.
 766   virtual void sigmaKin();
 767
 768   // Evaluate d(sigmaHat)/d(tHat).
 769   virtual double sigmaHat();
 770
 771   // Select flavour, colour and anticolour.
 772   virtual void setIdColAcol();
 773
 774   // Info on the subprocess.
 775   virtual string name()    const {return "q g-> gamma*/Z0 q";}
 776   virtual int    code()    const {return 242;}
 777   virtual string inFlux()  const {return "qg";}
 778   virtual int    id3Mass() const {return 23;}
 779
 780 private:
 781
 782   // Values stored for later use.
 783   double sigma0;
 784
 785 };
 786
 787 //**************************************************************************
 788
 789 // A derived class for f fbar' -> gamma*/Z0 gamma.
 790
 791 class Sigma2ffbar2gmZgm : public Sigma2ffbargmZggm {
 792
 793 public:
 794
 795   // Constructor.
 796   Sigma2ffbar2gmZgm() {}
 797
 798   // Calculate flavour-independent parts of cross section.
 799   virtual void sigmaKin();
 800
 801   // Evaluate d(sigmaHat)/d(tHat).
 802   virtual double sigmaHat();
 803
 804   // Select flavour, colour and anticolour.
 805   virtual void setIdColAcol();
 806
 807   // Info on the subprocess.
 808   virtual string name()    const {return "f fbar -> gamma*/Z0 gamma";}
 809   virtual int    code()    const {return 243;}
 810   virtual string inFlux()  const {return "ffbarSame";}
 811   virtual int    id3Mass() const {return 23;}
 812
 813 private:
 814
 815   // Values stored for later use.
 816   double sigma0;
 817
 818 };
 819
 820 //**************************************************************************
 821
 822 // A derived class for f gamma -> gamma*/Z0 f.
 823
 824 class Sigma2fgm2gmZf : public Sigma2ffbargmZggm {
 825
 826 public:
 827
 828   // Constructor.
 829   Sigma2fgm2gmZf() {}
 830
 831   // Calculate flavour-independent parts of cross section.
 832   virtual void sigmaKin();
 833
 834   // Evaluate d(sigmaHat)/d(tHat).
 835   virtual double sigmaHat();
 836
 837   // Select flavour, colour and anticolour.
 838   virtual void setIdColAcol();
 839
 840   // Info on the subprocess.
 841   virtual string name()    const {return "f gamma -> gamma*/Z0 f";}
 842   virtual int    code()    const {return 244;}
 843   virtual string inFlux()  const {return "fgm";}
 844   virtual int    id3Mass() const {return 23;}
 845
 846 private:
 847
 848   // Values stored for later use.
 849   double sigma0;
 850
 851 };
 852
 853 //**************************************************************************
 854
 855 // An intermediate class for f fbar -> W+- g/gamma and permutations.
 856
 857 class Sigma2ffbarWggm : public Sigma2Process {
 858
 859 public:
 860
 861   // Constructor.
 862   Sigma2ffbarWggm() {}
 863
 864   // Evaluate weight for gamma&/Z0 decay angle.
 865   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 866
 867 private:
 868
 869 };
 870
 871 //**************************************************************************
 872
 873 // A derived class for q qbar' -> W+- g.
 874
 875 class Sigma2qqbar2Wg : public Sigma2ffbarWggm {
 876
 877 public:
 878
 879   // Constructor.
 880   Sigma2qqbar2Wg() {}
 881
 882   // Initialize process.
 883   virtual void initProc();
 884
 885   // Calculate flavour-independent parts of cross section.
 886   virtual void sigmaKin();
 887
 888   // Evaluate d(sigmaHat)/d(tHat).
 889   virtual double sigmaHat();
 890
 891   // Select flavour, colour and anticolour.
 892   virtual void setIdColAcol();
 893
 894   // Info on the subprocess.
 895   virtual string name()    const {return "q qbar' -> W+- g";}
 896   virtual int    code()    const {return 251;}
 897   virtual string inFlux()  const {return "ffbarChg";}
 898   virtual int    id3Mass() const {return 24;}
 899
 900 private:
 901
 902   // Values stored for later use.
 903   double sigma0, openFracPos, openFracNeg;
 904
 905 };
 906
 907 //**************************************************************************
 908
 909 // A derived class for q g -> W+- q'.
 910
 911 class Sigma2qg2Wq : public Sigma2ffbarWggm {
 912
 913 public:
 914
 915   // Constructor.
 916   Sigma2qg2Wq() {}
 917
 918   // Initialize process.
 919   virtual void initProc();
 920
 921   // Calculate flavour-independent parts of cross section.
 922   virtual void sigmaKin();
 923
 924   // Evaluate d(sigmaHat)/d(tHat).
 925   virtual double sigmaHat();
 926
 927   // Select flavour, colour and anticolour.
 928   virtual void setIdColAcol();
 929
 930   // Info on the subprocess.
 931   virtual string name()    const {return "q g-> W+- q'";}
 932   virtual int    code()    const {return 252;}
 933   virtual string inFlux()  const {return "qg";}
 934   virtual int    id3Mass() const {return 24;}
 935
 936 private:
 937
 938   // Values stored for later use.
 939   double sigma0, openFracPos, openFracNeg;
 940
 941 };
 942
 943 //**************************************************************************
 944
 945 // A derived class for f fbar' -> W+- gamma.
 946
 947 class Sigma2ffbar2Wgm : public Sigma2ffbarWggm {
 948
 949 public:
 950
 951   // Constructor.
 952   Sigma2ffbar2Wgm() {}
 953
 954   // Initialize process.
 955   virtual void initProc();
 956
 957   // Calculate flavour-independent parts of cross section.
 958   virtual void sigmaKin();
 959
 960   // Evaluate d(sigmaHat)/d(tHat).
 961   virtual double sigmaHat();
 962
 963   // Select flavour, colour and anticolour.
 964   virtual void setIdColAcol();
 965
 966   // Info on the subprocess.
 967   virtual string name()    const {return "f fbar' -> W+- gamma";}
 968   virtual int    code()    const {return 253;}
 969   virtual string inFlux()  const {return "ffbarChg";}
 970   virtual int    id3Mass() const {return 24;}
 971
 972 private:
 973
 974   // Values stored for later use.
 975   double sigma0, openFracPos, openFracNeg;
 976
 977 };
 978
 979 //**************************************************************************
 980
 981 // A derived class for f gamma -> W+- f'.
 982
 983 class Sigma2fgm2Wf : public Sigma2ffbarWggm {
 984
 985 public:
 986
 987   // Constructor.
 988   Sigma2fgm2Wf() {}
 989
 990   // Initialize process.
 991   virtual void initProc();
 992
 993   // Calculate flavour-independent parts of cross section.
 994   virtual void sigmaKin();
 995
 996   // Evaluate d(sigmaHat)/d(tHat).
 997   virtual double sigmaHat();
 998
 999   // Select flavour, colour and anticolour.
1000   virtual void setIdColAcol();
1001
1002   // Info on the subprocess.
1003   virtual string name()    const {return "f gamma -> W+- f'";}
1004   virtual int    code()    const {return 254;}
1005   virtual string inFlux()  const {return "fgm";}
1006   virtual int    id3Mass() const {return 24;}
1007
1008 private:
1009
1010   // Values stored for later use.
1011   double sigma0, openFracPos, openFracNeg;
1012
1013 };
1014
1015 //**************************************************************************
1016
1017 } // end namespace Pythia8
1018
1019 #endif // Pythia8_SigmaEW_H