Fork me on GitHub

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

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

TRootZdcHits ok ; new class TRootForwardTaggerHits
File size: 16.5 KB
Line 
1#ifndef BLOCKCLASSES_H
2#define BLOCKCLASSES_H
3
4/***********************************************************************
5** **
6** /----------------------------------------------\ **
7** | Delphes, a framework for the fast simulation | **
8** | of a generic collider experiment | **
9** \----------------------------------------------/ **
10** **
11** **
12** This package uses: **
13** ------------------ **
14** FastJet algorithm: Phys. Lett. B641 (2006) [hep-ph/0512210] **
15** Hector: JINST 2:P09005 (2007) [physics.acc-ph:0707.1198v2] **
16** FROG: [hep-ex/0901.2718v1] **
17** **
18** ------------------------------------------------------------------ **
19** **
20** Main authors: **
21** ------------- **
22** **
23** Severine Ovyn Xavier Rouby **
24** severine.ovyn@uclouvain.be xavier.rouby@cern **
25** **
26** Center for Particle Physics and Phenomenology (CP3) **
27** Universite catholique de Louvain (UCL) **
28** Louvain-la-Neuve, Belgium **
29** **
30** Copyright (C) 2008-2009, **
31** All rights reserved. **
32** **
33***********************************************************************/
34
35#include "TLorentzVector.h"
36#include "TObject.h"
37#include "BlockCompare.h"
38#include "interface/D_Constants.h"
39#include "interface/CaloUtil.h"
40
41class TSortableObject: public TObject
42{
43public:
44 TSortableObject() {};
45 Bool_t IsSortable() const { return GetCompare() ? GetCompare()->IsSortable(this) : kFALSE; }
46 Int_t Compare(const TObject *obj) const { return GetCompare()->Compare(this, obj); }
47
48 virtual const TCompare *GetCompare() const = 0;
49
50 ClassDef(TSortableObject, 1)
51};
52
53//---------------------------------------------------------------------------
54//
55class TRootLHEFEvent: public TObject
56{
57public:
58 TRootLHEFEvent() {};
59
60 Long64_t Number; // event number
61
62 int Nparticles; // number of particles in the event | hepup.NUP
63 int ProcessID; // subprocess code for the event | hepup.IDPRUP
64
65 Double_t Weight; // weight for the event | hepup.XWGTUP
66 Double_t ScalePDF; // scale in GeV used in the calculation of the PDFs in the event | hepup.SCALUP
67 Double_t CouplingQED; // value of the QED coupling used in the event | hepup.AQEDUP
68 Double_t CouplingQCD; // value of the QCD coupling used in the event | hepup.AQCDUP
69
70 ClassDef(TRootLHEFEvent, 2)
71};
72
73//---------------------------------------------------------------------------
74
75class TRootLHEFParticle: public TSortableObject
76{
77public:
78 TRootLHEFParticle() {};
79 int PID; // particle HEP ID number | hepup.IDUP[number]
80 int Status; // particle status code | hepup.ISTUP[number]
81 int Mother1; // index for the particle first mother | hepup.MOTHUP[number][0]
82 int Mother2; // index for the particle last mother | hepup.MOTHUP[number][1]
83 int ColorLine1; // index for the particle color-line | hepup.ICOLUP[number][0]
84 int ColorLine2; // index for the particle anti-color-line | hepup.ICOLUP[number][1]
85
86 double Px; // particle momentum vector (x component) | hepup.PUP[number][0]
87 double Py; // particle momentum vector (y component) | hepup.PUP[number][1]
88 double Pz; // particle momentum vector (z component) | hepup.PUP[number][2]
89 double E; // particle energy | hepup.PUP[number][3]
90 double M; // particle mass | hepup.PUP[number][4]
91
92 double PT; // particle transverse momentum
93 double Eta; // particle pseudorapidity
94 double Phi; // particle azimuthal angle
95
96 double Rapidity; // particle rapidity
97
98 double LifeTime; // particle invariant lifetime
99 // (c*tau, distance from production to decay in mm)
100 // | hepup.VTIMUP[number]
101
102 double Spin; // cosine of the angle between the particle spin vector
103 // and the decaying particle 3-momentum,
104 // specified in the lab frame. | hepup.SPINUP[number]
105
106 static TCompare *fgCompare; //!
107 const TCompare *GetCompare() const { return fgCompare; }
108 ClassDef(TRootLHEFParticle, 2)
109
110};
111
112//---------------------------------------------------------------------------
113
114class TRootSelectorInfo: public TObject
115{
116public:
117 TRootSelectorInfo() {};
118 int Processed; // current number of processed events
119 int Accepted; // current number of accepted events
120
121 ClassDef(TRootSelectorInfo, 1)
122};
123
124
125class TRootGenEvent: public TObject
126{
127public:
128 TRootGenEvent() {};
129 Long64_t Number; // event number | hepevt.nevhep
130
131 static TCompare *fgCompare; //!
132 const TCompare *GetCompare() const { return fgCompare; }
133
134 ClassDef(TRootGenEvent, 1)
135};
136
137
138class TRootEvent: public TObject {
139
140public:
141 TRootEvent() {};
142 int Run; // run number [G3EventProxy::simSignal().id().runNumber()]
143 int Event; // event number [G3EventProxy::simSignal().id().eventInRun()]
144
145// Short_t L1Decision; // L1 trigger global decision [L1Trigger::decision()]
146// Short_t HLTDecision; // HLT trigger global decision [HighLevelTriggerResult::getGlobalDecision()]
147
148 ClassDef(TRootEvent, 1)
149};
150
151//---------------------------------------------------------------------------
152
153class TRootParticle: public TSortableObject {
154
155public:
156
157 TRootParticle() {};
158 float E; // particle energy in GeV
159 float Px; // particle momentum vector (x component) in GeV
160 float Py; // particle momentum vector (y component) in GeV
161 float Pz; // particle momentum vector (z component) in GeV
162
163 float Eta; // particle pseudorapidity
164 float Phi; // particle azimuthal angle in rad
165
166 void Set(const TLorentzVector& momentum);
167 void Set(const float px, const float py, const float pz, const float e);
168 void SetEtaPhi(const float eta, const float phi) {Eta=eta; Phi=phi;};
169 void SetEtaPhiEET(const float eta, const float phi, const float e, const float et);
170 static TCompare *fgCompare; //!
171 const TCompare *GetCompare() const { return fgCompare; }
172 float PT; // particle transverse momentum in GeV
173
174 ClassDef(TRootParticle, 1)
175};
176
177//--------------------------------------------------------------------------
178class TRootGenParticle;
179
180namespace TRootC {
181class GenParticle: public TRootParticle {
182
183public:
184 GenParticle() {};
185 GenParticle(const TRootGenParticle& p);
186 int PID; // particle HEP ID number [RawHepEventParticle::pid()]
187 int Status; // particle status [RawHepEventParticle::status()]
188 int M1; // particle 1st mother [RawHepEventParticle::mother1() - 1]
189 int M2; // particle 2nd mother [RawHepEventParticle::mother2() - 1]
190 int D1; // particle 1st daughter [RawHepEventParticle::daughter1() - 1]
191 int D2; // particle 2nd daughter [RawHepEventParticle::daughter2() - 1]
192
193 float Charge;
194
195 float T; // particle vertex position (t component) [RawHepEventParticle::t()]
196 float X; // particle vertex position (x component) [RawHepEventParticle::x()]
197 float Y; // particle vertex position (y component) [RawHepEventParticle::y()]
198 float Z; // particle vertex position (z component) [RawHepEventParticle::z()]
199 float M;
200
201
202 static TCompare *fgCompare; //!
203
204 ClassDef(GenParticle, 1)
205};
206}
207
208//---------------------------------------------------------------------------
209
210class TRootGenParticle: public TRootParticle {
211
212public:
213 TRootGenParticle() {_initialised=false;}
214 TRootGenParticle(const int pid): PID(pid) {_initialised=false;}
215 TRootGenParticle(TRootC::GenParticle* part);
216
217 int PID; // particle HEP ID number [RawHepEventParticle::pid()]
218 int Status; // particle status [RawHepEventParticle::status()]
219 int M1; // particle 1st mother [RawHepEventParticle::mother1() - 1]
220 int M2; // particle 2nd mother [RawHepEventParticle::mother2() - 1]
221 int D1; // particle 1st daughter [RawHepEventParticle::daughter1() - 1]
222 int D2; // particle 2nd daughter [RawHepEventParticle::daughter2() - 1]
223
224 float T; // particle vertex position (t component) [RawHepEventParticle::t()]
225 float X; // particle vertex position (x component) [RawHepEventParticle::x()]
226 float Y; // particle vertex position (y component) [RawHepEventParticle::y()]
227 float Z; // particle vertex position (z component) [RawHepEventParticle::z()]
228 float M;
229 void setFractions();
230 const float getFem() {if(!_initialised) setFractions(); return _Fem;}
231 const float getFhad() {if(!_initialised) setFractions(); return _Fhad;}
232
233 float EtaCalo; // particle pseudorapidity when entering the calo,
234 float PhiCalo; // particle azimuthal angle in rad when entering the calo
235 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
236
237 static TCompare *fgCompare; //!
238
239 float Charge; // electrical charge
240 protected:
241 float _Fem, _Fhad; // fractions of energy deposit
242 bool _initialised;
243 ClassDef(TRootGenParticle, 1)
244};
245
246
247//------------------------------------------------------------------------------
248
249class TRootElectron: public TRootParticle {
250public:
251 TRootElectron():Charge(-999), IsolFlag(false), IsolPt(UNDEFINED), EtaCalo(UNDEFINED), PhiCalo(UNDEFINED), EHoverEE(UNDEFINED){};
252 static TCompare *fgCompare; //!
253 int Charge; // particle Charge [RawHepEventParticle::pid()]
254 bool IsolFlag; // stores the result of the isolation test
255 float IsolPt; // sum of pt around the electron, for isolation criteria
256 float EtaCalo; // particle pseudorapidity when entering the calo,
257 float PhiCalo; // particle azimuthal angle in rad when entering the calo
258 float EHoverEE;
259
260 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
261
262 ClassDef(TRootElectron, 1)
263};
264
265//------------------------------------------------------------------------------
266
267class TRootPhoton: public TRootParticle {
268public:
269 TRootPhoton() : EHoverEE(UNDEFINED) {};
270 static TCompare *fgCompare; //!
271
272 float EHoverEE;
273 ClassDef(TRootPhoton, 1)
274};
275
276
277//------------------------------------------------------------------------------
278
279class TRootMuon: public TRootParticle {
280public:
281 TRootMuon():Charge(-999), IsolFlag(false), IsolPt(UNDEFINED), EtaCalo(UNDEFINED), PhiCalo(UNDEFINED),
282 EHoverEE(UNDEFINED), EtRatio(UNDEFINED) {};
283 static TCompare *fgCompare; //!
284 int Charge; // particle Charge [RawHepEventParticle::pid()]
285 bool IsolFlag;
286 float IsolPt;
287 float EtaCalo; // particle pseudorapidity when entering the calo,
288 float PhiCalo; // particle azimuthal angle in rad when entering the calo
289 float EHoverEE; // hadronic energy over electromagnetic energy
290 float EtRatio; // calo Et in NxN-tower grid around the muon over the muon Et
291
292 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
293 ClassDef(TRootMuon, 1)
294};
295
296//---------------------------------------------------------------------------
297
298class TRootTracks : public TSortableObject {
299 public:
300 TRootTracks(); // needed for storage in ExRootAnalysis
301 TRootTracks(const TRootTracks& track);
302 TRootTracks(const float inEta, const float inPhi, const float outEta, const float outPhi, const float pt);
303 TRootTracks& operator=(const TRootTracks& track);
304 void Set(const float inEta, const float inPhi, const float outEta, const float outPhi, const float pt, const float charge);
305 const TLorentzVector GetFourVector() const;
306 const float getEta() const {return Eta;}
307 const float getPhi() const {return Phi;}
308 const float getEtaOuter() const {return EtaOuter;}
309 const float getPhiOuter() const {return PhiOuter;}
310
311 static TCompare *fgCompare; //!
312 const TCompare *GetCompare() const { return fgCompare; }
313
314 float Eta, Phi; // (eta,phi) at the beginning of the track
315 float EtaOuter, PhiOuter; // (eta,phi) at the end of the track
316 float PT, E, Px, Py, Pz; // transverse momentum
317 float Charge;
318 ClassDef(TRootTracks, 1)
319};
320
321//---------------------------------------------------------------------------
322
323class TRootCalo: public TSortableObject
324{
325//class TRootCalo: public TRootParticle {
326 public:
327 float Eta;
328 float Phi;
329 float E;
330 TRootCalo() ;
331 TRootCalo(const TRootCalo& cal);
332 TRootCalo& operator=(const TRootCalo& cal);
333 void set(const D_CaloTower& cal);
334 static TCompare *fgCompare; //!
335 const TCompare *GetCompare() const { return fgCompare; }
336 const float getET() const {return ET;}
337
338 protected:
339 float E_em, E_had; // electromagnetic and hadronic components of the tower energy
340 float ET; // total energy and transverse energy
341 ClassDef(TRootCalo, 1)
342};
343
344//---------------------------------------------------------------------------
345class TRootZdcHits: public TSortableObject
346{
347public:
348
349 TRootZdcHits() {}; // do not put anything for the default constructor-- ExRootAnalysis constrain!!!
350 TRootZdcHits(const float e, const float t, const int side, const bool had);
351 TRootZdcHits(const TRootZdcHits& zdc);
352 TRootZdcHits& operator=(const TRootZdcHits& zdc);
353 const TCompare *GetCompare() const { return fgCompare; }
354 float E;
355 float T; // time of flight [s]
356 int side; // -1 or +1
357 static TCompare *fgCompare; //!
358 bool hadronic_hit; // true if neutron, false if photon
359
360 ClassDef(TRootZdcHits, 2)
361};
362
363//---------------------------------------------------------------------------
364
365class TRootTauJet: public TRootParticle
366{
367public:
368 TRootTauJet() {};
369 float Charge; // normally, using the charge of the track ; here using gen-level tau charge
370 int NTracks;
371
372 float EHoverEE;
373// float E; // particle energy in GeV
374// float Px; // particle momentum vector (x component) in GeV
375// float Py; // particle momentum vector (y component) in GeV
376// float Pz; // particle momentum vector (z component) in GeV
377
378// float Eta; // particle pseudorapidity
379// float Phi; // particle azimuthal angle in rad
380
381 void Set(const TLorentzVector& momentum);// { return TRootParticle::Set(momentum); }
382
383 static TCompare *fgCompare; //!
384
385 // float PT; // particle transverse momentum in GeV
386
387 ClassDef(TRootTauJet, 1)
388};
389
390//---------------------------------------------------------------------------
391
392class TRootJet: public TRootParticle
393{
394public:
395 TRootJet() {};
396
397 static TCompare *fgCompare; //!
398
399 bool Btag;
400 int NTracks;
401
402 float EHoverEE;
403 ClassDef(TRootJet, 1)
404};
405
406//------------------------------------------------------------------------------
407
408class TRootTrigger: public TSortableObject
409{
410public:
411 TRootTrigger() {};
412
413 int Accepted;
414
415 static TCompare *fgCompare; //!
416 const TCompare *GetCompare() const { return fgCompare; }
417
418 ClassDef(TRootTrigger, 1)
419};
420//---------------------------------------------------------------------------
421
422class TRootETmis: public TSortableObject
423{
424public:
425 TRootETmis() {};
426 float ET; // jet energy [RecJet::getEnergy()]
427 float Phi; // jet azimuthal angle [RecJet::getPhi()]
428 float Px;
429 float Py;
430
431 static TCompare *fgCompare; //!
432 const TCompare *GetCompare() const { return fgCompare; }
433
434 ClassDef(TRootETmis, 1)
435};
436
437//---------------------------------------------------------------------------
438
439class TRootRomanPotHits: public TSortableObject
440{
441public:
442 TRootRomanPotHits() {};
443 // float T; // time of flight to the detector [s]
444 float S; // distance to the IP [m]
445 float E; // reconstructed energy [GeV]
446 float q2; // reconstructed squared momentum transfer [GeV^2]
447
448 float X; // horizontal distance to the beam [um]
449 float Y; // vertical distance to the beam [um]
450
451 float Tx; // angle of the momentum in the horizontal (x,z) plane [urad]
452 float Ty; // angle of the momentum in the verical (y,z) plane [urad]
453
454 int side; // -1 or 1
455
456 static TCompare *fgCompare; //!
457 const TCompare *GetCompare() const { return fgCompare; }
458
459 ClassDef(TRootRomanPotHits, 1)
460};
461
462//---------------------------------------------------------------------------
463
464class TRootForwardTaggerHits : public TRootRomanPotHits
465{
466public:
467 TRootForwardTaggerHits() {};
468 float T; // time of flight to the detector [s]
469
470 static TCompare *fgCompare; //!
471 const TCompare *GetCompare() const { return fgCompare; }
472
473 ClassDef(TRootForwardTaggerHits, 1)
474};
475
476
477#endif // BLOCKCLASSES_H
478
Note: See TracBrowser for help on using the repository browser.