using option '-treename HLTesdTree' for EsdCollector, adding default parameter for...
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8130 / include / SigmaOnia.h
CommitLineData
5ad4eb21 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
14namespace Pythia8 {
15
16//**************************************************************************
17
18// A derived class for g g -> QQbar[3S1(1)] g (Q = c or b).
19
20class Sigma2gg2QQbar3S11g : public Sigma2Process {
21
22public:
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
59class Sigma2gg2QQbar3PJ1g : public Sigma2Process {
60
61public:
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
98class Sigma2qg2QQbar3PJ1q : public Sigma2Process {
99
100public:
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
137class Sigma2qqbar2QQbar3PJ1g : public Sigma2Process {
138
139public:
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
176class Sigma2gg2QQbarX8g : public Sigma2Process {
177
178public:
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
215class Sigma2qg2QQbarX8q : public Sigma2Process {
216
217public:
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
255class Sigma2qqbar2QQbarX8g : public Sigma2Process {
256
257public:
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