]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/ESD/AliESDEvent.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Unblocked using of TOF BC info in multi-vertexer
[u/mrichter/AliRoot.git] / STEER / ESD / AliESDEvent.h
CommitLineData
af885e0f 1// -*- mode: C++ -*-
2#ifndef ALIESDEVENT_H
3#define ALIESDEVENT_H
4/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * See cxx source for full Copyright notice */
6
7
8/* $Id$ */
9
10//-------------------------------------------------------------------------
f56a9fa7 11// Class AliESDEvent
6989bff3 12// This is the class to deal with during the physics analysis of data.
f56a9fa7 13// It also ensures the backward compatibility with the old ESD format.
af885e0f 14//
f56a9fa7 15// Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
af885e0f 16//-------------------------------------------------------------------------
17
18#include <TClonesArray.h>
19#include <TObject.h>
20#include <TTree.h>
21#include <TArrayF.h>
22
af885e0f 23
024c7734 24#include "AliVEvent.h"
694aad0c 25// some includes for delegated methods
f0106218 26#include "AliESDCaloTrigger.h"
af885e0f 27#include "AliESDRun.h"
28#include "AliESDHeader.h"
3f47e572 29#include "AliESDTZERO.h"
f0106218 30#include "AliESDZDC.h"
bd95bae7 31#include "AliESDACORDE.h"
af885e0f 32
024c7734 33// AliESDtrack has to be included so that the compiler
34// knows its inheritance tree (= that it is a AliVParticle).
35#include "AliESDtrack.h"
5303c167 36// same for AliESDVertex (which is a AliVVertex)
37#include "AliESDVertex.h"
c8fe2783 38// same for CaloCells and CaloClusters (which is a AliVCaloCells, AliVCluster)
39#include "AliESDCaloCluster.h"
40#include "AliESDCaloCells.h"
41
f858b00e 42#include "AliTOFHeader.h"
024c7734 43
ae2bccf1 44#include "AliESDVZERO.h"
45
af885e0f 46class AliESDfriend;
af885e0f 47class AliESDHLTtrack;
f0106218 48class AliESDVertex;
49class AliESDPmdTrack;
50class AliESDFMD;
51class AliESDkink;
f0106218 52class AliESDv0;
f0106218 53class AliMultiplicity;
54class AliRawDataErrorLog;
55class AliESDRun;
56class AliESDTrdTrack;
52cd0cc0 57class AliESDTrdTracklet;
f0106218 58class AliESDMuonTrack;
af885e0f 59class AliESD;
f0106218 60class AliESDcascade;
fba4b2e2 61class AliCentrality;
ce7adfe9 62class AliEventplane;
cd1d4ee0 63class TRefArray;
bd95bae7 64class AliESDACORDE;
8b12d288 65class AliESDHLTDecision;
af885e0f 66
80791508 67class TList;
68class TString;
69
70
024c7734 71class AliESDEvent : public AliVEvent {
af885e0f 72public:
73
74
6989bff3 75 enum ESDListIndex {kESDRun,
af885e0f 76 kHeader,
77 kESDZDC,
78 kESDFMD,
79 kESDVZERO,
80 kESDTZERO,
06cc9d95 81 kTPCVertex,
af885e0f 82 kSPDVertex,
83 kPrimaryVertex,
84 kSPDMult,
85 kPHOSTrigger,
86 kEMCALTrigger,
04d01397 87 kSPDPileupVertices,
88 kTrkPileupVertices,
af885e0f 89 kTracks,
90 kMuonTracks,
91 kPmdTracks,
92 kTrdTracks,
52cd0cc0 93 kTrdTracklets,
af885e0f 94 kV0s,
95 kCascades,
96 kKinks,
97 kCaloClusters,
e649177a 98 kEMCALCells,
99 kPHOSCells,
af885e0f 100 kErrorLogs,
bd95bae7 101 kESDACORDE,
f858b00e 102 kTOFHeader,
af885e0f 103 kESDListN
104 };
105
106 AliESDEvent();
732a24fe 107 virtual ~AliESDEvent();
108 AliESDEvent &operator=(const AliESDEvent& source); // or make private and use only copy?
109 virtual void Copy(TObject& obj) const;
af885e0f 110
111 // RUN
112 // move this to the UserData!!!
113 const AliESDRun* GetESDRun() const {return fESDRun;}
114
115 // Delegated methods for fESDRun
c017f53f 116 void SetRunNumber(Int_t n) {if(fESDRun) fESDRun->SetRunNumber(n);}
117 Int_t GetRunNumber() const {return fESDRun?fESDRun->GetRunNumber():-1;}
00d00f58 118 void SetPeriodNumber(UInt_t n){
119 if(fESDRun) fESDRun->SetPeriodNumber(n);
120 if(fHeader) fHeader->SetPeriodNumber(n);
121 }
c017f53f 122 UInt_t GetPeriodNumber() const {return fESDRun?fESDRun->GetPeriodNumber():0;}
123 void SetMagneticField(Double_t mf){if(fESDRun) fESDRun->SetMagneticField(mf);}
124 Double_t GetMagneticField() const {return fESDRun?fESDRun->GetMagneticField():0;}
125 void SetDiamond(const AliESDVertex *vertex) { if(fESDRun) fESDRun->SetDiamond(vertex);}
126 Double_t GetDiamondX() const {return fESDRun?fESDRun->GetDiamondX():0;}
127 Double_t GetDiamondY() const {return fESDRun?fESDRun->GetDiamondY():0;}
1c7554f9 128 Double_t GetDiamondZ() const {return fESDRun?fESDRun->GetDiamondZ():0;}
c017f53f 129 Double_t GetSigma2DiamondX() const {return fESDRun?fESDRun->GetSigma2DiamondX():0;}
130 Double_t GetSigma2DiamondY() const {return fESDRun?fESDRun->GetSigma2DiamondY():0;}
1c7554f9 131 Double_t GetSigma2DiamondZ() const {return fESDRun?fESDRun->GetSigma2DiamondZ():0;}
c017f53f 132 void GetDiamondCovXY(Float_t cov[3]) const {if(fESDRun) fESDRun->GetDiamondCovXY(cov);}
133 void SetTriggerClass(const char*name, Int_t index) {if(fESDRun) fESDRun->SetTriggerClass(name,index);}
134 void SetPHOSMatrix(TGeoHMatrix*matrix, Int_t i) {if(fESDRun) fESDRun->SetPHOSMatrix(matrix,i);}
135 const TGeoHMatrix* GetPHOSMatrix(Int_t i) const {return fESDRun?fESDRun->GetPHOSMatrix(i):0x0;}
136 void SetEMCALMatrix(TGeoHMatrix*matrix, Int_t i) {if(fESDRun) fESDRun->SetEMCALMatrix(matrix,i);}
137 const TGeoHMatrix* GetEMCALMatrix(Int_t i) const {return fESDRun?fESDRun->GetEMCALMatrix(i):0x0;}
da6062af 138 void SetCaloTriggerType(const Int_t* type) {if (fESDRun) fESDRun->SetCaloTriggerType(type);}
139 Int_t* GetCaloTriggerType() const {return fESDRun?fESDRun->GetCaloTriggerType():0x0;};
140
33fe5eb1 141 //
c017f53f 142 void SetCurrentL3(Float_t cur) const {if(fESDRun) fESDRun->SetCurrentL3(cur);}
143 void SetCurrentDip(Float_t cur) const {if(fESDRun) fESDRun->SetCurrentDip(cur);}
144 void SetBeamEnergy(Float_t be) const {if(fESDRun) fESDRun->SetBeamEnergy(be);}
145 void SetBeamType(const char* bt) const {if(fESDRun) fESDRun->SetBeamType(bt);}
146 void SetUniformBMap(Bool_t val=kTRUE) const {if(fESDRun) fESDRun->SetBit(AliESDRun::kUniformBMap,val);}
147 void SetBInfoStored(Bool_t val=kTRUE) const {if(fESDRun) fESDRun->SetBit(AliESDRun::kBInfoStored,val);}
33fe5eb1 148 //
c017f53f 149 Float_t GetCurrentL3() const {return fESDRun?fESDRun->GetCurrentL3():0;}
150 Float_t GetCurrentDip() const {return fESDRun?fESDRun->GetCurrentDip():0;}
151 Float_t GetBeamEnergy() const {return fESDRun?fESDRun->GetBeamEnergy():0;}
152 const char* GetBeamType() const {return fESDRun?fESDRun->GetBeamType():0;}
153 Bool_t IsUniformBMap() const {return fESDRun?fESDRun->TestBit(AliESDRun::kUniformBMap):kFALSE;}
33fe5eb1 154 //
c017f53f 155 Bool_t InitMagneticField() const {return fESDRun?fESDRun->InitMagneticField():kFALSE;}
8938f4e0 156 void SetT0spread(Float_t *t) const {if(fESDRun) fESDRun->SetT0spread(t);}
af885e0f 157 // HEADER
024c7734 158 AliESDHeader* GetHeader() const {return fHeader;}
af885e0f 159
160 // Delegated methods for fHeader
c017f53f 161 void SetTriggerMask(ULong64_t n) {if(fHeader) fHeader->SetTriggerMask(n);}
162 void SetOrbitNumber(UInt_t n) {if(fHeader) fHeader->SetOrbitNumber(n);}
163 void SetTimeStamp(UInt_t timeStamp){if(fHeader) fHeader->SetTimeStamp(timeStamp);}
164 void SetEventType(UInt_t eventType){if(fHeader) fHeader->SetEventType(eventType);}
165 void SetEventSpecie(UInt_t eventSpecie){if(fHeader) fHeader->SetEventSpecie(eventSpecie);}
166 void SetEventNumberInFile(Int_t n) {if(fHeader) fHeader->SetEventNumberInFile(n);}
167 // void SetRunNumber(Int_t n) {if(fHeader) fHeader->SetRunNumber(n);}
168 void SetBunchCrossNumber(UShort_t n) {if(fHeader) fHeader->SetBunchCrossNumber(n);}
169 void SetTriggerCluster(UChar_t n) {if(fHeader) fHeader->SetTriggerCluster(n);}
694aad0c 170
c017f53f 171 ULong64_t GetTriggerMask() const {return fHeader?fHeader->GetTriggerMask():0;}
172 TString GetFiredTriggerClasses() const {return (fESDRun&&fHeader)?fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask()):"";}
173 Bool_t IsTriggerClassFired(const char *name) const {return (fESDRun&&fHeader)?fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name):kFALSE;}
2a3dfb14 174 Bool_t IsEventSelected(const char *trigExpr) const;
3b286f80 175 TObject* GetHLTTriggerDecision() const;
176 TString GetHLTTriggerDescription() const;
177 Bool_t IsHLTTriggerFired(const char* name=NULL) const;
158a76dd 178 UInt_t GetOrbitNumber() const {return fHeader?fHeader->GetOrbitNumber():0;}
c017f53f 179 UInt_t GetTimeStamp() const { return fHeader?fHeader->GetTimeStamp():0;}
180 UInt_t GetEventType() const { return fHeader?fHeader->GetEventType():0;}
181 UInt_t GetEventSpecie() const { return fHeader?fHeader->GetEventSpecie():0;}
182 Int_t GetEventNumberInFile() const {return fHeader?fHeader->GetEventNumberInFile():-1;}
183 UShort_t GetBunchCrossNumber() const {return fHeader?fHeader->GetBunchCrossNumber():0;}
184 UChar_t GetTriggerCluster() const {return fHeader?fHeader->GetTriggerCluster():0;}
af885e0f 185
186 // ZDC CKB: put this in the header?
16d867eb 187 AliESDZDC* GetESDZDC() const {return fESDZDC;}
188 AliESDZDC* GetZDCData() const {return fESDZDC;}
189
af6f24c9 190 void SetZDCData(AliESDZDC * obj);
af885e0f 191
192 // Delegated methods for fESDZDC
c017f53f 193 Double_t GetZDCN1Energy() const {return fESDZDC?fESDZDC->GetZDCN1Energy():0;}
194 Double_t GetZDCP1Energy() const {return fESDZDC?fESDZDC->GetZDCP1Energy():0;}
195 Double_t GetZDCN2Energy() const {return fESDZDC?fESDZDC->GetZDCN2Energy():0;}
196 Double_t GetZDCP2Energy() const {return fESDZDC?fESDZDC->GetZDCP2Energy():0;}
197 Double_t GetZDCEMEnergy(Int_t i=0) const {return fESDZDC?fESDZDC->GetZDCEMEnergy(i):0;}
198 Int_t GetZDCParticipants() const {return fESDZDC?fESDZDC->GetZDCParticipants():0;}
fba4b2e2 199 AliCentrality* GetCentrality();
ce7adfe9 200 AliEventplane* GetEventplane();
cb62947d 201
2eec2a33 202
b19cc8d0 203 void SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t em1Energy, Float_t em2Energy,
204 Float_t n2Energy, Float_t p2Energy, Int_t participants, Int_t nPartA,
205 Int_t nPartC, Double_t b, Double_t bA, Double_t bC, UInt_t recoflag)
c017f53f 206 {if(fESDZDC) fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy,
b19cc8d0 207 participants, nPartA, nPartC, b, bA, bC, recoflag);}
cb62947d 208 // FMD
af885e0f 209 void SetFMDData(AliESDFMD * obj);
5b96d6f1 210 AliESDFMD *GetFMDData() const { return fESDFMD; }
af885e0f 211
212
213 // TZERO CKB: put this in the header?
214 const AliESDTZERO* GetESDTZERO() const {return fESDTZERO;}
b0e13b29 215 void SetTZEROData(AliESDTZERO * obj);
216 // delegetated methods for fESDTZERO
af885e0f 217
adf36b9d 218 Double32_t GetT0zVertex() const {return fESDTZERO?fESDTZERO->GetT0zVertex():0;}
219 void SetT0zVertex(Double32_t z) {if(fESDTZERO) fESDTZERO->SetT0zVertex(z);}
220 Double32_t GetT0() const {return fESDTZERO?fESDTZERO->GetT0():0;}
221 void SetT0(Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0(timeStart);}
222 Double32_t GetT0clock() const {return fESDTZERO?fESDTZERO->GetT0clock():0;}
223 void SetT0clock(Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0clock(timeStart);}
224 Double32_t GetT0TOF(Int_t icase) const {return fESDTZERO?fESDTZERO->GetT0TOF(icase):0;}
225 const Double32_t * GetT0TOF() const {return fESDTZERO?fESDTZERO->GetT0TOF():0x0;}
226 void SetT0TOF(Int_t icase,Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0TOF(icase,timeStart);}
227 const Double32_t * GetT0time() const {return fESDTZERO?fESDTZERO->GetT0time():0x0;}
228 void SetT0time(Double32_t time[24]) {if(fESDTZERO) fESDTZERO->SetT0time(time);}
229 const Double32_t * GetT0amplitude() const {return fESDTZERO?fESDTZERO->GetT0amplitude():0x0;}
230 void SetT0amplitude(Double32_t amp[24]){if(fESDTZERO) fESDTZERO->SetT0amplitude(amp);}
231 Int_t GetT0Trig() const { return fESDTZERO?fESDTZERO->GetT0Trig():0;}
232 void SetT0Trig(Int_t tvdc) {if(fESDTZERO) fESDTZERO->SetT0Trig(tvdc);}
af885e0f 233
234 // VZERO
235 AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
236 void SetVZEROData(AliESDVZERO * obj);
237
bd95bae7 238 // ACORDE
239 AliESDACORDE *GetACORDEData() const { return fESDACORDE;}
240 void SetACORDEData(AliESDACORDE * obj);
af885e0f 241
7d44c466 242 void SetESDfriend(const AliESDfriend *f) const;
af885e0f 243 void GetESDfriend(AliESDfriend *f) const;
244
245
246
06cc9d95 247 void SetPrimaryVertexTPC(const AliESDVertex *vertex);
248 const AliESDVertex *GetPrimaryVertexTPC() const {return fTPCVertex;}
249
250 void SetPrimaryVertexSPD(const AliESDVertex *vertex);
251 const AliESDVertex *GetPrimaryVertexSPD() const {return fSPDVertex;}
252 const AliESDVertex *GetVertex() const {
253 //For the backward compatibily only
254 return GetPrimaryVertexSPD();
255 }
af885e0f 256
c264b61b 257 void SetPrimaryVertexTracks(const AliESDVertex *vertex);
258 const AliESDVertex *GetPrimaryVertexTracks() const {return fPrimaryVertex;}
518573d7 259 AliESDVertex *PrimaryVertexTracksUnconstrained() const;
c264b61b 260
261 const AliESDVertex *GetPrimaryVertex() const;
af885e0f 262
f858b00e 263
264
265 void SetTOFHeader(const AliTOFHeader * tofEventTime);
266 const AliTOFHeader *GetTOFHeader() const {return fTOFHeader;}
d9fc7e74 267 Float_t GetEventTimeSpread() const {if (fTOFHeader) return fTOFHeader->GetT0spread(); else return 0.;}
268 Float_t GetTOFTimeResolution() const {if (fTOFHeader) return fTOFHeader->GetTOFResolution(); else return 0.;}
f858b00e 269
270
f0106218 271 void SetMultiplicity(const AliMultiplicity *mul);
272
af885e0f 273 const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
4ace6760 274 void EstimateMultiplicity(Int_t &tracklets,Int_t &trITSTPC,Int_t &trITSSApure,
275 Double_t eta=1.,Bool_t useDCAFlag=kTRUE,Bool_t useV0Flag=kTRUE) const;
f0106218 276
7f68891d 277 Bool_t Clean(Float_t *cleanPars);
7d44c466 278 Bool_t RemoveKink(Int_t i) const;
279 Bool_t RemoveV0(Int_t i) const;
280 Bool_t RemoveTrack(Int_t i) const;
d64bd07d 281
04d01397 282 const AliESDVertex *GetPileupVertexSPD(Int_t i) const {
c017f53f 283 return (const AliESDVertex *)(fSPDPileupVertices?fSPDPileupVertices->UncheckedAt(i):0x0);
04d01397 284 }
6dc21f57 285 Char_t AddPileupVertexSPD(const AliESDVertex *vtx);
04d01397 286 const AliESDVertex *GetPileupVertexTracks(Int_t i) const {
c017f53f 287 return (const AliESDVertex *)(fTrkPileupVertices?fTrkPileupVertices->UncheckedAt(i):0x0);
04d01397 288 }
6dc21f57 289 Char_t AddPileupVertexTracks(const AliESDVertex *vtx);
3f2db92f 290 TClonesArray* GetPileupVerticesTracks() const {return (TClonesArray*)fTrkPileupVertices;}
291 TClonesArray* GetPileupVerticesSPD() const {return (TClonesArray*)fSPDPileupVertices;}
04d01397 292
a98c78e5 293 virtual Bool_t IsPileupFromSPD(Int_t minContributors=3,
294 Double_t minZdist=0.8,
295 Double_t nSigmaZdist=3.,
296 Double_t nSigmaDiamXY=2.,
297 Double_t nSigmaDiamZ=5.) const;
298
b46ff4b0 299 virtual Bool_t IsPileupFromSPDInMultBins() const;
300
af885e0f 301 AliESDtrack *GetTrack(Int_t i) const {
c017f53f 302 return (AliESDtrack *)(fTracks?fTracks->UncheckedAt(i):0x0);
af885e0f 303 }
304 Int_t AddTrack(const AliESDtrack *t);
305
65a0cf79 306 /// add new track at the end of tracks array and return instance
307 AliESDtrack* NewTrack();
af885e0f 308
309 AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
310 // return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
311 return 0;
312 }
313 void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
314 printf("ESD:: AddHLTConfMapTrack do nothing \n");
315 // TClonesArray &fhlt = *fHLTConfMapTracks;
316 // new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
317 }
318
319
320 AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
321 // return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
322 return 0;
323 }
324 void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
325 printf("ESD:: AddHLTHoughTrack do nothing \n");
326 // TClonesArray &fhlt = *fHLTHoughTracks;
327 // new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
328 }
329
330 AliESDMuonTrack *GetMuonTrack(Int_t i) const {
c017f53f 331 return (AliESDMuonTrack *)(fMuonTracks?fMuonTracks->UncheckedAt(i):0x0);
af885e0f 332 }
f0106218 333
334 void AddMuonTrack(const AliESDMuonTrack *t);
af885e0f 335
336 AliESDPmdTrack *GetPmdTrack(Int_t i) const {
c017f53f 337 return (AliESDPmdTrack *)(fPmdTracks?fPmdTracks->UncheckedAt(i):0x0);
af885e0f 338 }
f0106218 339
340 void AddPmdTrack(const AliESDPmdTrack *t);
341
af885e0f 342
343 AliESDTrdTrack *GetTrdTrack(Int_t i) const {
c017f53f 344 return (AliESDTrdTrack *)(fTrdTracks?fTrdTracks->UncheckedAt(i):0x0);
af885e0f 345 }
f0106218 346
347
348 void AddTrdTrack(const AliESDTrdTrack *t);
af885e0f 349
52cd0cc0 350 AliESDTrdTracklet* GetTrdTracklet(Int_t idx) const {
351 return (AliESDTrdTracklet*)(fTrdTracklets?fTrdTracklets->UncheckedAt(idx):0x0);
352 }
353
354 void AddTrdTracklet(const AliESDTrdTracklet *trkl);
355
af885e0f 356 AliESDv0 *GetV0(Int_t i) const {
c017f53f 357 return (AliESDv0*)(fV0s?fV0s->UncheckedAt(i):0x0);
af885e0f 358 }
359 Int_t AddV0(const AliESDv0 *v);
360
361 AliESDcascade *GetCascade(Int_t i) const {
c017f53f 362 return (AliESDcascade *)(fCascades?fCascades->UncheckedAt(i):0x0);
af885e0f 363 }
f0106218 364
365 void AddCascade(const AliESDcascade *c);
af885e0f 366
367 AliESDkink *GetKink(Int_t i) const {
c017f53f 368 return (AliESDkink *)(fKinks?fKinks->UncheckedAt(i):0x0);
af885e0f 369 }
370 Int_t AddKink(const AliESDkink *c);
371
372 AliESDCaloCluster *GetCaloCluster(Int_t i) const {
c017f53f 373 return (AliESDCaloCluster *)(fCaloClusters?fCaloClusters->UncheckedAt(i):0x0);
af885e0f 374 }
e649177a 375
af885e0f 376 Int_t AddCaloCluster(const AliESDCaloCluster *c);
377
e649177a 378 AliESDCaloCells *GetEMCALCells() const {return fEMCALCells; }
379 AliESDCaloCells *GetPHOSCells() const {return fPHOSCells; }
380
042d5330 381 AliESDCaloTrigger* GetCaloTrigger(TString calo) const
382 {
383 if (calo.Contains("EMCAL")) return fEMCALTrigger;
384 else
385 return fPHOSTrigger;
386 }
387
af885e0f 388 AliRawDataErrorLog *GetErrorLog(Int_t i) const {
c017f53f 389 return (AliRawDataErrorLog *)(fErrorLogs?fErrorLogs->UncheckedAt(i):0x0);
af885e0f 390 }
7d44c466 391 void AddRawDataErrorLog(const AliRawDataErrorLog *log) const;
f0106218 392
c017f53f 393 Int_t GetNumberOfErrorLogs() const {return fErrorLogs?fErrorLogs->GetEntriesFast():0;}
af885e0f 394
04d01397 395 Int_t GetNumberOfPileupVerticesSPD() const {
642f673b 396 return (fSPDPileupVertices?fSPDPileupVertices->GetEntriesFast():0);
04d01397 397 }
398 Int_t GetNumberOfPileupVerticesTracks() const {
642f673b 399 return (fTrkPileupVertices?fTrkPileupVertices->GetEntriesFast():0);
04d01397 400 }
c017f53f 401 Int_t GetNumberOfTracks() const {return fTracks?fTracks->GetEntriesFast():0;}
af885e0f 402 Int_t GetNumberOfHLTConfMapTracks() const {return 0;}
403 // fHLTConfMapTracks->GetEntriesFast();}
404 Int_t GetNumberOfHLTHoughTracks() const {return 0; }
405 // fHLTHoughTracks->GetEntriesFast(); }
406
c017f53f 407 Int_t GetNumberOfMuonTracks() const {return fMuonTracks?fMuonTracks->GetEntriesFast():0;}
408 Int_t GetNumberOfPmdTracks() const {return fPmdTracks?fPmdTracks->GetEntriesFast():0;}
409 Int_t GetNumberOfTrdTracks() const {return fTrdTracks?fTrdTracks->GetEntriesFast():0;}
52cd0cc0 410 Int_t GetNumberOfTrdTracklets() const {return fTrdTracklets?fTrdTracklets->GetEntriesFast():0;}
c017f53f 411 Int_t GetNumberOfV0s() const {return fV0s?fV0s->GetEntriesFast():0;}
412 Int_t GetNumberOfCascades() const {return fCascades?fCascades->GetEntriesFast():0;}
413 Int_t GetNumberOfKinks() const {return fKinks?fKinks->GetEntriesFast():0;}
e649177a 414
cd1d4ee0 415 Int_t GetEMCALClusters(TRefArray *clusters) const;
416 Int_t GetPHOSClusters(TRefArray *clusters) const;
c017f53f 417 Int_t GetNumberOfCaloClusters() const {return fCaloClusters?fCaloClusters->GetEntriesFast():0;}
af885e0f 418
a2fbb067 419 void SetUseOwnList(Bool_t b){fUseOwnList = b;}
b19cc8d0 420 Bool_t GetUseOwnList() const {return fUseOwnList;}
e649177a 421
c017f53f 422 void ResetV0s() { if(fV0s) fV0s->Clear(); }
423 void ResetCascades() { if(fCascades) fCascades->Clear(); }
af885e0f 424 void Reset();
425
426 void Print(Option_t *option="") const;
427
428 void AddObject(TObject* obj);
1d0dd492 429 void ReadFromTree(TTree *tree, Option_t* opt = "");
2811495d 430 TObject* FindListObject(const char *name) const;
af885e0f 431 AliESD *GetAliESDOld(){return fESDOld;}
f12d42ce 432 void WriteToTree(TTree* tree) const;
af885e0f 433 void GetStdContent();
434 void ResetStdContent();
435 void CreateStdContent();
a2fbb067 436 void CreateStdContent(Bool_t bUseThisList);
af885e0f 437 void SetStdNames();
438 void CopyFromOldESD();
024c7734 439 TList* GetList() const {return fESDObjects;}
c8fe2783 440
441 //Following needed only for mixed event
442 virtual Int_t EventIndex(Int_t) const {return 0;}
443 virtual Int_t EventIndexForCaloCluster(Int_t) const {return 0;}
444 virtual Int_t EventIndexForPHOSCell(Int_t) const {return 0;}
445 virtual Int_t EventIndexForEMCALCell(Int_t) const {return 0;}
446
af885e0f 447
448protected:
449 AliESDEvent(const AliESDEvent&);
102c56c8 450 static Bool_t ResetWithPlacementNew(TObject *pObject);
af885e0f 451
452 TList *fESDObjects; // List of esd Objects
453
454 AliESDRun *fESDRun; //! Run information tmp put in the Userdata
455 AliESDHeader *fHeader; //! ESD Event Header
456 AliESDZDC *fESDZDC; //! ZDC information
457 AliESDFMD *fESDFMD; //! FMD object containing rough multiplicity
458 AliESDVZERO *fESDVZERO; //! VZERO object containing rough multiplicity
459 AliESDTZERO *fESDTZERO; //! TZEROObject
06cc9d95 460 AliESDVertex *fTPCVertex; //! Primary vertex estimated by the TPC
af885e0f 461 AliESDVertex *fSPDVertex; //! Primary vertex estimated by the SPD
462 AliESDVertex *fPrimaryVertex; //! Primary vertex estimated using ESD tracks
463 AliMultiplicity *fSPDMult; //! SPD tracklet multiplicity
464 AliESDCaloTrigger* fPHOSTrigger; //! PHOS Trigger information
465 AliESDCaloTrigger* fEMCALTrigger; //! PHOS Trigger information
bd95bae7 466 AliESDACORDE *fESDACORDE; //! ACORDE ESD object caontaining bit pattern
af885e0f 467
04d01397 468 TClonesArray *fSPDPileupVertices;//! Pileup primary vertices reconstructed by SPD
469 TClonesArray *fTrkPileupVertices;//! Pileup primary vertices reconstructed using the tracks
af885e0f 470 TClonesArray *fTracks; //! ESD tracks
471 TClonesArray *fMuonTracks; //! MUON ESD tracks
472 TClonesArray *fPmdTracks; //! PMD ESD tracks
473 TClonesArray *fTrdTracks; //! TRD ESD tracks (triggered)
52cd0cc0 474 TClonesArray *fTrdTracklets; //! TRD tracklets (for trigger)
af885e0f 475 TClonesArray *fV0s; //! V0 vertices
476 TClonesArray *fCascades; //! Cascade vertices
477 TClonesArray *fKinks; //! Kinks
478 TClonesArray *fCaloClusters; //! Calorimeter clusters for PHOS/EMCAL
e649177a 479 AliESDCaloCells *fEMCALCells; //! EMCAL cell info
480 AliESDCaloCells *fPHOSCells; //! PHOS cell info
af885e0f 481 TClonesArray *fErrorLogs; //! Raw-data reading error messages
482
483
484
1bd10080 485 AliESD *fESDOld; //! Old esd Structure
486 AliESDfriend *fESDFriendOld; //! Old friend esd Structure
60e8f114 487 Bool_t fConnected; //! flag if leaves are alreday connected
a2fbb067 488 Bool_t fUseOwnList; //! Do not use the list from the esdTree but use the one created by this class
60e8f114 489
6989bff3 490 static const char* fgkESDListName[kESDListN]; //!
af885e0f 491
f858b00e 492 AliTOFHeader *fTOFHeader; //! event times (and sigmas) as estimated by TOF
493 // combinatorial algorithm.
494 // It contains also TOF time resolution
495 // and T0spread as written in OCDB
fba4b2e2 496 AliCentrality *fCentrality; //! Centrality for AA collision
ce7adfe9 497 AliEventplane *fEventplane; //! Event plane for AA collision
498 ClassDef(AliESDEvent,14) //ESDEvent class
af885e0f 499};
500#endif
501