Fork me on GitHub

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

Last change on this file since 701 was 567, checked in by Xavier Rouby, 14 years ago

version 1.9

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