using option '-treename HLTesdTree' for EsdCollector, adding default parameter for...
[u/mrichter/AliRoot.git] / PYTHIA8 / pythia8130 / include / SigmaQCD.h
CommitLineData
5ad4eb21 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
14namespace Pythia8 {
15
16//**************************************************************************
17
18// A derived class for minimum-bias (inelastic, nondiffractive) events.
19
20class Sigma0minBias : public Sigma0Process {
21
22public:
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
38private:
39
40};
41
42//**************************************************************************
43
44// A derived class for elastic scattering A B -> A B.
45
46class Sigma0AB2AB : public Sigma0Process {
47
48public:
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
64private:
65
66};
67
68//**************************************************************************
69
70// A derived class for single diffractive scattering A B -> X B.
71
72class Sigma0AB2XB : public Sigma0Process {
73
74public:
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
91private:
92
93};
94
95//**************************************************************************
96
97// A derived class for single diffractive scattering A B -> A X.
98
99class Sigma0AB2AX : public Sigma0Process {
100
101public:
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
118private:
119
120};
121
122//**************************************************************************
123
124// A derived class for double diffractive scattering A B -> X X.
125
126class Sigma0AB2XX : public Sigma0Process {
127
128public:
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
146private:
147
148};
149
150//**************************************************************************
151
152// A derived class for g g -> g g.
153
154class Sigma2gg2gg : public Sigma2Process {
155
156public:
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
175private:
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
186class Sigma2gg2qqbar : public Sigma2Process {
187
188public:
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
210private:
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
226class Sigma2qg2qg : public Sigma2Process {
227
228public:
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
247private:
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
259class Sigma2qq2qq : public Sigma2Process {
260
261public:
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
291class Sigma2qqbar2gg : public Sigma2Process {
292
293public:
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
323class Sigma2qqbar2qqbarNew : public Sigma2Process {
324
325public:
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
362class Sigma2gg2QQbar : public Sigma2Process {
363
364public:
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
404class Sigma2qqbar2QQbar : public Sigma2Process {
405
406public:
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