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