PYTHIA8/pythia8145/include/SigmaSUSY.h

   1 // SigmaSUSY.h is a part of the PYTHIA event generator.
   2 // Copyright (C) 2010 Peter Skands, 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 Supersymmetric process differential cross sections.
   7 // Contains classes derived from SigmaProcess via Sigma2Process.
   8
   9 #ifndef Pythia8_SigmaSUSY_H
  10 #define Pythia8_SigmaSUSY_H
  11
  12 #include "PhaseSpace.h"
  13 #include "PythiaComplex.h"
  14 #include "SigmaProcess.h"
  15 #include "SusyCouplings.h"
  16 #include "SusyLesHouches.h"
  17
  18 namespace Pythia8 {
  19
  20 //==========================================================================
  21
  22 // A derived class for q qbar -> neutralino_i neutralino_j.
  23
  24 class Sigma2qqbar2chi0chi0 : public Sigma2Process {
  25
  26 public:
  27
  28   // Constructor.
  29   Sigma2qqbar2chi0chi0() {};
  30
  31   // Constructor.
  32   Sigma2qqbar2chi0chi0(int id3chiIn, int id4chiIn, int codeIn) {
  33
  34     // Save ordering indices and process code
  35     id3chi   = id3chiIn;
  36     id4chi   = id4chiIn;
  37     codeSave = codeIn;
  38
  39
  40     // Construct id codes from ordering indices.
  41     id3                  = 1000022;
  42     if (id3chi == 2) id3 = 1000023;
  43     if (id3chi == 3) id3 = 1000025;
  44     if (id3chi == 4) id3 = 1000035;
  45     if (id3chi == 5) id3 = 1000045;
  46     id4                  = 1000022;
  47     if (id4chi == 2) id4 = 1000023;
  48     if (id4chi == 3) id4 = 1000025;
  49     if (id4chi == 4) id4 = 1000035;
  50     if (id4chi == 5) id4 = 1000045;
  51
  52   }
  53
  54   // Initialize process.
  55   virtual void initProc();
  56
  57   // Calculate flavour-independent parts of cross section.
  58   virtual void sigmaKin();
  59
  60   // Evaluate d(sigmaHat)/d(tHat).
  61   virtual double sigmaHat();
  62
  63   // Select flavour, colour and anticolour.
  64   virtual void setIdColAcol();
  65
  66   // Info on the subprocess.
  67   virtual string name()    const {return nameSave;}
  68   virtual int    code()    const {return codeSave;}
  69   virtual string inFlux()  const {return "qq";}
  70   virtual int    id3Mass() const {return abs(id3);}
  71   virtual int    id4Mass() const {return abs(id4);}
  72   virtual int    resonanceA() const {return 23;}
  73   virtual bool   isSUSY()  const {return true;}
  74
  75  protected:
  76
  77   // Basic process information
  78   int     id3chi, id4chi, codeSave;
  79   string  nameSave;
  80
  81   // Values stored for later use
  82   double  sigma0, ui, uj, ti, tj, openFracPair;
  83   complex propZ;
  84
  85   CoupSUSY* coupSUSYPtr;
  86
  87 };
  88
  89 //==========================================================================
  90
  91 // A derived class for q qbar -> neutralino_i chargino_j.
  92
  93 class Sigma2qqbar2charchi0 : public Sigma2qqbar2chi0chi0 {
  94
  95 public:
  96
  97   // Constructor.
  98   Sigma2qqbar2charchi0(int id3chiIn, int id4chiIn, int codeIn) {
  99
 100     // Save ordering indices and process code
 101     id3chi   = id3chiIn;
 102     id4chi   = id4chiIn;
 103     codeSave = codeIn;
 104
 105     // Construct id codes from ordering indices.
 106     id3 = (abs(id3chi) == 2) ? 1000037 : 1000024;
 107     if (id3chi < 0)  id3 = -id3;
 108
 109     id4                  = 1000022;
 110     if (id4chi == 2) id4 = 1000023;
 111     if (id4chi == 3) id4 = 1000025;
 112     if (id4chi == 4) id4 = 1000035;
 113     if (id4chi == 5) id4 = 1000045;
 114
 115   }
 116
 117   // Calculate flavour-independent parts of cross section.
 118   virtual void sigmaKin();
 119
 120   // Evaluate d(sigmaHat)/d(tHat).
 121   virtual double sigmaHat();
 122
 123   virtual int    resonanceA() const {return 24;}
 124
 125 protected :
 126
 127   complex propW;
 128
 129 };
 130
 131 //==========================================================================
 132
 133 // A derived class for q qbar -> chargino+_i chargino-_j.
 134
 135 class Sigma2qqbar2charchar : public Sigma2qqbar2chi0chi0 {
 136
 137 public:
 138
 139   // Constructor.
 140   Sigma2qqbar2charchar(int id3chiIn, int id4chiIn, int codeIn) {
 141
 142     // Save ordering indices and process code
 143     id3chi   = id3chiIn;
 144     id4chi   = id4chiIn;
 145     codeSave = codeIn;
 146
 147     // Construct id codes from ordering indices.
 148     id3 = (abs(id3chi) == 2) ?  1000037 :  1000024;
 149     id4 = (abs(id4chi) == 2) ? -1000037 : -1000024;
 150
 151   }
 152
 153   // Calculate flavour-independent parts of cross section.
 154   virtual void sigmaKin();
 155
 156   // Evaluate d(sigmaHat)/d(tHat).
 157   virtual double sigmaHat();
 158
 159 };
 160
 161 //==========================================================================
 162
 163 // A derived class for q g -> neutralino_i squark_j (and cc)
 164
 165 class Sigma2qg2chi0squark : public Sigma2Process {
 166
 167 public:
 168
 169   // Constructor.
 170   Sigma2qg2chi0squark() { };
 171
 172   // Constructor.
 173   Sigma2qg2chi0squark(int id3chiIn, int id4sqIn, bool isUp, int codeIn) {
 174
 175     // Save ordering indices and process code
 176     id3chi   = id3chiIn;
 177     id4sq    = id4sqIn;
 178     codeSave = codeIn;
 179
 180     // Construct id codes from ordering indices.
 181     id3                  = 1000022;
 182     if (id3chi == 2) id3 = 1000023;
 183     if (id3chi == 3) id3 = 1000025;
 184     if (id3chi == 4) id3 = 1000035;
 185     if (id3chi == 5) id3 = 1000045;
 186     id4                  = 1000001 + (isUp ? 1 : 0);
 187     if (id4sq  == 2) id4 = 1000003 + (isUp ? 1 : 0);
 188     if (id4sq  == 3) id4 = 1000005 + (isUp ? 1 : 0);
 189     if (id4sq  == 4) id4 = 2000001 + (isUp ? 1 : 0);
 190     if (id4sq  == 5) id4 = 2000003 + (isUp ? 1 : 0);
 191     if (id4sq  == 6) id4 = 2000005 + (isUp ? 1 : 0);
 192
 193   }
 194
 195   // Initialize process.
 196   virtual void initProc();
 197
 198   // Calculate flavour-independent parts of cross section.
 199   virtual void sigmaKin();
 200
 201   // Evaluate d(sigmaHat)/d(tHat).
 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 nameSave;}
 209   virtual int    code()    const {return codeSave;}
 210   virtual string inFlux()  const {return "qg";}
 211   virtual int    id3Mass() const {return abs(id3);}
 212   virtual int    id4Mass() const {return abs(id4);}
 213   virtual bool   isSUSY()  const {return true;}
 214
 215  protected:
 216
 217   // Basic process information
 218   int     id3chi, id4sq, codeSave;
 219   string  nameSave;
 220
 221   // Values stored for later use
 222   double  sigma0, ui, uj, ti, tj, openFracPair;
 223
 224   //SUSY couplings
 225   CoupSUSY* coupSUSYPtr;
 226
 227 };
 228
 229 //==========================================================================
 230
 231 // A derived class for q g -> chargino_i squark_j (incl cc)
 232
 233 class Sigma2qg2charsquark : public Sigma2qg2chi0squark {
 234
 235 public:
 236
 237   // Constructor.
 238   Sigma2qg2charsquark(int id3chiIn, int id4sqIn, bool isUp, int codeIn) {
 239
 240     // Save ordering indices and process code
 241     id3chi   = id3chiIn;
 242     id4sq    = id4sqIn;
 243     codeSave = codeIn;
 244
 245     // Construct id codes from ordering indices.
 246     id3Sav                       = 1000024;
 247     if (abs(id3chi) == 2) id3Sav = 1000037;
 248     if (isUp)             id3Sav = -id3Sav;
 249     id4Sav                       = 1000001 + (isUp ? 1 : 0);
 250     if (id4sq  == 2) id4Sav      = 1000003 + (isUp ? 1 : 0);
 251     if (id4sq  == 3) id4Sav      = 1000005 + (isUp ? 1 : 0);
 252     if (id4sq  == 4) id4Sav      = 2000001 + (isUp ? 1 : 0);
 253     if (id4sq  == 5) id4Sav      = 2000003 + (isUp ? 1 : 0);
 254     if (id4sq  == 6) id4Sav      = 2000005 + (isUp ? 1 : 0);
 255
 256     // Initial values, can be swapped to charge conjugates event by event.
 257     id3 = id3Sav;
 258     id4 = id4Sav;
 259
 260   }
 261
 262   // Initialize process.
 263   virtual void initProc();
 264
 265   // Evaluate d(sigmaHat)/d(tHat).
 266   virtual double sigmaHat();
 267
 268   // Select flavour, colour and anticolour.
 269   virtual void setIdColAcol();
 270
 271  private:
 272
 273   // Basic process information
 274   int id3Sav, id4Sav;
 275
 276 };
 277
 278 //==========================================================================
 279
 280 // A derived class for q q' -> ~q_i ~q_j
 281
 282 class Sigma2qq2squarksquark : public Sigma2Process {
 283
 284 public:
 285
 286   // Constructor.
 287   Sigma2qq2squarksquark() {}
 288
 289   // Constructor.
 290   Sigma2qq2squarksquark(int id3In, int id4In, int codeIn) {
 291
 292     // Save ordering indices and process code
 293     id3Sav = id3In;
 294     id4Sav = id4In;
 295     codeSave = codeIn;
 296     // Initial values (flipped for c.c.)
 297     id3    = id3Sav;
 298     id4    = id4Sav;
 299
 300   }
 301
 302   // Initialize process.
 303   virtual void initProc();
 304
 305   // Calculate flavour-independent parts of cross section.
 306   virtual void sigmaKin();
 307
 308   // Evaluate d(sigmaHat)/d(tHat).
 309   virtual double sigmaHat();
 310
 311   // Select flavour, colour and anticolour.
 312   virtual void setIdColAcol();
 313
 314   // Info on the subprocess.
 315   virtual string name()    const {return nameSave;}
 316   virtual int    code()    const {return codeSave;}
 317   virtual string inFlux()  const {return "qq";}
 318   virtual int    id3Mass() const {return abs(id3Sav);}
 319   virtual int    id4Mass() const {return abs(id4Sav);}
 320   virtual bool   isSUSY()  const {return true;}
 321
 322 private:
 323
 324   // Basic process information
 325   int     id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut;
 326   string  nameSave;
 327   bool    isUD;
 328
 329   // Storage of mass squares
 330   double m2Glu;
 331   vector<double> m2Neut, m2Char;
 332
 333   // Flavor-independent prefactors.
 334   double sigmaChar, sigmaNeut, sigmaGlu;
 335   double sigmaCharNeut, sigmaCharGlu, sigmaNeutGlu;
 336   double openFracPair;
 337
 338   // Point-by-point info
 339   double tGlu, uGlu;
 340   vector<double> tNeut, uNeut, tChar, uChar;
 341   double sumCt, sumCu, sumNt, sumNu, sumGt, sumGu, sumInterference;
 342
 343   //SUSY couplings
 344   CoupSUSY* coupSUSYPtr;
 345 };
 346
 347 //==========================================================================
 348
 349 // A derived class for q qbar' -> ~q_i ~q*_j
 350
 351 class Sigma2qqbar2squarkantisquark : public Sigma2Process {
 352
 353 public:
 354
 355   // Constructor.
 356   Sigma2qqbar2squarkantisquark() {}
 357
 358   // Constructor.
 359   Sigma2qqbar2squarkantisquark(int id3In, int id4In, int codeIn) {
 360
 361     // Save ordering indices and process code
 362     // (always store squark first, antisquark second)
 363     id3Sav = abs(id3In);
 364     id4Sav = -abs(id4In);
 365     codeSave = codeIn;
 366     // Initial values
 367     id3    = id3Sav;
 368     id4    = id4Sav;
 369
 370   }
 371
 372   // Initialize process.
 373   virtual void initProc();
 374
 375   // Calculate flavour-independent parts of cross section.
 376   virtual void sigmaKin();
 377
 378   // Evaluate d(sigmaHat)/d(tHat).
 379   virtual double sigmaHat();
 380
 381   // Select flavour, colour and anticolour.
 382   virtual void setIdColAcol();
 383
 384   // Info on the subprocess.
 385   virtual string name()    const {return nameSave;}
 386   virtual int    code()    const {return codeSave;}
 387   virtual string inFlux()  const {return "qq";}
 388   virtual int    id3Mass() const {return abs(id3Sav);}
 389   virtual int    id4Mass() const {return abs(id4Sav);}
 390   virtual bool   isSUSY()  const {return true;}
 391
 392 private:
 393
 394   // Basic process information
 395   int     id3Sav, id4Sav, codeSave, iGen3, iGen4, nNeut;
 396   string  nameSave;
 397   bool    isUD, isCC;
 398
 399   // Storage of mass squares
 400   double m2Glu;
 401   vector<double> m2Neut;
 402
 403   // Flavor-independent prefactors: EW, strong, and interference
 404   double xW;
 405   double openFracPair;
 406   double sigmaEW, sigmaGlu, sigmaEWG;
 407
 408   // Point-by-point info
 409   double tGlu, uGlu;
 410   vector<double> tNeut, uNeut;
 411   complex propZW;
 412   double sumColS, sumColT, sumColSCC, sumColTCC, sumInterference;
 413
 414   //SUSY couplings
 415   CoupSUSY* coupSUSYPtr;
 416
 417 };
 418
 419 //==========================================================================
 420
 421 // A derived class for g g -> ~q ~q*
 422
 423 class Sigma2gg2squarkantisquark : public Sigma2Process {
 424
 425 public:
 426
 427   // Constructor.
 428   Sigma2gg2squarkantisquark() {
 429   }
 430
 431   // Constructor.
 432   Sigma2gg2squarkantisquark(int id34In, int codeIn) {
 433
 434     // Save ordering indices and process code
 435     // (always store squark first, antisquark second)
 436     id3Sav = abs(id34In);
 437     id4Sav = -abs(id34In);
 438     codeSave = codeIn;
 439     // Initial values
 440     id3    = id3Sav;
 441     id4    = id4Sav;
 442
 443   }
 444
 445   // Initialize process.
 446   virtual void initProc();
 447
 448   // Calculate flavour-independent parts of cross section.
 449   virtual void sigmaKin();
 450
 451   // Evaluate d(sigmaHat)/d(tHat).
 452   virtual double sigmaHat() {return sigma;}
 453
 454   // Select flavour, colour and anticolour.
 455   virtual void setIdColAcol();
 456
 457   // Info on the subprocess.
 458   virtual string name()    const {return nameSave;}
 459   virtual int    code()    const {return codeSave;}
 460   virtual string inFlux()  const {return "gg";}
 461   virtual int    id3Mass() const {return abs(id3Sav);}
 462   virtual int    id4Mass() const {return abs(id4Sav);}
 463   virtual bool   isSUSY()  const {return true;}
 464
 465 private:
 466
 467   // Basic process information
 468   int     id3Sav, id4Sav, codeSave;
 469   string  nameSave;
 470   double sigma, m2Sq, openFracPair;
 471
 472   // Color flow info
 473   double sumColT, sumColU, sumInterference;
 474
 475   //SUSY couplings
 476   CoupSUSY* coupSUSYPtr;
 477
 478 };
 479
 480 //==========================================================================
 481
 482 // A derived class for q g -> ~q ~g
 483
 484 class Sigma2qg2squarkgluino : public Sigma2Process {
 485
 486 public:
 487
 488   // Constructor.
 489   Sigma2qg2squarkgluino() {}
 490
 491   // Constructor.
 492   Sigma2qg2squarkgluino(int id3In, int codeIn) {
 493
 494     // Save ordering indices and process code
 495     id3Sav = abs(id3In);
 496     codeSave = codeIn;
 497     // Initial values
 498     id3    = id3Sav;
 499     id4    = 1000021;
 500
 501   }
 502
 503   // Initialize process.
 504   virtual void initProc();
 505
 506   // Calculate flavour-independent parts of cross section.
 507   virtual void sigmaKin();
 508
 509   // Evaluate d(sigmaHat)/d(tHat).
 510   virtual double sigmaHat();
 511
 512   // Select flavour, colour and anticolour.
 513   virtual void setIdColAcol();
 514
 515   // Info on the subprocess.
 516   virtual string name()    const {return nameSave;}
 517   virtual int    code()    const {return codeSave;}
 518   virtual string inFlux()  const {return "qg";}
 519   virtual int    id3Mass() const {return abs(id3Sav);}
 520   virtual int    id4Mass() const {return 1000021;}
 521   virtual bool   isSUSY()  const {return true;}
 522
 523 private:
 524
 525   // Basic process information
 526   int     id3Sav, codeSave;
 527   string  nameSave;
 528   double sigmaA, sigmaB, comFacHat, m2Glu, m2Sq, openFracPair;
 529
 530   //SUSY couplings
 531   CoupSUSY* coupSUSYPtr;
 532
 533 };
 534
 535 //==========================================================================
 536
 537 // A derived class for g g -> gluino gluino.
 538
 539 class Sigma2gg2gluinogluino : public Sigma2Process {
 540
 541 public:
 542
 543   // Constructor.
 544   Sigma2gg2gluinogluino() {
 545   }
 546
 547   // Initialize process.
 548   virtual void initProc();
 549
 550   // Calculate flavour-independent parts of cross section.
 551   virtual void sigmaKin();
 552
 553   // Evaluate d(sigmaHat)/d(tHat).
 554   virtual double sigmaHat() {return sigma;}
 555
 556   // Select flavour, colour and anticolour.
 557   virtual void setIdColAcol();
 558
 559   // Info on the subprocess.
 560   virtual string name()    const {return "g g -> gluino gluino";}
 561   virtual int    code()    const {return 1201;}
 562   virtual string inFlux()  const {return "gg";}
 563   virtual int    id3Mass() const {return 1000021;}
 564   virtual int    id4Mass() const {return 1000021;}
 565   virtual bool   isSUSY()  const {return true;}
 566
 567 private:
 568
 569   // Values stored for process type and colour flow selection.
 570   double sigTS, sigUS, sigTU, sigSum, sigma, openFracPair;
 571
 572   //SUSY couplings
 573   CoupSUSY* coupSUSYPtr;
 574
 575 };
 576
 577 //==========================================================================
 578
 579 // A derived class for q qbar -> gluino gluino.
 580
 581 class Sigma2qqbar2gluinogluino : public Sigma2Process {
 582
 583 public:
 584
 585   // Constructor.
 586   Sigma2qqbar2gluinogluino() {
 587
 588 }
 589
 590   // Initialize process.
 591   virtual void initProc();
 592
 593   // Calculate flavour-independent parts of cross section.
 594   virtual void sigmaKin();
 595
 596   // Evaluate d(sigmaHat)/d(tHat).
 597   virtual double sigmaHat();
 598
 599   // Select flavour, colour and anticolour.
 600   virtual void setIdColAcol();
 601
 602   // Info on the subprocess.
 603   virtual string name()    const {return "q qbar -> gluino gluino";}
 604   virtual int    code()    const {return 1202;}
 605   virtual string inFlux()  const {return "qqbarSame";}
 606   virtual int    id3Mass() const {return 1000021;}
 607   virtual int    id4Mass() const {return 1000021;}
 608   virtual bool   isSUSY()  const {return true;}
 609
 610 private:
 611
 612   // Values stored for process type and colour flow selection.
 613   double openFracPair, s34Avg, sigS, tHG, uHG, tHG2, uHG2;
 614
 615   //SUSY couplings
 616   CoupSUSY* coupSUSYPtr;
 617
 618 };
 619
 620 //==========================================================================
 621
 622 class Sigma1qq2antisquark : public Sigma1Process {
 623 public:
 624
 625   // Constructor.
 626   Sigma1qq2antisquark() {}
 627
 628
 629   Sigma1qq2antisquark(int id3In) {
 630
 631     idRes = id3In;
 632
 633   }
 634
 635   // Initialize process.
 636   virtual void initProc();
 637
 638   // Calculate flavour-independent parts of cross section.
 639   virtual void sigmaKin();
 640
 641   // Evaluate d(sigmaHat)/d(tHat).
 642   virtual double sigmaHat();
 643
 644   // Select flavour, colour and anticolour.
 645   virtual void setIdColAcol();
 646
 647   // Info on the subprocess.
 648   virtual string name()    const {return nameSave;}
 649   virtual int    code()    const {return codeSave;}
 650   virtual string inFlux()  const {return "qq";}
 651   virtual bool   isSUSY()  const {return true;}
 652   virtual bool   isRPV()   const {return true;}
 653   virtual int    resonanceA() const {return idRes;}
 654
 655 private:
 656
 657   // Values stored for process type and colour flow selection.
 658   double mRes, GammaRes, m2Res, GamMRat, sigBW, widthOut;
 659   int    squarkType, codeSave, idRes;
 660   string nameSave;
 661
 662   //SUSY couplings
 663   CoupSUSY* coupSUSYPtr;
 664
 665 };
 666
 667
 668 //==========================================================================
 669 } // end namespace Pythia8
 670
 671
 672
 673
 674
 675
 676
 677 #endif // Pythia8_SigmaSUSY_H
 678