← Back to branch summary

~ubuntu-branches/ubuntu/trusty/pythia8/trusty-proposed

« back to all changes in this revision

Viewing changes to include/SigmaOnia.h

  • Committer: Package Import Robot
  • Author(s): Lifeng Sun
  • Date: 2012-05-22 11:43:00 UTC
  • Revision ID: package-import@ubuntu.com-20120522114300-0jvsv2vl4o2bo435
Tags: upstream-8.1.65
Import upstream version 8.1.65

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/SigmaOnia.h
 
1
// SigmaOnia.h is a part of the PYTHIA event generator.
 
2
// Copyright (C) 2012 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