PYTHIA8/pythia8130/include/SigmaQCD.h

   1 // SigmaQCD.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 QCD process differential cross sections.
   7 // Contains classes derived from SigmaProcess via Sigma(0/2)Process.
   8
   9 #ifndef Pythia8_SigmaQCD_H
  10 #define Pythia8_SigmaQCD_H
  11
  12 #include "SigmaProcess.h"
  13
  14 namespace Pythia8 {
  15
  16 //**************************************************************************
  17
  18 // A derived class for minimum-bias (inelastic, nondiffractive) events.
  19
  20 class Sigma0minBias : public Sigma0Process {
  21
  22 public:
  23
  24   // Constructor.
  25   Sigma0minBias() {}
  26
  27   // Evaluate sigma.
  28   virtual double sigmaHat() {return sigmaTotPtr->sigmaND();}
  29
  30   // Select flavour, colour and anticolour.
  31   virtual void setIdColAcol() {}
  32
  33   // Info on the subprocess.
  34   virtual string name()      const {return "minimum bias";}
  35   virtual int    code()      const {return 101;}
  36   virtual bool   isMinBias() const {return true;}
  37
  38 private:
  39
  40 };
  41
  42 //**************************************************************************
  43
  44 // A derived class for elastic scattering A B -> A B.
  45
  46 class Sigma0AB2AB : public Sigma0Process {
  47
  48 public:
  49
  50   // Constructor.
  51   Sigma0AB2AB() {}
  52
  53   // Evaluate sigma.
  54   virtual double sigmaHat() {return sigmaTotPtr->sigmaEl();}
  55
  56   // Select flavour, colour and anticolour.
  57   virtual void setIdColAcol();
  58
  59   // Info on the subprocess.
  60   virtual string name()       const {return "A B -> A B elastic";}
  61   virtual int    code()       const {return 102;}
  62   virtual bool   isResolved() const {return false;}
  63
  64 private:
  65
  66 };
  67
  68 //**************************************************************************
  69
  70 // A derived class for single diffractive scattering A B -> X B.
  71
  72 class Sigma0AB2XB : public Sigma0Process {
  73
  74 public:
  75
  76   // Constructor.
  77   Sigma0AB2XB() {}
  78
  79   // Evaluate sigma.
  80   virtual double sigmaHat() {return sigmaTotPtr->sigmaXB();}
  81
  82   // Select flavour, colour and anticolour.
  83   virtual void setIdColAcol();
  84
  85   // Info on the subprocess.
  86   virtual string name()       const {return "A B -> X B single diffractive";}
  87   virtual int    code()       const {return 103;}
  88   virtual bool   isResolved() const {return false;}
  89   virtual bool   isDiffA()    const {return true;};
  90
  91 private:
  92
  93 };
  94
  95 //**************************************************************************
  96
  97 // A derived class for single diffractive scattering A B -> A X.
  98
  99 class Sigma0AB2AX : public Sigma0Process {
 100
 101 public:
 102
 103   // Constructor.
 104   Sigma0AB2AX() {}
 105
 106   // Evaluate sigma.
 107   virtual double sigmaHat() {return sigmaTotPtr->sigmaAX();}
 108
 109   // Select flavour, colour and anticolour.
 110   virtual void setIdColAcol();
 111
 112   // Info on the subprocess.
 113   virtual string name()       const {return "A B -> A X single diffractive";}
 114   virtual int    code()       const {return 104;}
 115   virtual bool   isResolved() const {return false;}
 116   virtual bool   isDiffB()    const {return true;};
 117
 118 private:
 119
 120 };
 121
 122 //**************************************************************************
 123
 124 // A derived class for double diffractive scattering A B -> X X.
 125
 126 class Sigma0AB2XX : public Sigma0Process {
 127
 128 public:
 129
 130   // Constructor.
 131   Sigma0AB2XX() {}
 132
 133   // Evaluate sigma.
 134   virtual double sigmaHat() {return sigmaTotPtr->sigmaXX();}
 135
 136   // Select flavour, colour and anticolour.
 137   virtual void setIdColAcol();
 138
 139   // Info on the subprocess.
 140   virtual string name()       const {return "A B -> X X double diffractive";}
 141   virtual int    code()       const {return 105;}
 142   virtual bool   isResolved() const {return false;}
 143   virtual bool   isDiffA()    const {return true;};
 144   virtual bool   isDiffB()    const {return true;};
 145
 146 private:
 147
 148 };
 149
 150 //**************************************************************************
 151
 152 // A derived class for g g -> g g.
 153
 154 class Sigma2gg2gg : public Sigma2Process {
 155
 156 public:
 157
 158   // Constructor.
 159   Sigma2gg2gg() {}
 160
 161   // Calculate flavour-independent parts of cross section.
 162   virtual void sigmaKin();
 163
 164   // Evaluate d(sigmaHat)/d(tHat).
 165   virtual double sigmaHat() {return sigma;}
 166
 167   // Select flavour, colour and anticolour.
 168   virtual void setIdColAcol();
 169
 170   // Info on the subprocess.
 171   virtual string name()   const {return "g g -> g g";}
 172   virtual int    code()   const {return 111;}
 173   virtual string inFlux() const {return "gg";}
 174
 175 private:
 176
 177   // Values stored for colour flow selection.
 178   double sigTS, sigUS, sigTU, sigSum, sigma;
 179
 180 };
 181
 182 //**************************************************************************
 183
 184 // A derived class for g g -> q qbar (q = u, d, s, i.e. almost massless).
 185
 186 class Sigma2gg2qqbar : public Sigma2Process {
 187
 188 public:
 189
 190   // Constructor.
 191   Sigma2gg2qqbar() {}
 192
 193   // Initialize process.
 194   virtual void initProc();
 195
 196   // Calculate flavour-independent parts of cross section.
 197   virtual void sigmaKin();
 198
 199   // Evaluate d(sigmaHat)/d(tHat).
 200   virtual double sigmaHat() {return sigma;}
 201
 202   // Select flavour, colour and anticolour.
 203   virtual void setIdColAcol();
 204
 205   // Info on the subprocess.
 206   virtual string name()   const {return "g g -> q qbar (uds)";}
 207   virtual int    code()   const {return 112;}
 208   virtual string inFlux() const {return "gg";}
 209
 210 private:
 211
 212   // Number of quarks to be considered in massless approximation.
 213   int    nQuarkNew;
 214
 215   // Values stored for colour flow selection.
 216   int    idNew;
 217   double mNew, m2New, sigTS, sigUS, sigSum, sigma;
 218
 219 };
 220
 221 //**************************************************************************
 222
 223 // A derived class for q g -> q g (q = u, d, s, c, b).
 224 // Use massless approximation also for Q since no alternative.
 225
 226 class Sigma2qg2qg : public Sigma2Process {
 227
 228 public:
 229
 230   // Constructor.
 231   Sigma2qg2qg() {}
 232
 233   // Calculate flavour-independent parts of cross section.
 234   virtual void sigmaKin();
 235
 236   // Evaluate d(sigmaHat)/d(tHat).
 237   virtual double sigmaHat() {return sigma;}
 238
 239   // Select flavour, colour and anticolour.
 240   virtual void setIdColAcol();
 241
 242   // Info on the subprocess.
 243   virtual string name()   const {return "q g -> q g";}
 244   virtual int    code()   const {return 113;}
 245   virtual string inFlux() const {return "qg";}
 246
 247 private:
 248
 249   // Values stored for colour flow selection.
 250   double mNew, m2New, sigTS, sigTU, sigSum, sigma;
 251
 252 };
 253
 254 //**************************************************************************
 255
 256 // A derived class for q qbar' -> q qbar' or q q' -> q q'
 257 // (qbar qbar' -> qbar qbar'), q' may be same as q.
 258
 259 class Sigma2qq2qq : public Sigma2Process {
 260
 261 public:
 262
 263   // Constructor.
 264   Sigma2qq2qq() {}
 265
 266   // Calculate flavour-independent parts of cross section.
 267   virtual void sigmaKin();
 268
 269   // Evaluate d(sigmaHat)/d(tHat).
 270   virtual double sigmaHat();
 271
 272   // Select flavour, colour and anticolour.
 273   virtual void setIdColAcol();
 274
 275   // Info on the subprocess.
 276   virtual string name()   const {return "q q(bar)' -> q q(bar)'";}
 277   virtual int    code()   const {return 114;}
 278   virtual string inFlux() const {return "qq";}
 279
 280  private:
 281
 282   // Values stored for colour flow selection.
 283   double sigT, sigU, sigTU, sigST, sigSum;
 284
 285 };
 286
 287 //**************************************************************************
 288
 289 // A derived class for q qbar -> g g.
 290
 291 class Sigma2qqbar2gg : public Sigma2Process {
 292
 293 public:
 294
 295   // Constructor.
 296   Sigma2qqbar2gg() {}
 297
 298   // Calculate flavour-independent parts of cross section.
 299   virtual void sigmaKin();
 300
 301   // Evaluate d(sigmaHat)/d(tHat).
 302   virtual double sigmaHat() {return sigma;}
 303
 304   // Select flavour, colour and anticolour.
 305   virtual void setIdColAcol();
 306
 307   // Info on the subprocess.
 308   virtual string name()   const {return "q qbar -> g g";}
 309   virtual int    code()   const {return 115;}
 310   virtual string inFlux() const {return "qqbarSame";}
 311
 312  private:
 313
 314   // Values stored for colour flow selection.
 315   double sigTS, sigUS, sigSum, sigma;
 316
 317 };
 318
 319 //**************************************************************************
 320
 321 // A derived class for q qbar -> q' qbar'.
 322
 323 class Sigma2qqbar2qqbarNew : public Sigma2Process {
 324
 325 public:
 326
 327   // Constructor.
 328   Sigma2qqbar2qqbarNew() {}
 329
 330   // Initialize process.
 331   virtual void initProc();
 332
 333   // Calculate flavour-independent parts of cross section.
 334   virtual void sigmaKin();
 335
 336   // Evaluate d(sigmaHat)/d(tHat).
 337   virtual double sigmaHat() {return sigma;}
 338
 339   // Select flavour, colour and anticolour.
 340   virtual void setIdColAcol();
 341
 342   // Info on the subprocess.
 343   virtual string name()   const {return "q qbar -> q' qbar' (uds)";}
 344   virtual int    code()   const {return 116;}
 345   virtual string inFlux() const {return "qqbarSame";}
 346
 347  private:
 348
 349   // Number of quarks to be considered in massless approximation.
 350   int    nQuarkNew;
 351
 352   // Values stored for colour flow selection.
 353   int    idNew;
 354   double mNew, m2New, sigS, sigma;
 355
 356 };
 357
 358 //**************************************************************************
 359
 360 // A derived class for g g -> Q Qbar (Q = c, b or t).
 361
 362 class Sigma2gg2QQbar : public Sigma2Process {
 363
 364 public:
 365
 366   // Constructor.
 367   Sigma2gg2QQbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
 368
 369   // Initialize process.
 370   virtual void initProc();
 371
 372   // Calculate flavour-independent parts of cross section.
 373   virtual void sigmaKin();
 374
 375   // Evaluate d(sigmaHat)/d(tHat).
 376   virtual double sigmaHat() {return sigma;}
 377
 378   // Select flavour, colour and anticolour.
 379   virtual void setIdColAcol();
 380
 381   // Evaluate weight for W decay angles in top decay (else inactive).
 382   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 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 "gg";}
 388   virtual int    id3Mass() const {return idNew;}
 389   virtual int    id4Mass() const {return idNew;}
 390
 391  private:
 392
 393   // Values stored for process type and colour flow selection.
 394   int    idNew, codeSave;
 395   string nameSave;
 396   double sigTS, sigUS, sigSum, sigma, openFracPair;
 397
 398 };
 399
 400 //**************************************************************************
 401
 402 // A derived class for q qbar -> Q Qbar (Q = c, b or t).
 403
 404 class Sigma2qqbar2QQbar : public Sigma2Process {
 405
 406 public:
 407
 408   // Constructor.
 409   Sigma2qqbar2QQbar(int idIn, int codeIn) : idNew(idIn), codeSave(codeIn) {}
 410
 411   // Initialize process.
 412   virtual void initProc();
 413
 414   // Calculate flavour-independent parts of cross section.
 415   virtual void sigmaKin();
 416
 417   // Evaluate d(sigmaHat)/d(tHat).
 418   virtual double sigmaHat() {return sigma;}
 419
 420   // Select flavour, colour and anticolour.
 421   virtual void setIdColAcol();
 422
 423   // Evaluate weight for W decay angles in top decay (else inactive).
 424   virtual double weightDecay( Event& process, int iResBeg, int iResEnd);
 425
 426   // Info on the subprocess.
 427   virtual string name()    const {return nameSave;}
 428   virtual int    code()    const {return codeSave;}
 429   virtual string inFlux()  const {return "qqbarSame";}
 430   virtual int    id3Mass() const {return idNew;}
 431   virtual int    id4Mass() const {return idNew;}
 432
 433  private:
 434
 435   // Values stored for process type.
 436   int    idNew, codeSave;
 437   string nameSave;
 438   double sigma, openFracPair;
 439
 440 };
 441
 442 //**************************************************************************
 443
 444 } // end namespace Pythia8
 445
 446 #endif // Pythia8_SigmaQCD_H