Fork me on GitHub

source: git/classes/DelphesClasses.h @ 264bf40

ImprovedOutputFileTimingdual_readoutllp
Last change on this file since 264bf40 was 264bf40, checked in by pavel <pavel@…>, 7 years ago

define BTag and TauTag? as UInt_t and use them as a set of bits

  • Property mode set to 100644
File size: 9.7 KB
Line 
1#ifndef DelphesClasses_h
2#define DelphesClasses_h
3
4/**
5 *
6 *  Definition of classes to be stored in the root tree.
7 *  Function CompareXYZ sorts objects by the variable XYZ that MUST be
8 *  present in the data members of the root tree class of the branch.
9 *
10 *  $Date: 2008-06-04 13:57:24 $
11 *  $Revision: 1.1 $
12 *
13 *
14 *  \author P. Demin - UCL, Louvain-la-Neuve
15 *
16 */
17
18// Dependencies (#includes)
19
20#include "TRef.h"
21#include "TObject.h"
22#include "TRefArray.h"
23#include "TLorentzVector.h"
24
25#include "classes/SortableObject.h"
26
27class DelphesFactory;
28
29//---------------------------------------------------------------------------
30
31class Event: public TObject
32{
33public:
34
35  Long64_t Number; // event number
36
37  Float_t ReadTime;
38  Float_t ProcTime; 
39
40  ClassDef(Event, 1)
41};
42
43//---------------------------------------------------------------------------
44
45class LHCOEvent: public Event
46{
47public:
48
49  Int_t Trigger; // trigger word
50
51  ClassDef(LHCOEvent, 1)
52};
53
54//---------------------------------------------------------------------------
55
56class LHEFEvent: public Event
57{
58public:
59
60  Int_t ProcessID; // subprocess code for the event | hepup.IDPRUP
61
62  Float_t Weight; // weight for the event | hepup.XWGTUP
63  Float_t ScalePDF; // scale in GeV used in the calculation of the PDFs in the event | hepup.SCALUP
64  Float_t AlphaQED; // value of the QED coupling used in the event | hepup.AQEDUP
65  Float_t AlphaQCD; // value of the QCD coupling used in the event | hepup.AQCDUP
66
67  ClassDef(LHEFEvent, 2)
68};
69
70//---------------------------------------------------------------------------
71
72class HepMCEvent: public Event
73{
74public:
75
76  Int_t ProcessID; // unique signal process id | signal_process_id()
77  Int_t MPI; // number of multi parton interactions | mpi ()
78
79  Float_t Scale; // energy scale, see hep-ph/0109068 | event_scale()
80  Float_t AlphaQED; // QED coupling, see hep-ph/0109068 | alphaQED()
81  Float_t AlphaQCD; // QCD coupling, see hep-ph/0109068 | alphaQCD()
82
83  Int_t ID1; // flavour code of first parton | pdf_info()->id1()
84  Int_t ID2; // flavour code of second parton | pdf_info()->id2()     
85
86  Float_t X1; // fraction of beam momentum carried by first parton ("beam side") | pdf_info()->x1()
87  Float_t X2; // fraction of beam momentum carried by second parton ("target side") | pdf_info()->x2()
88
89  Float_t ScalePDF; // Q-scale used in evaluation of PDF's (in GeV) | pdf_info()->scalePDF()
90
91  Float_t PDF1; // PDF (id1, x1, Q) | pdf_info()->pdf1()
92  Float_t PDF2; // PDF (id2, x2, Q) | pdf_info()->pdf2()
93
94  ClassDef(HepMCEvent, 2)
95};
96
97//---------------------------------------------------------------------------
98
99class GenParticle: public SortableObject
100{
101public:
102  Int_t PID; // particle HEP ID number | hepevt.idhep[number]
103
104  Int_t Status; // particle status | hepevt.isthep[number]
105  Int_t IsPU; // 0 or 1 for particles from pile-up interactions
106 
107
108  Int_t M1; // particle 1st mother | hepevt.jmohep[number][0] - 1
109  Int_t M2; // particle 2nd mother | hepevt.jmohep[number][1] - 1
110
111  Int_t D1; // particle 1st daughter | hepevt.jdahep[number][0] - 1
112  Int_t D2; // particle last daughter | hepevt.jdahep[number][1] - 1
113
114  Int_t Charge; // particle charge
115
116  Float_t Mass; // particle mass
117
118  Float_t E; // particle energy | hepevt.phep[number][3]
119  Float_t Px; // particle momentum vector (x component) | hepevt.phep[number][0]
120  Float_t Py; // particle momentum vector (y component) | hepevt.phep[number][1]
121  Float_t Pz; // particle momentum vector (z component) | hepevt.phep[number][2]
122
123  Float_t PT; // particle transverse momentum
124  Float_t Eta; // particle pseudorapidity
125  Float_t Phi; // particle azimuthal angle
126
127  Float_t Rapidity; // particle rapidity
128
129  Float_t T; // particle vertex position (t component) | hepevt.vhep[number][3]
130  Float_t X; // particle vertex position (x component) | hepevt.vhep[number][0]
131  Float_t Y; // particle vertex position (y component) | hepevt.vhep[number][1]
132  Float_t Z; // particle vertex position (z component) | hepevt.vhep[number][2]
133
134  static CompBase *fgCompare; //!
135  const CompBase *GetCompare() const { return fgCompare; }
136 
137  TLorentzVector P4();
138
139  ClassDef(GenParticle, 1)
140};
141
142//---------------------------------------------------------------------------
143
144class MissingET: public TObject
145{
146public:
147  Float_t MET; // mising transverse energy
148  Float_t Phi; // mising energy azimuthal angle
149
150  ClassDef(MissingET, 1)
151};
152
153//---------------------------------------------------------------------------
154
155class ScalarHT: public TObject
156{
157public:
158  Float_t HT; // scalar sum of transverse momenta
159
160  ClassDef(ScalarHT, 1)
161};
162
163//---------------------------------------------------------------------------
164
165class Photon: public SortableObject
166{
167public:
168
169  Float_t PT; // photon transverse momentum
170  Float_t Eta; // photon pseudorapidity
171  Float_t Phi; // photon azimuthal angle
172
173  Float_t E; // photon energy
174 
175  Float_t EhadOverEem; // ratio of the hadronic versus electromagnetic energy deposited in the calorimeter
176
177  TRefArray Particles; // references to generated particles
178
179  static CompBase *fgCompare; //!
180  const CompBase *GetCompare() const { return fgCompare; }
181
182  TLorentzVector P4();
183
184  ClassDef(Photon, 2)
185};
186
187//---------------------------------------------------------------------------
188
189class Electron: public SortableObject
190{
191public:
192
193  Float_t PT; // electron transverse momentum
194  Float_t Eta; // electron pseudorapidity
195  Float_t Phi; // electron azimuthal angle
196
197  Int_t Charge; // electron charge
198
199  Float_t EhadOverEem; // ratio of the hadronic versus electromagnetic energy deposited in the calorimeter
200
201  TRef Particle; // reference to generated particle
202
203  static CompBase *fgCompare; //!
204  const CompBase *GetCompare() const { return fgCompare; }
205
206  TLorentzVector P4();
207
208  ClassDef(Electron, 2)
209};
210
211//---------------------------------------------------------------------------
212
213class Muon: public SortableObject
214{
215public:
216
217  Float_t PT; // muon transverse momentum
218  Float_t Eta; // muon pseudorapidity
219  Float_t Phi; // muon azimuthal angle
220
221  Int_t Charge; // muon charge
222
223  TRef Particle; // reference to generated particle
224
225  static CompBase *fgCompare; //!
226  const CompBase *GetCompare() const { return fgCompare; }
227
228  TLorentzVector P4();
229
230  ClassDef(Muon, 2)
231};
232
233//---------------------------------------------------------------------------
234
235class Jet: public SortableObject
236{
237public:
238
239  Float_t PT; // jet transverse momentum
240  Float_t Eta; // jet pseudorapidity
241  Float_t Phi; // jet azimuthal angle
242
243  Float_t Mass; // jet invariant mass
244
245  Float_t DeltaEta;  // jet radius in pseudorapidity
246  Float_t DeltaPhi;  // jet radius in azimuthal angle
247
248  UInt_t BTag; // 0 or 1 for a jet that has been tagged as containing a heavy quark
249  UInt_t TauTag; // 0 or 1 for a jet that has been tagged as a tau
250
251  Int_t Charge; // tau charge
252
253  Float_t EhadOverEem; // ratio of the hadronic versus electromagnetic energy deposited in the calorimeter
254
255  TRefArray Constituents; // references to constituents
256  TRefArray Particles; // references to generated particles
257
258  static CompBase *fgCompare; //!
259  const CompBase *GetCompare() const { return fgCompare; }
260
261  TLorentzVector P4();
262
263  ClassDef(Jet, 2)
264};
265
266//---------------------------------------------------------------------------
267
268class Track: public SortableObject
269{
270public: 
271  Int_t PID; // HEP ID number
272
273  Int_t Charge; // track charge
274
275  Float_t PT; // track transverse momentum
276
277  Float_t Eta; // track pseudorapidity
278  Float_t Phi; // track azimuthal angle
279
280  Float_t EtaOuter; // track pseudorapidity at the tracker edge
281  Float_t PhiOuter; // track azimuthal angle at the tracker edge
282
283  Float_t X; // track vertex position (x component)
284  Float_t Y; // track vertex position (y component)
285  Float_t Z; // track vertex position (z component)
286
287  Float_t XOuter; // track position (x component) at the tracker edge
288  Float_t YOuter; // track position (y component) at the tracker edge
289  Float_t ZOuter; // track position (z component) at the tracker edge
290
291  TRef Particle; // reference to generated particle
292
293  static CompBase *fgCompare; //!
294  const CompBase *GetCompare() const { return fgCompare; }
295
296  TLorentzVector P4();
297
298  ClassDef(Track, 1)
299};
300
301//---------------------------------------------------------------------------
302
303class Tower: public SortableObject
304{
305public:
306  Float_t ET; // calorimeter tower transverse energy
307  Float_t Eta; // calorimeter tower pseudorapidity
308  Float_t Phi; // calorimeter tower azimuthal angle
309
310  Float_t E; // calorimeter tower energy
311
312  Float_t Eem; // calorimeter tower electromagnetic energy
313  Float_t Ehad; // calorimeter tower hadronic energy
314
315  Float_t Edges[4]; // calorimeter tower edges
316
317  TRefArray Particles; // references to generated particles
318
319  static CompBase *fgCompare; //!
320  const CompBase *GetCompare() const { return fgCompare; }
321
322  TLorentzVector P4();
323
324  ClassDef(Tower, 1)
325};
326
327//---------------------------------------------------------------------------
328
329class Candidate: public SortableObject
330{
331  friend class DelphesFactory;
332
333public:
334  Candidate();
335
336  Int_t PID;
337
338  Int_t Status;
339  Int_t M1, M2, D1, D2;
340
341  Int_t Charge;
342
343  Float_t Mass;
344 
345  Int_t IsPU;
346  Int_t IsConstituent;
347 
348  UInt_t BTag;
349  UInt_t TauTag;
350
351  Float_t Eem;
352  Float_t Ehad;
353
354  Float_t Edges[4];
355  Float_t DeltaEta;
356  Float_t DeltaPhi;
357
358  TLorentzVector Momentum, Position, Area;
359
360  static CompBase *fgCompare; //!
361  const CompBase *GetCompare() const { return fgCompare; }
362
363  void AddCandidate(Candidate *object);
364  TObjArray *GetCandidates();
365
366  Bool_t Overlaps(const Candidate *object) const;
367
368  virtual void Copy(TObject &object) const;
369  virtual TObject *Clone(const char *newname = "") const;
370  virtual void Clear(Option_t* option = "");
371
372private:
373  DelphesFactory *fFactory; //!
374  TObjArray *fArray; //!
375 
376  void SetFactory(DelphesFactory *factory) { fFactory = factory; }
377
378  ClassDef(Candidate, 1)
379};
380
381#endif // DelphesClasses_h
382
383
Note: See TracBrowser for help on using the repository browser.