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