Fork me on GitHub

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

Last change on this file since 550 was 550, checked in by severine ovyn, 14 years ago

changements pour EtRatio muons et electrons. Bugge
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 float EtRatio;
265
266 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
267
268 ClassDef(TRootElectron, 1)
269};
270
271//------------------------------------------------------------------------------
272
273class TRootPhoton: public TRootParticle {
274public:
275 TRootPhoton() : EHoverEE(UNDEFINED) {};
276 static TCompare *fgCompare; //!
277
278 float EHoverEE;
279 ClassDef(TRootPhoton, 1)
280};
281
282
283//------------------------------------------------------------------------------
284
285class TRootMuon: public TRootParticle {
286public:
287 TRootMuon():Charge(-999), IsolFlag(false), IsolPt(UNDEFINED), EtaCalo(UNDEFINED), PhiCalo(UNDEFINED),
288 EHoverEE(UNDEFINED), EtRatio(UNDEFINED) {};
289 static TCompare *fgCompare; //!
290 int Charge; // particle Charge [RawHepEventParticle::pid()]
291 bool IsolFlag;
292 float IsolPt;
293 float EtaCalo; // particle pseudorapidity when entering the calo,
294 float PhiCalo; // particle azimuthal angle in rad when entering the calo
295 float EHoverEE; // hadronic energy over electromagnetic energy
296 float EtRatio; // calo Et in NxN-tower grid around the muon over the muon Et
297
298 void SetEtaPhiCalo(const float eta, const float phi) {EtaCalo=eta; PhiCalo=phi;};
299 ClassDef(TRootMuon, 1)
300};
301
302//---------------------------------------------------------------------------
303
304class TRootTracks : public TSortableObject {
305 public:
306 TRootTracks(); // needed for storage in ExRootAnalysis
307 TRootTracks(const TRootTracks& track);
308 TRootTracks(const float inEta, const float inPhi, const float outEta, const float outPhi, const float pt);
309 TRootTracks& operator=(const TRootTracks& track);
310 void Set(const float inEta, const float inPhi, const float outEta, const float outPhi, const float pt, const float charge);
311 const TLorentzVector GetFourVector() const;
312 const float getEta() const {return Eta;}
313 const float getPhi() const {return Phi;}
314 const float getEtaOuter() const {return EtaOuter;}
315 const float getPhiOuter() const {return PhiOuter;}
316
317 static TCompare *fgCompare; //!
318 const TCompare *GetCompare() const { return fgCompare; }
319
320 float Eta, Phi; // (eta,phi) at the beginning of the track
321 float EtaOuter, PhiOuter; // (eta,phi) at the end of the track
322 float PT, E, Px, Py, Pz; // transverse momentum
323 float Charge;
324 float Vx,Vy,Vz;
325 ClassDef(TRootTracks, 1)
326};
327
328//---------------------------------------------------------------------------
329
330class TRootCalo: public TSortableObject
331{
332//class TRootCalo: public TRootParticle {
333 public:
334 float Eta;
335 float Phi;
336 float E;
337 TRootCalo() ;
338 TRootCalo(const TRootCalo& cal);
339 TRootCalo& operator=(const TRootCalo& cal);
340 void set(const D_CaloTower& cal);
341 static TCompare *fgCompare; //!
342 const TCompare *GetCompare() const { return fgCompare; }
343 const float getET() const {return ET;}
344
345 protected:
346 float E_em, E_had; // electromagnetic and hadronic components of the tower energy
347 float ET; // total energy and transverse energy
348 ClassDef(TRootCalo, 1)
349};
350
351//---------------------------------------------------------------------------
352/*
353class TRootZdcHits: public TRootParticle
354{
355public:
356 TRootZdcHits() {};
357 float T; // time of flight [s]
358 int side; // -1 or +1
359 static TCompare *fgCompare; //!
360 int pid;
361
362 ClassDef(TRootZdcHits, 1)
363};
364*/
365
366// gen-level info stored for forward detectors
367// this class is similar to TRootParticle, but for the member names
368class TRootGenFwdParticle: public TSortableObject {
369
370public:
371
372 TRootGenFwdParticle() {};
373 TRootGenFwdParticle(const TRootGenFwdParticle& p);
374 TRootGenFwdParticle& operator=(const TRootGenFwdParticle& p);
375 float genE; // particle energy in GeV
376 float genPx; // particle momentum vector (x component) in GeV
377 float genPy; // particle momentum vector (y component) in GeV
378 float genPz; // particle momentum vector (z component) in GeV
379 float genPT; // particle transverse momentum in GeV
380
381 float genEta; // particle pseudorapidity
382 float genPhi; // particle azimuthal angle in rad
383 int pid;
384
385 void Set(const TLorentzVector& momentum); // initialises the gen-level data
386 void Set(const float px, const float py, const float pz, const float e);
387 void SetEtaPhi(const float eta, const float phi) {genEta=eta; genPhi=phi;};
388 void SetEtaPhiEET(const float eta, const float phi, const float e, const float et);
389 static TCompare *fgCompare; //!
390 const TCompare *GetCompare() const { return fgCompare; }
391
392 ClassDef(TRootGenFwdParticle, 1)
393};
394
395
396
397//class TRootZdcHits: public TSortableObject
398class TRootZdcHits: public TRootGenFwdParticle
399{
400public:
401
402 TRootZdcHits() {}; // do not put anything for the default constructor-- ExRootAnalysis constrain!!!
403 TRootZdcHits(const float e, const float t, const int side, const bool had);
404 TRootZdcHits(const TRootZdcHits& zdc);
405 TRootZdcHits& operator=(const TRootZdcHits& zdc);
406 float E;
407 float T; // time of flight [s]
408 int side; // -1 or +1
409 static TCompare *fgCompare; //!
410 bool hadronic_hit; // true if neutron, false if photon
411
412 ClassDef(TRootZdcHits, 2)
413};
414
415
416//---------------------------------------------------------------------------
417
418class TRootTauJet: public TRootParticle
419{
420public:
421 TRootTauJet() {};
422 float Charge; // normally, using the charge of the track ; here using gen-level tau charge
423 int NTracks;
424
425 float EHoverEE;
426// float E; // particle energy in GeV
427// float Px; // particle momentum vector (x component) in GeV
428// float Py; // particle momentum vector (y component) in GeV
429// float Pz; // particle momentum vector (z component) in GeV
430
431// float Eta; // particle pseudorapidity
432// float Phi; // particle azimuthal angle in rad
433
434 void Set(const TLorentzVector& momentum);// { return TRootParticle::Set(momentum); }
435
436 static TCompare *fgCompare; //!
437
438 // float PT; // particle transverse momentum in GeV
439
440 ClassDef(TRootTauJet, 1)
441};
442
443//---------------------------------------------------------------------------
444
445class TRootJet: public TRootParticle
446{
447public:
448 TRootJet() {};
449
450 static TCompare *fgCompare; //!
451
452 bool Btag;
453 int NTracks;
454
455 float EHoverEE;
456 ClassDef(TRootJet, 1)
457};
458
459//------------------------------------------------------------------------------
460
461class TRootTrigger: public TSortableObject
462{
463public:
464 TRootTrigger() {};
465
466 int Accepted;
467
468 static TCompare *fgCompare; //!
469 const TCompare *GetCompare() const { return fgCompare; }
470
471 ClassDef(TRootTrigger, 1)
472};
473//---------------------------------------------------------------------------
474
475class TRootETmis: public TSortableObject
476{
477public:
478 TRootETmis() {};
479 float ET; // jet energy [RecJet::getEnergy()]
480 float Phi; // jet azimuthal angle [RecJet::getPhi()]
481 float Px;
482 float Py;
483
484 static TCompare *fgCompare; //!
485 const TCompare *GetCompare() const { return fgCompare; }
486
487 ClassDef(TRootETmis, 1)
488};
489
490//---------------------------------------------------------------------------
491
492//class TRootRomanPotHits: public TSortableObject
493class TRootRomanPotHits: public TRootGenFwdParticle
494{
495public:
496 TRootRomanPotHits() {};
497 // float T; // time of flight to the detector [s]
498 float S; // distance to the IP [m]
499 float E; // reconstructed energy [GeV]
500 float q2; // reconstructed squared momentum transfer [GeV^2]
501
502 float X; // horizontal distance to the beam [um]
503 float Y; // vertical distance to the beam [um]
504
505 float Tx; // angle of the momentum in the horizontal (x,z) plane [urad]
506 float Ty; // angle of the momentum in the verical (y,z) plane [urad]
507
508 float T; // time of flight to the detector [s]
509 int side; // -1 or 1
510
511 static TCompare *fgCompare; //!
512 //const TCompare *GetCompare() const { return fgCompare; }
513
514 ClassDef(TRootRomanPotHits, 2)
515};
516
517//---------------------------------------------------------------------------
518
519class TRootForwardTaggerHits : public TRootRomanPotHits
520{
521public:
522 TRootForwardTaggerHits() {};
523 float T; // time of flight to the detector [s]
524
525 static TCompare *fgCompare; //!
526 const TCompare *GetCompare() const { return fgCompare; }
527
528 ClassDef(TRootForwardTaggerHits, 1)
529};
530
531
532
533
534class TRootLHEFParticle: public TRootC::GenParticle
535{
536public:
537 TRootLHEFParticle() {};
538 int ColorLine1; // index for the particle color-line | hepup.ICOLUP[number][0]
539 int ColorLine2; // index for the particle anti-color-line | hepup.ICOLUP[number][1]
540
541 double Rapidity; // particle rapidity
542 double LifeTime; // particle invariant lifetime
543 // (c*tau, distance from production to decay in mm)
544 // | hepup.VTIMUP[number]
545
546 double Spin; // cosine of the angle between the particle spin vector
547 // and the decaying particle 3-momentum,
548 // specified in the lab frame. | hepup.SPINUP[number]
549
550 static TCompare *fgCompare; //!
551 const TCompare *GetCompare() const { return fgCompare; }
552 ClassDef(TRootLHEFParticle, 2)
553
554};
555
556#endif // BLOCKCLASSES_H
557
Note: See TracBrowser for help on using the repository browser.