PYTHIA8/pythia8130/include/SigmaOnia.h

   1 // SigmaOnia.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 charmonia/bottomonia process differential cross sections.
   7 // Contains classes derived from SigmaProcess via Sigma2Process.
   8
   9 #ifndef Pythia8_SigmaOnia_H
  10 #define Pythia8_SigmaOnia_H
  11
  12 #include "SigmaProcess.h"
  13
  14 namespace Pythia8 {
  15
  16 //**************************************************************************
  17
  18 // A derived class for g g -> QQbar[3S1(1)] g (Q = c or b).
  19
  20 class Sigma2gg2QQbar3S11g : public Sigma2Process {
  21
  22 public:
  23
  24   // Constructor.
  25   Sigma2gg2QQbar3S11g(int idIn, int codeIn) : idNew(idIn),
  26     codeSave(codeIn) {}
  27
  28   // Initialize process.
  29   virtual void initProc();
  30
  31   // Calculate flavour-independent parts of cross section.
  32   virtual void sigmaKin();
  33
  34   // Evaluate d(sigmaHat)/d(tHat).
  35   virtual double sigmaHat() {return sigma;}
  36
  37   // Select flavour, colour and anticolour.
  38   virtual void setIdColAcol();
  39
  40   // Info on the subprocess.
  41   virtual string name()    const {return nameSave;}
  42   virtual int    code()    const {return codeSave;}
  43   virtual string inFlux()  const {return "gg";}
  44   virtual int    id3Mass() const {return idHad;}
  45
  46  private:
  47
  48   // Values stored for process type and colour flow selection.
  49   int    idNew, idHad, codeSave;
  50   string nameSave;
  51   double oniumME, sigma;
  52
  53 };
  54
  55 //**************************************************************************
  56
  57 // A derived class for g g -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2).
  58
  59 class Sigma2gg2QQbar3PJ1g : public Sigma2Process {
  60
  61 public:
  62
  63   // Constructor.
  64   Sigma2gg2QQbar3PJ1g(int idIn, int jIn, int codeIn) : idNew(idIn),
  65     jSave(jIn), codeSave(codeIn) {}
  66
  67   // Initialize process.
  68   virtual void initProc();
  69
  70   // Calculate flavour-independent parts of cross section.
  71   virtual void sigmaKin();
  72
  73   // Evaluate d(sigmaHat)/d(tHat).
  74   virtual double sigmaHat() {return sigma;}
  75
  76   // Select flavour, colour and anticolour.
  77   virtual void setIdColAcol();
  78
  79   // Info on the subprocess.
  80   virtual string name()    const {return nameSave;}
  81   virtual int    code()    const {return codeSave;}
  82   virtual string inFlux()  const {return "gg";}
  83   virtual int    id3Mass() const {return idHad;}
  84
  85  private:
  86
  87   // Values stored for process type and colour flow selection.
  88   int    idNew, idHad, jSave, codeSave;
  89   string nameSave;
  90   double oniumME, sigma;
  91
  92 };
  93
  94 //**************************************************************************
  95
  96 // A derived class for q g -> QQbar[3PJ(1)] q (Q = c or b, J = 0, 1 or 2).
  97
  98 class Sigma2qg2QQbar3PJ1q : public Sigma2Process {
  99
 100 public:
 101
 102   // Constructor.
 103   Sigma2qg2QQbar3PJ1q(int idIn, int jIn, int codeIn) : idNew(idIn),
 104     jSave(jIn), codeSave(codeIn) {}
 105
 106   // Initialize process.
 107   virtual void initProc();
 108
 109   // Calculate flavour-independent parts of cross section.
 110   virtual void sigmaKin();
 111
 112   // Evaluate d(sigmaHat)/d(tHat).
 113   virtual double sigmaHat() {return sigma;}
 114
 115   // Select flavour, colour and anticolour.
 116   virtual void setIdColAcol();
 117
 118   // Info on the subprocess.
 119   virtual string name()    const {return nameSave;}
 120   virtual int    code()    const {return codeSave;}
 121   virtual string inFlux()  const {return "qg";}
 122   virtual int    id3Mass() const {return idHad;}
 123
 124  private:
 125
 126   // Values stored for process type and colour flow selection.
 127   int    idNew, idHad, jSave, codeSave;
 128   string nameSave;
 129   double oniumME, sigma;
 130
 131 };
 132
 133 //**************************************************************************
 134
 135 // A derived class for q qbar -> QQbar[3PJ(1)] g (Q = c or b, J = 0, 1 or 2).
 136
 137 class Sigma2qqbar2QQbar3PJ1g : public Sigma2Process {
 138
 139 public:
 140
 141   // Constructor.
 142   Sigma2qqbar2QQbar3PJ1g(int idIn, int jIn, int codeIn) : idNew(idIn),
 143     jSave(jIn), codeSave(codeIn) {}
 144
 145   // Initialize process.
 146   virtual void initProc();
 147
 148   // Calculate flavour-independent parts of cross section.
 149   virtual void sigmaKin();
 150
 151   // Evaluate d(sigmaHat)/d(tHat).
 152   virtual double sigmaHat() {return sigma;}
 153
 154   // Select flavour, colour and anticolour.
 155   virtual void setIdColAcol();
 156
 157   // Info on the subprocess.
 158   virtual string name()    const {return nameSave;}
 159   virtual int    code()    const {return codeSave;}
 160   virtual string inFlux()  const {return "qqbarSame";}
 161   virtual int    id3Mass() const {return idHad;}
 162
 163  private:
 164
 165   // Values stored for process type and colour flow selection.
 166   int    idNew, idHad, jSave, codeSave;
 167   string nameSave;
 168   double oniumME, sigma;
 169
 170 };
 171
 172 //**************************************************************************
 173
 174 // A derived class for g g -> QQbar[X(8)] g (Q = c or b, X = 3S1, 1S0 or 3PJ).
 175
 176 class Sigma2gg2QQbarX8g : public Sigma2Process {
 177
 178 public:
 179
 180   // Constructor.
 181   Sigma2gg2QQbarX8g(int idIn, int stateIn, int codeIn) : idNew(idIn),
 182     stateSave(stateIn), codeSave(codeIn) {}
 183
 184   // Initialize process.
 185   virtual void initProc();
 186
 187   // Calculate flavour-independent parts of cross section.
 188   virtual void sigmaKin();
 189
 190   // Evaluate d(sigmaHat)/d(tHat).
 191   virtual double sigmaHat() {return sigma;}
 192
 193   // Select flavour, colour and anticolour.
 194   virtual void setIdColAcol();
 195
 196   // Info on the subprocess.
 197   virtual string name()    const {return nameSave;}
 198   virtual int    code()    const {return codeSave;}
 199   virtual string inFlux()  const {return "gg";}
 200   virtual int    id3Mass() const {return idHad;}
 201
 202  private:
 203
 204   // Values stored for process type and colour flow selection.
 205   int    idNew, idHad, stateSave, codeSave;
 206   string nameSave;
 207   double oniumME, sigma;
 208
 209 };
 210
 211 //**************************************************************************
 212
 213 // A derived class for q g -> QQbar[X(8)] q (Q = c or b, X = 3S1, 1S0 or 3PJ).
 214
 215 class Sigma2qg2QQbarX8q : public Sigma2Process {
 216
 217 public:
 218
 219   // Constructor.
 220   Sigma2qg2QQbarX8q(int idIn, int stateIn, int codeIn) : idNew(idIn),
 221     stateSave(stateIn), codeSave(codeIn) {}
 222
 223   // Initialize process.
 224   virtual void initProc();
 225
 226   // Calculate flavour-independent parts of cross section.
 227   virtual void sigmaKin();
 228
 229   // Evaluate d(sigmaHat)/d(tHat).
 230   virtual double sigmaHat() {return sigma;}
 231
 232   // Select flavour, colour and anticolour.
 233   virtual void setIdColAcol();
 234
 235   // Info on the subprocess.
 236   virtual string name()    const {return nameSave;}
 237   virtual int    code()    const {return codeSave;}
 238   virtual string inFlux()  const {return "qg";}
 239   virtual int    id3Mass() const {return idHad;}
 240
 241  private:
 242
 243   // Values stored for process type and colour flow selection.
 244   int    idNew, idHad, stateSave, codeSave;
 245   string nameSave;
 246   double oniumME, sigma;
 247
 248 };
 249
 250 //**************************************************************************
 251
 252 // A derived class for q qbar -> QQbar[X(8)] g (Q = c or b,
 253 //   X = 3S1, 1S0 or 3PJ).
 254
 255 class Sigma2qqbar2QQbarX8g : public Sigma2Process {
 256
 257 public:
 258
 259   // Constructor.
 260   Sigma2qqbar2QQbarX8g(int idIn, int stateIn, int codeIn) : idNew(idIn),
 261     stateSave(stateIn), codeSave(codeIn) {}
 262
 263   // Initialize process.
 264   virtual void initProc();
 265
 266   // Calculate flavour-independent parts of cross section.
 267   virtual void sigmaKin();
 268
 269   // Evaluate d(sigmaHat)/d(tHat).
 270   virtual double sigmaHat() {return sigma;}
 271
 272   // Select flavour, colour and anticolour.
 273   virtual void setIdColAcol();
 274
 275   // Info on the subprocess.
 276   virtual string name()    const {return nameSave;}
 277   virtual int    code()    const {return codeSave;}
 278   virtual string inFlux()  const {return "qqbarSame";}
 279   virtual int    id3Mass() const {return idHad;}
 280
 281  private:
 282
 283   // Values stored for process type and colour flow selection.
 284   int    idNew, idHad, stateSave, codeSave;
 285   string nameSave;
 286   double oniumME, sigma;
 287
 288 };
 289
 290 //**************************************************************************
 291
 292 } // end namespace Pythia8
 293
 294 #endif // Pythia8_SigmaOnia_H