PYTHIA8/pythia8170/include/SigmaSUSY.h

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