Fork me on GitHub

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

Last change on this file since 477 was 450, checked in by Xavier Rouby, 15 years ago

lhe bug (empty Analysis tree) solved
File size: 18.9 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
75//---------------------------------------------------------------------------
76/*
77class TRootLHEFParticle: public TSortableObject
78{
79public:
80 TRootLHEFParticle() {};
81 int PID; // particle HEP ID number | hepup.IDUP[number]
82 int Status; // particle status code | hepup.ISTUP[number]
83 int Mother1; // index for the particle first mother | hepup.MOTHUP[number][0]
84 int Mother2; // index for the particle last mother | hepup.MOTHUP[number][1]
85 int ColorLine1; // index for the particle color-line | hepup.ICOLUP[number][0]
86 int ColorLine2; // index for the particle anti-color-line | hepup.ICOLUP[number][1]
87
88 double Px; // particle momentum vector (x component) | hepup.PUP[number][0]
89 double Py; // particle momentum vector (y component) | hepup.PUP[number][1]
90 double Pz; // particle momentum vector (z component) | hepup.PUP[number][2]
91 double E; // particle energy | hepup.PUP[number][3]
92 double M; // particle mass | hepup.PUP[number][4]
93 double Charge; // particle charge
94
95 double PT; // particle transverse momentum
96 double Eta; // particle pseudorapidity
97 double Phi; // particle azimuthal angle
98
99 double Rapidity; // particle rapidity
100
101 double LifeTime; // particle invariant lifetime
102 // (c*tau, distance from production to decay in mm)
103 // | hepup.VTIMUP[number]
104
105 double Spin; // cosine of the angle between the particle spin vector
106 // and the decaying particle 3-momentum,
107 // specified in the lab frame. | hepup.SPINUP[number]
108
109 static TCompare *fgCompare; //!
110 const TCompare *GetCompare() const { return fgCompare; }
111 ClassDef(TRootLHEFParticle, 2)
112
113};
114*/
115//---------------------------------------------------------------------------
116
117class TRootSelectorInfo: public TObject
118{
119public:
120 TRootSelectorInfo() {};
121 int Processed; // current number of processed events
122 int Accepted; // current number of accepted events
123
124 ClassDef(TRootSelectorInfo, 1)
125};
126
127
128class TRootGenEvent: public TObject
129{
130public:
131 TRootGenEvent() {};
132 Long64_t Number; // event number | hepevt.nevhep
133
134 static TCompare *fgCompare; //!
135 const TCompare *GetCompare() const { return fgCompare; }
136
137 ClassDef(TRootGenEvent, 1)
138};
139
140
141class TRootEvent: public TObject {
142
143public:
144 TRootEvent() {};
145 int Run; // run number [G3EventProxy::simSignal().id().runNumber()]
146 int Event; // event number [G3EventProxy::simSignal().id().eventInRun()]
147
148// Short_t L1Decision; // L1 trigger global decision [L1Trigger::decision()]
149// Short_t HLTDecision; // HLT trigger global decision [HighLevelTriggerResult::getGlobalDecision()]
150
151 ClassDef(TRootEvent, 1)
152};
153
154//---------------------------------------------------------------------------
155
156class TRootParticle: public TSortableObject {
157
158public:
159
160 TRootParticle() {};
161 float E; // particle energy in GeV
162 float Px; // particle momentum vector (x component) in GeV
163 float Py; // particle momentum vector (y component) in GeV
164 float Pz; // particle momentum vector (z component) in GeV
165
166 float Eta; // particle pseudorapidity
167 float Phi; // particle azimuthal angle in rad
168
169 void Set(const TLorentzVector& momentum);
170 void Set(const float px, const float py, const float pz, const float e);
171 void SetEtaPhi(const float eta, const float phi) {Eta=eta; Phi=phi;};
172 void SetEtaPhiEET(const float eta, const float phi, const float e, const float et);
173 static TCompare *fgCompare; //!
174 const TCompare *GetCompare() const { return fgCompare; }
175 float PT; // particle transverse momentum in GeV
176
177 ClassDef(TRootParticle, 1)
178};
179
180//--------------------------------------------------------------------------
181class TRootGenParticle;
182
183namespace TRootC {
184class GenParticle: public TRootParticle {
185
186public:
187 GenParticle() {};
188 GenParticle(const TRootGenParticle& p);
189 int PID; // particle HEP ID number [RawHepEventParticle::pid()]
190 int Status; // particle status [RawHepEventParticle::status()]
191 int M1; // particle 1st mother [RawHepEventParticle::mother1() - 1]
192 int M2; // particle 2nd mother [RawHepEventParticle::mother2() - 1]
193 int D1; // particle 1st daughter [RawHepEventParticle::daughter1() - 1]
194 int D2; // particle 2nd daughter [RawHepEventParticle::daughter2() - 1]
195
196 float Charge;
197
198 float T; // particle vertex position (t component) [RawHepEventParticle::t()]
199 float X; // particle vertex position (x component) [RawHepEventParticle::x()]
200 float Y; // particle vertex position (y component) [RawHepEventParticle::y()]
201 float Z; // particle vertex position (z component) [RawHepEventParticle::z()]
202 float M;
203
204
205 static TCompare *fgCompare; //!
206
207 ClassDef(GenParticle, 1)
208};
209}
210
211//---------------------------------------------------------------------------
212
213class TRootGenParticle: public TRootParticle {
214
215public:
216 TRootGenParticle() {_initialised=false; M=-9999.; }
217 TRootGenParticle(const int pid): PID(pid) {_initialised=false;}
218 TRootGenParticle(TRootC::GenParticle* part);
219
220 int PID; // particle HEP ID number [RawHepEventParticle::pid()]
221 int Status; // particle status [RawHepEventParticle::status()]
222 int M1; // particle 1st mother [RawHepEventParticle::mother1() - 1]
223 int M2; // particle 2nd mother [RawHepEventParticle::mother2() - 1]
224 int D1; // particle 1st daughter [RawHepEventParticle::daughter1() - 1]
225 int D2; // particle 2nd daughter [RawHepEventParticle::daughter2() - 1]
226
227 float T; // particle vertex position (t component) [RawHepEventParticle::t()]
228 float X; // particle vertex position (x component) [RawHepEventParticle::x()]
229 float Y; // particle vertex position (y component) [RawHepEventParticle::y()]
230 float Z; // particle vertex position (z component) [RawHepEventParticle::z()]
231 float M;
232 void setFractions();
233 const float getFem() {if(!_initialised) setFractions(); return _Fem;}
234 const float getFhad() {if(!_initialised) setFractions(); return _Fhad;}
235
236 float EtaCalo; // particle pseudorapidity when entering the calo,
237 float PhiCalo; // particle azimuthal angle in rad when entering the calo
238 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
239
240 void print();//
241
242 static TCompare *fgCompare; //!
243
244 float Charge; // electrical charge
245 protected:
246 float _Fem, _Fhad; // fractions of energy deposit
247 bool _initialised;
248 ClassDef(TRootGenParticle, 1)
249};
250
251
252//------------------------------------------------------------------------------
253
254class TRootElectron: public TRootParticle {
255public:
256 TRootElectron():Charge(-999), IsolFlag(false), IsolPt(UNDEFINED), EtaCalo(UNDEFINED), PhiCalo(UNDEFINED), EHoverEE(UNDEFINED){};
257 static TCompare *fgCompare; //!
258 int Charge; // particle Charge [RawHepEventParticle::pid()]
259 bool IsolFlag; // stores the result of the isolation test
260 float IsolPt; // sum of pt around the electron, for isolation criteria
261 float EtaCalo; // particle pseudorapidity when entering the calo,
262 float PhiCalo; // particle azimuthal angle in rad when entering the calo
263 float EHoverEE;
264
265 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
266
267 ClassDef(TRootElectron, 1)
268};
269
270//------------------------------------------------------------------------------
271
272class TRootPhoton: public TRootParticle {
273public:
274 TRootPhoton() : EHoverEE(UNDEFINED) {};
275 static TCompare *fgCompare; //!
276
277 float EHoverEE;
278 ClassDef(TRootPhoton, 1)
279};
280
281
282//------------------------------------------------------------------------------
283
284class TRootMuon: public TRootParticle {
285public:
286 TRootMuon():Charge(-999), IsolFlag(false), IsolPt(UNDEFINED), EtaCalo(UNDEFINED), PhiCalo(UNDEFINED),
287 EHoverEE(UNDEFINED), EtRatio(UNDEFINED) {};
288 static TCompare *fgCompare; //!
289 int Charge; // particle Charge [RawHepEventParticle::pid()]
290 bool IsolFlag;
291 float IsolPt;
292 float EtaCalo; // particle pseudorapidity when entering the calo,
293 float PhiCalo; // particle azimuthal angle in rad when entering the calo
294 float EHoverEE; // hadronic energy over electromagnetic energy
295 float EtRatio; // calo Et in NxN-tower grid around the muon over the muon Et
296
297 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
298 ClassDef(TRootMuon, 1)
299};
300
301//---------------------------------------------------------------------------
302
303class TRootTracks : public TSortableObject {
304 public:
305 TRootTracks(); // needed for storage in ExRootAnalysis
306 TRootTracks(const TRootTracks& track);
307 TRootTracks(const float inEta, const float inPhi, const float outEta, const float outPhi, const float pt);
308 TRootTracks& operator=(const TRootTracks& track);
309 void Set(const float inEta, const float inPhi, const float outEta, const float outPhi, const float pt, const float charge);
310 const TLorentzVector GetFourVector() const;
311 const float getEta() const {return Eta;}
312 const float getPhi() const {return Phi;}
313 const float getEtaOuter() const {return EtaOuter;}
314 const float getPhiOuter() const {return PhiOuter;}
315
316 static TCompare *fgCompare; //!
317 const TCompare *GetCompare() const { return fgCompare; }
318
319 float Eta, Phi; // (eta,phi) at the beginning of the track
320 float EtaOuter, PhiOuter; // (eta,phi) at the end of the track
321 float PT, E, Px, Py, Pz; // transverse momentum
322 float Charge;
323 ClassDef(TRootTracks, 1)
324};
325
326//---------------------------------------------------------------------------
327
328class TRootCalo: public TSortableObject
329{
330//class TRootCalo: public TRootParticle {
331 public:
332 float Eta;
333 float Phi;
334 float E;
335 TRootCalo() ;
336 TRootCalo(const TRootCalo& cal);
337 TRootCalo& operator=(const TRootCalo& cal);
338 void set(const D_CaloTower& cal);
339 static TCompare *fgCompare; //!
340 const TCompare *GetCompare() const { return fgCompare; }
341 const float getET() const {return ET;}
342
343 protected:
344 float E_em, E_had; // electromagnetic and hadronic components of the tower energy
345 float ET; // total energy and transverse energy
346 ClassDef(TRootCalo, 1)
347};
348
349//---------------------------------------------------------------------------
350/*
351class TRootZdcHits: public TRootParticle
352{
353public:
354 TRootZdcHits() {};
355 float T; // time of flight [s]
356 int side; // -1 or +1
357 static TCompare *fgCompare; //!
358 int pid;
359
360 ClassDef(TRootZdcHits, 1)
361};
362*/
363
364// gen-level info stored for forward detectors
365// this class is similar to TRootParticle, but for the member names
366class TRootGenFwdParticle: public TSortableObject {
367
368public:
369
370 TRootGenFwdParticle() {};
371 TRootGenFwdParticle(const TRootGenFwdParticle& p);
372 TRootGenFwdParticle& operator=(const TRootGenFwdParticle& p);
373 float genE; // particle energy in GeV
374 float genPx; // particle momentum vector (x component) in GeV
375 float genPy; // particle momentum vector (y component) in GeV
376 float genPz; // particle momentum vector (z component) in GeV
377 float genPT; // particle transverse momentum in GeV
378
379 float genEta; // particle pseudorapidity
380 float genPhi; // particle azimuthal angle in rad
381 int pid;
382
383 void Set(const TLorentzVector& momentum); // initialises the gen-level data
384 void Set(const float px, const float py, const float pz, const float e);
385 void SetEtaPhi(const float eta, const float phi) {genEta=eta; genPhi=phi;};
386 void SetEtaPhiEET(const float eta, const float phi, const float e, const float et);
387 static TCompare *fgCompare; //!
388 const TCompare *GetCompare() const { return fgCompare; }
389
390 ClassDef(TRootGenFwdParticle, 1)
391};
392
393
394
395//class TRootZdcHits: public TSortableObject
396class TRootZdcHits: public TRootGenFwdParticle
397{
398public:
399
400 TRootZdcHits() {}; // do not put anything for the default constructor-- ExRootAnalysis constrain!!!
401 TRootZdcHits(const float e, const float t, const int side, const bool had);
402 TRootZdcHits(const TRootZdcHits& zdc);
403 TRootZdcHits& operator=(const TRootZdcHits& zdc);
404 float E;
405 float T; // time of flight [s]
406 int side; // -1 or +1
407 static TCompare *fgCompare; //!
408 bool hadronic_hit; // true if neutron, false if photon
409
410 ClassDef(TRootZdcHits, 2)
411};
412
413
414//---------------------------------------------------------------------------
415
416class TRootTauJet: public TRootParticle
417{
418public:
419 TRootTauJet() {};
420 float Charge; // normally, using the charge of the track ; here using gen-level tau charge
421 int NTracks;
422
423 float EHoverEE;
424// float E; // particle energy in GeV
425// float Px; // particle momentum vector (x component) in GeV
426// float Py; // particle momentum vector (y component) in GeV
427// float Pz; // particle momentum vector (z component) in GeV
428
429// float Eta; // particle pseudorapidity
430// float Phi; // particle azimuthal angle in rad
431
432 void Set(const TLorentzVector& momentum);// { return TRootParticle::Set(momentum); }
433
434 static TCompare *fgCompare; //!
435
436 // float PT; // particle transverse momentum in GeV
437
438 ClassDef(TRootTauJet, 1)
439};
440
441//---------------------------------------------------------------------------
442
443class TRootJet: public TRootParticle
444{
445public:
446 TRootJet() {};
447
448 static TCompare *fgCompare; //!
449
450 bool Btag;
451 int NTracks;
452
453 float EHoverEE;
454 ClassDef(TRootJet, 1)
455};
456
457//------------------------------------------------------------------------------
458
459class TRootTrigger: public TSortableObject
460{
461public:
462 TRootTrigger() {};
463
464 int Accepted;
465
466 static TCompare *fgCompare; //!
467 const TCompare *GetCompare() const { return fgCompare; }
468
469 ClassDef(TRootTrigger, 1)
470};
471//---------------------------------------------------------------------------
472
473class TRootETmis: public TSortableObject
474{
475public:
476 TRootETmis() {};
477 float ET; // jet energy [RecJet::getEnergy()]
478 float Phi; // jet azimuthal angle [RecJet::getPhi()]
479 float Px;
480 float Py;
481
482 static TCompare *fgCompare; //!
483 const TCompare *GetCompare() const { return fgCompare; }
484
485 ClassDef(TRootETmis, 1)
486};
487
488//---------------------------------------------------------------------------
489
490//class TRootRomanPotHits: public TSortableObject
491class TRootRomanPotHits: public TRootGenFwdParticle
492{
493public:
494 TRootRomanPotHits() {};
495 // float T; // time of flight to the detector [s]
496 float S; // distance to the IP [m]
497 float E; // reconstructed energy [GeV]
498 float q2; // reconstructed squared momentum transfer [GeV^2]
499
500 float X; // horizontal distance to the beam [um]
501 float Y; // vertical distance to the beam [um]
502
503 float Tx; // angle of the momentum in the horizontal (x,z) plane [urad]
504 float Ty; // angle of the momentum in the verical (y,z) plane [urad]
505
506 float T; // time of flight to the detector [s]
507 int side; // -1 or 1
508
509 static TCompare *fgCompare; //!
510 //const TCompare *GetCompare() const { return fgCompare; }
511
512 ClassDef(TRootRomanPotHits, 2)
513};
514
515//---------------------------------------------------------------------------
516
517class TRootForwardTaggerHits : public TRootRomanPotHits
518{
519public:
520 TRootForwardTaggerHits() {};
521 float T; // time of flight to the detector [s]
522
523 static TCompare *fgCompare; //!
524 const TCompare *GetCompare() const { return fgCompare; }
525
526 ClassDef(TRootForwardTaggerHits, 1)
527};
528
529
530
531
532class TRootLHEFParticle: public TRootC::GenParticle
533{
534public:
535 TRootLHEFParticle() {};
536 int ColorLine1; // index for the particle color-line | hepup.ICOLUP[number][0]
537 int ColorLine2; // index for the particle anti-color-line | hepup.ICOLUP[number][1]
538
539 double Rapidity; // particle rapidity
540 double LifeTime; // particle invariant lifetime
541 // (c*tau, distance from production to decay in mm)
542 // | hepup.VTIMUP[number]
543
544 double Spin; // cosine of the angle between the particle spin vector
545 // and the decaying particle 3-momentum,
546 // specified in the lab frame. | hepup.SPINUP[number]
547
548 static TCompare *fgCompare; //!
549 const TCompare *GetCompare() const { return fgCompare; }
550 ClassDef(TRootLHEFParticle, 2)
551
552};
553
554#endif // BLOCKCLASSES_H
555
Note: See TracBrowser for help on using the repository browser.