Fork me on GitHub

source: svn/trunk/Utilities/ExRootAnalysis/interface/BlockClasses.h@ 218

Last change on this file since 218 was 192, checked in by Xavier Rouby, 16 years ago

minor change

File size: 10.0 KB
Line 
1#ifndef BLOCKCLASSES_H
2#define BLOCKCLASSES_H
3
4/** \class BlockClasses
5 *
6 * Definition of classes to be stored in root tree.
7 * You can decide to have the objects in each event to be sorted according
8 * to one of the data member of the class. If you decide so then a class
9 * inheriting from class TCompare should be implemented.
10 * There are already several functions TCompare*** implemented
11 * (see BlockCompare.h).
12 * Function TCompareXX sorts objects by the variable "XX" that MUST be
13 * present in the data members of the Block TRoot class.
14 *
15 * $Date: 2009-01-26 14:43:09 $
16 * $Revision: 1.10 $
17 *
18 *
19 * \author P. Demin - UCL, Louvain-la-Neuve
20 *
21 */
22
23// Dependencies (#includes)
24
25#include "TLorentzVector.h"
26#include "TRef.h"
27#include "TObject.h"
28#include "TRefArray.h"
29
30#include "Utilities/ExRootAnalysis/interface/BlockCompare.h"
31//---------------------------------------------------------------------------
32//
33class TSortableObject: public TObject
34{
35public:
36 TSortableObject() {};
37 Bool_t IsSortable() const { return GetCompare() ? GetCompare()->IsSortable(this) : kFALSE; }
38 Int_t Compare(const TObject *obj) const { return GetCompare()->Compare(this, obj); }
39
40 virtual const TCompare *GetCompare() const = 0;
41
42 ClassDef(TSortableObject, 1)
43};
44
45
46//---------------------------------------------------------------------------
47//
48class TRootLHEFEvent: public TObject
49{
50public:
51 TRootLHEFEvent() {};
52
53 Long64_t Number; // event number
54
55 int Nparticles; // number of particles in the event | hepup.NUP
56 int ProcessID; // subprocess code for the event | hepup.IDPRUP
57
58 Double_t Weight; // weight for the event | hepup.XWGTUP
59 Double_t ScalePDF; // scale in GeV used in the calculation of the PDFs in the event | hepup.SCALUP
60 Double_t CouplingQED; // value of the QED coupling used in the event | hepup.AQEDUP
61 Double_t CouplingQCD; // value of the QCD coupling used in the event | hepup.AQCDUP
62
63 ClassDef(TRootLHEFEvent, 2)
64};
65
66//---------------------------------------------------------------------------
67
68class TRootLHEFParticle: public TSortableObject
69{
70public:
71 TRootLHEFParticle() {};
72 int PID; // particle HEP ID number | hepup.IDUP[number]
73 int Status; // particle status code | hepup.ISTUP[number]
74 int Mother1; // index for the particle first mother | hepup.MOTHUP[number][0]
75 int Mother2; // index for the particle last mother | hepup.MOTHUP[number][1]
76 int ColorLine1; // index for the particle color-line | hepup.ICOLUP[number][0]
77 int ColorLine2; // index for the particle anti-color-line | hepup.ICOLUP[number][1]
78
79 double Px; // particle momentum vector (x component) | hepup.PUP[number][0]
80 double Py; // particle momentum vector (y component) | hepup.PUP[number][1]
81 double Pz; // particle momentum vector (z component) | hepup.PUP[number][2]
82 double E; // particle energy | hepup.PUP[number][3]
83 double M; // particle mass | hepup.PUP[number][4]
84
85 double PT; // particle transverse momentum
86 double Eta; // particle pseudorapidity
87 double Phi; // particle azimuthal angle
88
89 double Rapidity; // particle rapidity
90
91 double LifeTime; // particle invariant lifetime
92 // (c*tau, distance from production to decay in mm)
93 // | hepup.VTIMUP[number]
94
95 double Spin; // cosine of the angle between the particle spin vector
96 // and the decaying particle 3-momentum,
97 // specified in the lab frame. | hepup.SPINUP[number]
98
99 static TCompare *fgCompare; //!
100 const TCompare *GetCompare() const { return fgCompare; }
101 ClassDef(TRootLHEFParticle, 2)
102
103};
104
105//---------------------------------------------------------------------------
106
107class TRootSelectorInfo: public TObject
108{
109public:
110 TRootSelectorInfo() {};
111 int Processed; // current number of processed events
112 int Accepted; // current number of accepted events
113
114 ClassDef(TRootSelectorInfo, 1)
115};
116
117
118class TRootGenEvent: public TObject
119{
120public:
121 TRootGenEvent() {};
122 Long64_t Number; // event number | hepevt.nevhep
123
124 static TCompare *fgCompare; //!
125 const TCompare *GetCompare() const { return fgCompare; }
126
127 ClassDef(TRootGenEvent, 1)
128};
129
130
131class TRootEvent: public TObject {
132
133public:
134 TRootEvent() {};
135 int Run; // run number [G3EventProxy::simSignal().id().runNumber()]
136 int Event; // event number [G3EventProxy::simSignal().id().eventInRun()]
137
138// Short_t L1Decision; // L1 trigger global decision [L1Trigger::decision()]
139// Short_t HLTDecision; // HLT trigger global decision [HighLevelTriggerResult::getGlobalDecision()]
140
141 ClassDef(TRootEvent, 1)
142};
143
144//---------------------------------------------------------------------------
145
146class TRootParticle: public TSortableObject {
147
148public:
149
150 TRootParticle() {};
151 float E; // particle energy in GeV
152 float Px; // particle momentum vector (x component) in GeV
153 float Py; // particle momentum vector (y component) in GeV
154 float Pz; // particle momentum vector (z component) in GeV
155
156 float PT; // particle transverse momentum in GeV
157 float Eta; // particle pseudorapidity
158 float Phi; // particle azimuthal angle in rad
159
160 void Set(const TLorentzVector& momentum);
161 void Set(const float px, const float py, const float pz, const float e);
162 static TCompare *fgCompare; //!
163 const TCompare *GetCompare() const { return fgCompare; }
164
165 ClassDef(TRootParticle, 1)
166};
167
168
169//---------------------------------------------------------------------------
170
171class TRootGenParticle: public TRootParticle {
172
173public:
174 TRootGenParticle() {};
175 int PID; // particle HEP ID number [RawHepEventParticle::pid()]
176 int Status; // particle status [RawHepEventParticle::status()]
177 int M1; // particle 1st mother [RawHepEventParticle::mother1() - 1]
178 int M2; // particle 2nd mother [RawHepEventParticle::mother2() - 1]
179 int D1; // particle 1st daughter [RawHepEventParticle::daughter1() - 1]
180 int D2; // particle 2nd daughter [RawHepEventParticle::daughter2() - 1]
181 float Charge; // electrical charge
182
183 float T; // particle vertex position (t component) [RawHepEventParticle::t()]
184 float X; // particle vertex position (x component) [RawHepEventParticle::x()]
185 float Y; // particle vertex position (y component) [RawHepEventParticle::y()]
186 float Z; // particle vertex position (z component) [RawHepEventParticle::z()]
187 float M;
188 static TCompare *fgCompare; //!
189
190 ClassDef(TRootGenParticle, 1)
191};
192
193//------------------------------------------------------------------------------
194
195class TRootElectron: public TRootParticle
196{
197public:
198 TRootElectron() {};
199 int Charge; // particle Charge [RawHepEventParticle::pid()]
200 static TCompare *fgCompare; //!
201
202 bool IsolFlag;
203
204 ClassDef(TRootElectron, 1)
205};
206
207//------------------------------------------------------------------------------
208
209class TRootPhoton: public TRootParticle
210{
211public:
212 TRootPhoton() {};
213 static TCompare *fgCompare; //!
214
215 ClassDef(TRootPhoton, 1)
216};
217
218
219//------------------------------------------------------------------------------
220
221class TRootMuon: public TRootParticle
222{
223public:
224 TRootMuon() {};
225 int Charge; // particle Charge [RawHepEventParticle::pid()]
226 bool IsolFlag;
227 static TCompare *fgCompare; //!
228
229 ClassDef(TRootMuon, 1)
230};
231
232//---------------------------------------------------------------------------
233
234class TRootTracks: public TRootParticle
235{
236public:
237 TRootTracks() : Etaout(0), Phiout(0) {};
238 static TCompare *fgCompare; //!
239
240// float X, Y, Z; // coordinates of the beginning of the track
241// float Xout, Yout, Zout; // coordinates of the end of the track
242 float Etaout, Phiout; // coordinates of the end of the track
243// void SetPosition(const float x, const float y, const float z) {X=x; Y=y; Z=z;}
244// void SetPositionOut(const float x, const float y, const float z) {Xout=x; Yout=y; Zout=z;}
245 ClassDef(TRootTracks, 1)
246};
247
248//---------------------------------------------------------------------------
249
250class TRootCalo: public TRootParticle
251{
252public:
253 TRootCalo() {};
254 static TCompare *fgCompare; //!
255
256 ClassDef(TRootCalo, 1)
257};
258
259//---------------------------------------------------------------------------
260class TRootZdcHits: public TRootParticle
261{
262public:
263 TRootZdcHits() {};
264 float T; // time of flight [s]
265 int side; // -1 or +1
266 static TCompare *fgCompare; //!
267
268 ClassDef(TRootZdcHits, 1)
269};
270
271//---------------------------------------------------------------------------
272
273class TRootJet: public TRootParticle
274{
275public:
276 TRootJet() {};
277 bool Btag;
278
279 static TCompare *fgCompare; //!
280
281 ClassDef(TRootJet, 1)
282};
283
284//---------------------------------------------------------------------------
285
286class TRootTauJet: public TRootParticle
287{
288public:
289 TRootTauJet() {};
290 static TCompare *fgCompare; //!
291
292 ClassDef(TRootTauJet, 1)
293};
294
295class TRootTrigger: public TSortableObject
296{
297public:
298 TRootTrigger() {};
299
300 int Accepted;
301
302 static TCompare *fgCompare; //!
303 const TCompare *GetCompare() const { return fgCompare; }
304
305 ClassDef(TRootTrigger, 1)
306};
307//---------------------------------------------------------------------------
308
309class TRootETmis: public TSortableObject
310{
311public:
312 TRootETmis() {};
313 float ET; // jet energy [RecJet::getEnergy()]
314 float Phi; // jet azimuthal angle [RecJet::getPhi()]
315 float Px;
316 float Py;
317
318 static TCompare *fgCompare; //!
319 const TCompare *GetCompare() const { return fgCompare; }
320
321 ClassDef(TRootETmis, 1)
322};
323
324//---------------------------------------------------------------------------
325
326class TRootRomanPotHits: public TSortableObject
327{
328public:
329 TRootRomanPotHits() {};
330 float T; // time of flight to the detector [s]
331 float S; // distance to the IP [m]
332 float E; // reconstructed energy [GeV]
333 float q2; // reconstructed squared momentum transfer [GeV^2]
334
335 float X; // horizontal distance to the beam [um]
336 float Y; // vertical distance to the beam [um]
337
338 float Tx; // angle of the momentum in the horizontal (x,z) plane [urad]
339 float Ty; // angle of the momentum in the verical (y,z) plane [urad]
340
341 int side; // -1 or 1
342
343 static TCompare *fgCompare; //!
344 const TCompare *GetCompare() const { return fgCompare; }
345
346 ClassDef(TRootRomanPotHits, 1)
347};
348
349//---------------------------------------------------------------------------
350
351#endif // BLOCKCLASSES_H
352
Note: See TracBrowser for help on using the repository browser.