Line data Source code
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: AliESDEvent.h 64008 2013-08-28 13:09:59Z hristov $ */
9 :
10 : //-------------------------------------------------------------------------
11 : // Class AliESDEvent
12 : // This is the class to deal with during the physics analysis of data.
13 : // It also ensures the backward compatibility with the old ESD format.
14 : //
15 : // Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch
16 : //-------------------------------------------------------------------------
17 :
18 : #include <TClonesArray.h>
19 : #include <TObject.h>
20 : #include <TTree.h>
21 : #include <TArrayF.h>
22 : #include <TObjArray.h>
23 :
24 :
25 : #include "AliVEvent.h"
26 : // some includes for delegated methods
27 : #include "AliESDCaloTrigger.h"
28 : #include "AliESDRun.h"
29 : #include "AliESDHeader.h"
30 : #include "AliESDTZERO.h"
31 : #include "AliESDFIT.h"
32 : #include "AliESDZDC.h"
33 : #include "AliESDACORDE.h"
34 : #include "AliESDAD.h"
35 : #include "AliMultiplicity.h"
36 :
37 : // AliESDtrack has to be included so that the compiler
38 : // knows its inheritance tree (= that it is a AliVParticle).
39 : #include "AliESDtrack.h"
40 : // same for AliESDVertex (which is a AliVVertex)
41 : #include "AliESDVertex.h"
42 : // same for CaloCells and CaloClusters (which is a AliVCaloCells, AliVCluster)
43 : #include "AliESDCaloCluster.h"
44 : #include "AliESDCaloCells.h"
45 :
46 : #include "AliESDVZERO.h"
47 : #include "AliESDTrdTrack.h"
48 : #include "AliESDTOFCluster.h"
49 : #include "AliESDTOFHit.h"
50 : #include "AliESDTOFMatch.h"
51 : #include "AliESDfriend.h"
52 : #include "AliESDv0.h"
53 :
54 : class AliESDkink;
55 : class AliESDHLTtrack;
56 : class AliESDVertex;
57 : class AliESDPmdTrack;
58 : class AliESDFMD;
59 : class AliESDkink;
60 : class AliESDv0;
61 : class AliRawDataErrorLog;
62 : class AliESDRun;
63 : class AliESDTrdTrigger;
64 : class AliESDTrdTracklet;
65 : class AliESDMuonTrack;
66 : class AliESDMuonCluster;
67 : class AliESDMuonPad;
68 : class AliESDMuonGlobalTrack; // AU
69 : class AliESD;
70 : class AliESDcascade;
71 : class AliCentrality;
72 : class AliEventplane;
73 : class TRefArray;
74 : class AliESDACORDE;
75 : class AliESDAD;
76 : class AliESDHLTDecision;
77 : class AliESDCosmicTrack;
78 :
79 : class TList;
80 : class TString;
81 :
82 :
83 : class AliESDEvent : public AliVEvent {
84 : public:
85 :
86 :
87 : enum ESDListIndex {kESDRun,
88 : kHeader,
89 : kESDZDC,
90 : kESDFMD,
91 : kESDVZERO,
92 : kESDTZERO,
93 : kTPCVertex,
94 : kSPDVertex,
95 : kPrimaryVertex,
96 : kSPDMult,
97 : kPHOSTrigger,
98 : kEMCALTrigger,
99 : kSPDPileupVertices,
100 : kTrkPileupVertices,
101 : kTracks,
102 : kMuonTracks,
103 : kMuonClusters,
104 : kMuonPads,
105 : kMuonGlobalTracks, // AU
106 : kPmdTracks,
107 : kTrdTrigger,
108 : kTrdTracks,
109 : kTrdTracklets,
110 : kV0s,
111 : kCascades,
112 : kKinks,
113 : kCaloClusters,
114 : kEMCALCells,
115 : kPHOSCells,
116 : kErrorLogs,
117 : kESDACORDE,
118 : kESDAD,
119 : kTOFHeader,
120 : kCosmicTracks,
121 : kTOFclusters,
122 : kTOFhit,
123 : kTOFmatch,
124 : kESDFIT,
125 : kESDListN
126 : };
127 :
128 : AliESDEvent();
129 : virtual ~AliESDEvent();
130 : AliESDEvent &operator=(const AliESDEvent& source); // or make private and use only copy?
131 : virtual void Copy(TObject& obj) const;
132 :
133 : // RUN
134 : // move this to the UserData!!!
135 172 : const AliESDRun* GetESDRun() const {return fESDRun;}
136 :
137 : // Delegated methods for fESDRun
138 0 : const AliTimeStamp* GetCTPStart() const {return fESDRun ? &fESDRun->GetCTPStart() : 0;}
139 0 : void SetCTPStart(const AliTimeStamp* t) {if(fESDRun) fESDRun->SetCTPStart(t);}
140 64 : void SetRunNumber(Int_t n) {if(fESDRun) fESDRun->SetRunNumber(n);}
141 556 : Int_t GetRunNumber() const {return fESDRun?fESDRun->GetRunNumber():-1;}
142 : void SetPeriodNumber(UInt_t n){
143 24 : if(fESDRun) fESDRun->SetPeriodNumber(n);
144 16 : if(fHeader) fHeader->SetPeriodNumber(n);
145 8 : }
146 96 : UInt_t GetPeriodNumber() const {return fESDRun?fESDRun->GetPeriodNumber():0;}
147 64 : void SetMagneticField(Double_t mf){if(fESDRun) fESDRun->SetMagneticField(mf);}
148 14492 : Double_t GetMagneticField() const {return fESDRun?fESDRun->GetMagneticField():0;}
149 32 : void SetDiamond(const AliESDVertex *vertex) { if(fESDRun) fESDRun->SetDiamond(vertex);}
150 32 : Double_t GetDiamondX() const {return fESDRun?fESDRun->GetDiamondX():0;}
151 32 : Double_t GetDiamondY() const {return fESDRun?fESDRun->GetDiamondY():0;}
152 32 : Double_t GetDiamondZ() const {return fESDRun?fESDRun->GetDiamondZ():0;}
153 0 : Double_t GetSigma2DiamondX() const {return fESDRun?fESDRun->GetSigma2DiamondX():0;}
154 0 : Double_t GetSigma2DiamondY() const {return fESDRun?fESDRun->GetSigma2DiamondY():0;}
155 64 : Double_t GetSigma2DiamondZ() const {return fESDRun?fESDRun->GetSigma2DiamondZ():0;}
156 32 : void GetDiamondCovXY(Float_t cov[3]) const {if(fESDRun) fESDRun->GetDiamondCovXY(cov);}
157 576 : void SetTriggerClass(const char*name, Int_t index) {if(fESDRun) fESDRun->SetTriggerClass(name,index);}
158 40 : void SetPHOSMatrix(TGeoHMatrix*matrix, Int_t i) {if(fESDRun) fESDRun->SetPHOSMatrix(matrix,i);}
159 64 : const TGeoHMatrix* GetPHOSMatrix(Int_t i) const {return fESDRun?fESDRun->GetPHOSMatrix(i):0x0;}
160 120 : void SetEMCALMatrix(TGeoHMatrix*matrix, Int_t i) {if(fESDRun) fESDRun->SetEMCALMatrix(matrix,i);}
161 144 : const TGeoHMatrix* GetEMCALMatrix(Int_t i) const {return fESDRun?fESDRun->GetEMCALMatrix(i):0x0;}
162 0 : void SetCaloTriggerType(const Int_t* type) {if (fESDRun) fESDRun->SetCaloTriggerType(type);}
163 0 : void SetCaloTriggerType(int i,const Int_t* type) {if (fESDRun) fESDRun->SetCaloTriggerType(i,type);}
164 8 : Int_t* GetCaloTriggerType() const {return fESDRun?fESDRun->GetCaloTriggerType():0x0;}
165 0 : Int_t* GetCaloTriggerType(int i) const {return fESDRun?fESDRun->GetCaloTriggerType(i):0x0;}
166 32 : virtual const Float_t* GetVZEROEqFactors() const {return fESDRun?fESDRun->GetVZEROEqFactors():0x0;}
167 : virtual Float_t GetVZEROEqMultiplicity(Int_t i) const;
168 :
169 : //
170 64 : void SetCurrentL3(Float_t cur) const {if(fESDRun) fESDRun->SetCurrentL3(cur);}
171 64 : void SetCurrentDip(Float_t cur) const {if(fESDRun) fESDRun->SetCurrentDip(cur);}
172 64 : void SetBeamEnergy(Float_t be) const {if(fESDRun) fESDRun->SetBeamEnergy(be);}
173 64 : void SetBeamType(const char* bt) const {if(fESDRun) fESDRun->SetBeamType(bt);}
174 128 : void SetBeamParticle(Int_t az, Int_t ibeam) {if(fESDRun) fESDRun->SetBeamParticle(az,ibeam);}
175 48 : void SetUniformBMap(Bool_t val=kTRUE) const {if(fESDRun) fESDRun->SetBit(AliESDRun::kUniformBMap,val);}
176 48 : void SetBInfoStored(Bool_t val=kTRUE) const {if(fESDRun) fESDRun->SetBit(AliESDRun::kBInfoStored,val);}
177 : //
178 0 : Float_t GetCurrentL3() const {return fESDRun?fESDRun->GetCurrentL3():0;}
179 32 : Float_t GetCurrentDip() const {return fESDRun?fESDRun->GetCurrentDip():0;}
180 0 : Float_t GetBeamEnergy() const {return fESDRun?fESDRun->GetBeamEnergy():0;}
181 0 : const char* GetBeamType() const {return fESDRun?fESDRun->GetBeamType():0;}
182 0 : Int_t GetBeamParticle(Int_t ibeam) const {return fESDRun?fESDRun->GetBeamParticle(ibeam):0;}
183 0 : Int_t GetBeamParticleA(Int_t ibeam) const {return fESDRun?fESDRun->GetBeamParticleA(ibeam):0;}
184 0 : Int_t GetBeamParticleZ(Int_t ibeam) const {return fESDRun?fESDRun->GetBeamParticleZ(ibeam):0;}
185 0 : Bool_t IsUniformBMap() const {return fESDRun?fESDRun->TestBit(AliESDRun::kUniformBMap):kFALSE;}
186 : //
187 0 : virtual Bool_t InitMagneticField() const {return fESDRun?fESDRun->InitMagneticField():kFALSE;}
188 64 : void SetT0spread(Float_t *t) const {if(fESDRun) fESDRun->SetT0spread(t);}
189 0 : Float_t GetT0spread(Int_t i) const {return fESDRun?fESDRun->GetT0spread(i):0;}
190 32 : virtual void SetVZEROEqFactors(Float_t factors[64]) const {if(fESDRun) fESDRun->SetVZEROEqFactors(factors);}
191 : // HEADER
192 440 : AliESDHeader* GetHeader() const {return fHeader;}
193 :
194 : // Delegated methods for fHeader
195 32 : void SetTriggerMask(ULong64_t n) {if(fHeader) fHeader->SetTriggerMask(n);}
196 32 : void SetTriggerMaskNext50(ULong64_t n) {if(fHeader) fHeader->SetTriggerMaskNext50(n);}
197 32 : void SetOrbitNumber(UInt_t n) {if(fHeader) fHeader->SetOrbitNumber(n);}
198 64 : void SetTimeStamp(UInt_t timeStamp){if(fHeader) fHeader->SetTimeStamp(timeStamp);}
199 32 : void SetEventType(UInt_t eventType){if(fHeader) fHeader->SetEventType(eventType);}
200 64 : void SetEventSpecie(UInt_t eventSpecie){if(fHeader) fHeader->SetEventSpecie(eventSpecie);}
201 64 : void SetEventNumberInFile(Int_t n) {if(fHeader) fHeader->SetEventNumberInFile(n);}
202 : // void SetRunNumber(Int_t n) {if(fHeader) fHeader->SetRunNumber(n);}
203 32 : void SetBunchCrossNumber(UShort_t n) {if(fHeader) fHeader->SetBunchCrossNumber(n);}
204 32 : void SetTriggerCluster(UChar_t n) {if(fHeader) fHeader->SetTriggerCluster(n);}
205 :
206 1680 : ULong64_t GetTriggerMask() const {return fHeader?fHeader->GetTriggerMask():0;}
207 1648 : ULong64_t GetTriggerMaskNext50() const {return fHeader?fHeader->GetTriggerMaskNext50():0;}
208 : //TString GetFiredTriggerClasses() const {return (fESDRun&&fHeader)?fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask()):"";}
209 80 : TString GetFiredTriggerClasses() const {return (fESDRun&&fHeader)?fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask(),fHeader->GetTriggerMaskNext50()):"";}
210 : //Bool_t IsTriggerClassFired(const char *name) const {return (fESDRun&&fHeader)?fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name):kFALSE;}
211 0 : Bool_t IsTriggerClassFired(const char *name) const {return (fESDRun&&fHeader)?fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),fHeader->GetTriggerMaskNext50(),name):kFALSE;}
212 : Bool_t IsEventSelected(const char *trigExpr) const;
213 : TObject* GetHLTTriggerDecision() const;
214 : TString GetHLTTriggerDescription() const;
215 : Bool_t IsHLTTriggerFired(const char* name=NULL) const;
216 112 : UInt_t GetOrbitNumber() const {return fHeader?fHeader->GetOrbitNumber():0;}
217 288 : UInt_t GetTimeStamp() const { return fHeader?fHeader->GetTimeStamp():0;}
218 : UInt_t GetTimeStampCTP() const;
219 : UInt_t GetTimeStampCTPBCCorr() const;
220 112 : UInt_t GetEventType() const { return fHeader?fHeader->GetEventType():0;}
221 32 : UInt_t GetEventSpecie() const { return fHeader?fHeader->GetEventSpecie():0;}
222 600 : Int_t GetEventNumberInFile() const {return fHeader?fHeader->GetEventNumberInFile():-1;}
223 124 : UShort_t GetBunchCrossNumber() const {return fHeader?fHeader->GetBunchCrossNumber():0;}
224 64 : UChar_t GetTriggerCluster() const {return fHeader?fHeader->GetTriggerCluster():0;}
225 : Bool_t IsDetectorInTriggerCluster(TString detector, AliTriggerConfiguration* trigConf) const;
226 : // ZDC CKB: put this in the header?
227 0 : AliESDZDC* GetESDZDC() const {return fESDZDC;}
228 16 : AliESDZDC* GetZDCData() const {return fESDZDC;}
229 :
230 : void SetZDCData(const AliESDZDC * obj);
231 :
232 : // Delegated methods for fESDZDC
233 64 : Double_t GetZDCN1Energy() const {return fESDZDC?fESDZDC->GetZDCN1Energy():0;}
234 64 : Double_t GetZDCP1Energy() const {return fESDZDC?fESDZDC->GetZDCP1Energy():0;}
235 64 : Double_t GetZDCN2Energy() const {return fESDZDC?fESDZDC->GetZDCN2Energy():0;}
236 64 : Double_t GetZDCP2Energy() const {return fESDZDC?fESDZDC->GetZDCP2Energy():0;}
237 128 : Double_t GetZDCEMEnergy(Int_t i=0) const {return fESDZDC?fESDZDC->GetZDCEMEnergy(i):0;}
238 32 : Int_t GetZDCParticipants() const {return fESDZDC?fESDZDC->GetZDCParticipants():0;}
239 : AliCentrality* GetCentrality();
240 : AliEventplane* GetEventplane();
241 :
242 :
243 : void SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t em1Energy, Float_t em2Energy,
244 : Float_t n2Energy, Float_t p2Energy, Int_t participants, Int_t nPartA,
245 : Int_t nPartC, Double_t b, Double_t bA, Double_t bC, UInt_t recoflag)
246 0 : {if(fESDZDC) fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy,
247 0 : participants, nPartA, nPartC, b, bA, bC, recoflag);}
248 : // FMD
249 : void SetFMDData(AliESDFMD * obj);
250 0 : AliESDFMD *GetFMDData() const { return fESDFMD; }
251 :
252 : // FIT methods
253 0 : const AliESDFIT* GetESDFIT() const {return fESDFIT;}
254 : void SetFITData(const AliESDFIT * obj);
255 :
256 :
257 : // TZERO CKB: put this in the header?
258 16 : const AliESDTZERO* GetESDTZERO() const {return fESDTZERO;}
259 : void SetTZEROData(const AliESDTZERO * obj);
260 : // delegetated methods for fESDTZERO
261 :
262 32 : Double32_t GetT0zVertex() const {return fESDTZERO?fESDTZERO->GetT0zVertex():0;}
263 0 : void SetT0zVertex(Double32_t z) {if(fESDTZERO) fESDTZERO->SetT0zVertex(z);}
264 0 : Double32_t GetT0() const {return fESDTZERO?fESDTZERO->GetT0():0;}
265 0 : void SetT0(Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0(timeStart);}
266 0 : Double32_t GetT0clock() const {return fESDTZERO?fESDTZERO->GetT0clock():0;}
267 0 : void SetT0clock(Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0clock(timeStart);}
268 0 : Double32_t GetT0TOF(Int_t icase) const {return fESDTZERO?fESDTZERO->GetT0TOF(icase):0;}
269 32 : const Double32_t * GetT0TOF() const {return fESDTZERO?fESDTZERO->GetT0TOF():0x0;}
270 0 : void SetT0TOF(Int_t icase,Double32_t timeStart) {if(fESDTZERO) fESDTZERO->SetT0TOF(icase,timeStart);}
271 0 : const Double32_t * GetT0time() const {return fESDTZERO?fESDTZERO->GetT0time():0x0;}
272 0 : void SetT0time(Double32_t time[24]) {if(fESDTZERO) fESDTZERO->SetT0time(time);}
273 0 : const Double32_t * GetT0amplitude() const {return fESDTZERO?fESDTZERO->GetT0amplitude():0x0;}
274 0 : void SetT0amplitude(Double32_t amp[24]){if(fESDTZERO) fESDTZERO->SetT0amplitude(amp);}
275 0 : Int_t GetT0Trig() const { return fESDTZERO?fESDTZERO->GetT0Trig():0;}
276 0 : void SetT0Trig(Int_t tvdc) {if(fESDTZERO) fESDTZERO->SetT0Trig(tvdc);}
277 :
278 : // VZERO
279 48 : AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
280 : void SetVZEROData(const AliESDVZERO * obj);
281 : Int_t GetVZEROData( AliESDVZERO &v ) const {
282 0 : if( fESDVZERO ){ v=*fESDVZERO; return 0; }
283 0 : return -1;
284 0 : }
285 :
286 : // ACORDE
287 0 : AliESDACORDE *GetACORDEData() const { return fESDACORDE;}
288 : void SetACORDEData(AliESDACORDE * obj);
289 :
290 : // AD
291 32 : AliESDAD *GetADData() const { return fESDAD;}
292 : void SetADData(AliESDAD * obj);
293 :
294 :
295 :
296 :
297 : void SetESDfriend(const AliESDfriend *f) const;
298 : void GetESDfriend(AliESDfriend *f);
299 : virtual AliESDfriend* FindFriend() const;
300 :
301 : void SetPrimaryVertexTPC(const AliESDVertex *vertex);
302 16 : const AliESDVertex *GetPrimaryVertexTPC() const {return fTPCVertex;}
303 :
304 : void SetPrimaryVertexSPD(const AliESDVertex *vertex);
305 544 : const AliESDVertex *GetPrimaryVertexSPD() const {return fSPDVertex;}
306 : const AliESDVertex *GetVertex() const {
307 : //For the backward compatibily only
308 280 : return GetPrimaryVertexSPD();
309 : }
310 :
311 : void SetPrimaryVertexTracks(const AliESDVertex *vertex);
312 80 : const AliESDVertex *GetPrimaryVertexTracks() const {return fPrimaryVertex;}
313 : AliESDVertex *PrimaryVertexTracksUnconstrained() const;
314 :
315 : const AliESDVertex *GetPrimaryVertex() const;
316 :
317 : //getters for calibration
318 : Int_t GetPrimaryVertex (AliESDVertex &v) const {
319 0 : if(!GetPrimaryVertex()) return -1;
320 0 : v=*GetPrimaryVertex();
321 0 : return 0;
322 0 : }
323 :
324 : Int_t GetPrimaryVertexTPC (AliESDVertex &v) const {
325 0 : if(!GetPrimaryVertexTPC()) return -1;
326 0 : v=*GetPrimaryVertexTPC();
327 0 : return 0;
328 0 : }
329 :
330 : Int_t GetPrimaryVertexSPD (AliESDVertex &v) const {
331 0 : if(!GetPrimaryVertexSPD()) return -1;
332 0 : v=*GetPrimaryVertexSPD();
333 0 : return 0;
334 0 : }
335 :
336 : Int_t GetPrimaryVertexTracks (AliESDVertex &v) const {
337 0 : if(!GetPrimaryVertexTracks()) return -1;
338 0 : v=*GetPrimaryVertexTracks();
339 0 : return 0;
340 0 : }
341 :
342 :
343 : void SetTOFHeader(const AliTOFHeader * tofEventTime);
344 128 : AliTOFHeader *GetTOFHeader() const {return fTOFHeader;}
345 0 : Float_t GetEventTimeSpread() const {if (fTOFHeader) return fTOFHeader->GetT0spread(); else return 0.;}
346 0 : Float_t GetTOFTimeResolution() const {if (fTOFHeader) return fTOFHeader->GetTOFResolution(); else return 0.;}
347 :
348 10130 : TClonesArray *GetESDTOFClusters() const {return fESDTOFClusters;}
349 4520 : TClonesArray *GetESDTOFHits() const {return fESDTOFHits;}
350 32864 : TClonesArray *GetESDTOFMatches() const {return fESDTOFMatches;}
351 :
352 : void SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster,Int_t *mapping=NULL);
353 : void SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster[],Int_t *mapping=NULL);
354 0 : Int_t GetNTOFclusters() const {return fESDTOFClusters ? fESDTOFClusters->GetEntriesFast() : 0;}
355 :
356 0 : Int_t GetNumberOfITSClusters(Int_t lr) const {return fSPDMult ? fSPDMult->GetNumberOfITSClusters(lr) : 0;}
357 : void SetMultiplicity(const AliMultiplicity *mul);
358 :
359 96 : AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
360 : Int_t GetMultiplicity( AliMultiplicity & mult ) const {
361 0 : if( fSPDMult ){ mult=*fSPDMult; return 0; }
362 0 : return -1;
363 0 : }
364 : void EstimateMultiplicity(Int_t &tracklets,Int_t &trITSTPC,Int_t &trITSSApure,
365 : Double_t eta=1.,Bool_t useDCAFlag=kTRUE,Bool_t useV0Flag=kTRUE) const;
366 :
367 32 : Int_t GetNumberOfTPCClusters() const {return fNTPCClusters;}
368 16 : void SetNumberOfTPCClusters(int n) {fNTPCClusters = n;}
369 :
370 : Bool_t Clean(Float_t *cleanPars, TObjArray* track2destroy);
371 : Bool_t RemoveKink(Int_t i) const;
372 : Bool_t RemoveV0(Int_t i) const;
373 : AliESDfriendTrack* RemoveTrack(Int_t i) const;
374 :
375 : const AliESDVertex *GetPileupVertexSPD(Int_t i) const {
376 0 : return (const AliESDVertex *)(fSPDPileupVertices?fSPDPileupVertices->At(i):0x0);
377 : }
378 : Char_t AddPileupVertexSPD(const AliESDVertex *vtx);
379 : const AliESDVertex *GetPileupVertexTracks(Int_t i) const {
380 0 : return (const AliESDVertex *)(fTrkPileupVertices?fTrkPileupVertices->At(i):0x0);
381 : }
382 : Char_t AddPileupVertexTracks(const AliESDVertex *vtx);
383 0 : TClonesArray* GetPileupVerticesTracks() const {return (TClonesArray*)fTrkPileupVertices;}
384 0 : TClonesArray* GetPileupVerticesSPD() const {return (TClonesArray*)fSPDPileupVertices;}
385 :
386 : virtual Bool_t IsPileupFromSPD(Int_t minContributors=3,
387 : Double_t minZdist=0.8,
388 : Double_t nSigmaZdist=3.,
389 : Double_t nSigmaDiamXY=2.,
390 : Double_t nSigmaDiamZ=5.) const;
391 :
392 : virtual Bool_t IsPileupFromSPDInMultBins() const;
393 :
394 : void ConnectTracks();
395 0 : Bool_t AreTracksConnected() const {return fTracksConnected;}
396 :
397 57232 : AliESDtrack *GetTrack(Int_t i) const {return (fTracks)?(AliESDtrack*)fTracks->At(i) : 0;}
398 : Int_t AddTrack(const AliESDtrack *t);
399 :
400 0 : AliESDtrack *GetVTrack(Int_t i) const {return GetTrack(i);}
401 :
402 : /// add new track at the end of tracks array and return instance
403 : AliESDtrack* NewTrack();
404 :
405 : AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
406 : // return (AliESDHLTtrack *)fHLTConfMapTracks->At(i);
407 0 : return 0;
408 : }
409 : void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
410 0 : printf("ESD:: AddHLTConfMapTrack do nothing \n");
411 : // TClonesArray &fhlt = *fHLTConfMapTracks;
412 : // new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
413 0 : }
414 :
415 :
416 : AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
417 : // return (AliESDHLTtrack *)fHLTHoughTracks->At(i);
418 0 : return 0;
419 : }
420 : void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
421 0 : printf("ESD:: AddHLTHoughTrack do nothing \n");
422 : // TClonesArray &fhlt = *fHLTHoughTracks;
423 : // new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
424 0 : }
425 :
426 : Bool_t MoveMuonObjects();
427 :
428 : AliESDMuonTrack* GetMuonTrack(Int_t i);
429 : AliESDMuonTrack* NewMuonTrack();
430 :
431 : AliESDMuonCluster* GetMuonCluster(Int_t i);
432 : AliESDMuonCluster* FindMuonCluster(UInt_t clusterId);
433 : AliESDMuonCluster* NewMuonCluster();
434 :
435 : AliESDMuonPad* GetMuonPad(Int_t i);
436 : AliESDMuonPad* FindMuonPad(UInt_t padId);
437 : AliESDMuonPad* NewMuonPad();
438 :
439 : AliESDMuonGlobalTrack* GetMuonGlobalTrack(Int_t i); // AU
440 : AliESDMuonGlobalTrack* NewMuonGlobalTrack(); // AU
441 :
442 : AliESDPmdTrack *GetPmdTrack(Int_t i) const {
443 688 : return (AliESDPmdTrack *)(fPmdTracks?fPmdTracks->At(i):0x0);
444 : }
445 :
446 : void AddPmdTrack(const AliESDPmdTrack *t);
447 :
448 :
449 : AliESDTrdTrack *GetTrdTrack(Int_t i) const {
450 18552 : return (AliESDTrdTrack *)(fTrdTracks?fTrdTracks->At(i):0x0);
451 : }
452 :
453 :
454 : void SetTrdTrigger(const AliESDTrdTrigger *t);
455 :
456 : AliESDTrdTrigger* GetTrdTrigger() const {
457 0 : return (AliESDTrdTrigger*)(fTrdTrigger);
458 : }
459 :
460 : void AddTrdTrack(const AliESDTrdTrack *t);
461 :
462 : AliESDTrdTracklet* GetTrdTracklet(Int_t idx) const {
463 292 : return (AliESDTrdTracklet*)(fTrdTracklets?fTrdTracklets->At(idx):0x0);
464 : }
465 :
466 : void AddTrdTracklet(const AliESDTrdTracklet *trkl);
467 : void AddTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label = -1);
468 :
469 : using AliVEvent::GetV0;
470 : AliESDv0 *GetV0(Int_t i) const {
471 512 : return (AliESDv0*)(fV0s?fV0s->At(i):0x0);
472 : }
473 :
474 : Int_t GetV0(AliESDv0 &v0dum, Int_t i) const {
475 0 : if(!GetV0(i)) return -1;
476 0 : v0dum=*GetV0(i);
477 0 : return 0;}
478 :
479 : Int_t AddV0(const AliESDv0 *v);
480 :
481 : AliESDcascade *GetCascade(Int_t i) const {
482 0 : return (AliESDcascade *)(fCascades?fCascades->At(i):0x0);
483 : }
484 :
485 : void AddCascade(const AliESDcascade *c);
486 :
487 : AliESDkink *GetKink(Int_t i) const {
488 5248 : return (AliESDkink *)(fKinks?fKinks->At(i):0x0);
489 : }
490 : Int_t AddKink(const AliESDkink *c);
491 :
492 : AliESDCaloCluster *GetCaloCluster(Int_t i) const {
493 1092 : return (AliESDCaloCluster *)(fCaloClusters?fCaloClusters->At(i):0x0);
494 : }
495 :
496 : Int_t AddCaloCluster(const AliESDCaloCluster *c);
497 :
498 48 : AliESDCaloCells *GetEMCALCells() const {return fEMCALCells; }
499 48 : AliESDCaloCells *GetPHOSCells() const {return fPHOSCells; }
500 :
501 : AliESDCaloTrigger* GetCaloTrigger(TString calo) const
502 : {
503 72 : if (calo.Contains("EMCAL")) return fEMCALTrigger;
504 : else
505 12 : return fPHOSTrigger;
506 28 : }
507 :
508 : AliESDCosmicTrack *GetCosmicTrack(Int_t i) const {
509 0 : return fCosmicTracks ? (AliESDCosmicTrack*) fCosmicTracks->At(i) : 0;
510 : }
511 0 : const TClonesArray * GetCosmicTracks() const{ return fCosmicTracks;}
512 :
513 : void AddCosmicTrack(const AliESDCosmicTrack *t);
514 :
515 : AliRawDataErrorLog *GetErrorLog(Int_t i) const {
516 0 : return (AliRawDataErrorLog *)(fErrorLogs?fErrorLogs->At(i):0x0);
517 : }
518 : void AddRawDataErrorLog(const AliRawDataErrorLog *log) const;
519 :
520 0 : Int_t GetNumberOfErrorLogs() const {return fErrorLogs?fErrorLogs->GetEntriesFast():0;}
521 :
522 : Int_t GetNumberOfPileupVerticesSPD() const {
523 64 : return (fSPDPileupVertices?fSPDPileupVertices->GetEntriesFast():0);
524 : }
525 : Int_t GetNumberOfPileupVerticesTracks() const {
526 64 : return (fTrkPileupVertices?fTrkPileupVertices->GetEntriesFast():0);
527 : }
528 6332 : Int_t GetNumberOfTracks() const {return fTracks?fTracks->GetEntriesFast():0;}
529 0 : Int_t GetNumberOfESDTracks() const { return GetNumberOfTracks(); }
530 0 : Int_t GetNumberOfHLTConfMapTracks() const {return 0;}
531 : // fHLTConfMapTracks->GetEntriesFast();}
532 0 : Int_t GetNumberOfHLTHoughTracks() const {return 0; }
533 : // fHLTHoughTracks->GetEntriesFast(); }
534 :
535 32 : Int_t GetNumberOfMuonTracks() const {return fMuonTracks?fMuonTracks->GetEntriesFast():0;}
536 : Int_t GetNumberOfMuonClusters();
537 : Int_t GetNumberOfMuonPads();
538 0 : Int_t GetNumberOfMuonGlobalTracks() const {return fMuonGlobalTracks?fMuonGlobalTracks->GetEntriesFast():0;} // AU
539 784 : Int_t GetNumberOfPmdTracks() const {return fPmdTracks?fPmdTracks->GetEntriesFast():0;}
540 64 : Int_t GetNumberOfTrdTracks() const {return fTrdTracks?fTrdTracks->GetEntriesFast():0;}
541 0 : Int_t GetNumberOfTrdTracklets() const {return fTrdTracklets?fTrdTracklets->GetEntriesFast():0;}
542 440 : Int_t GetNumberOfV0s() const {return fV0s?fV0s->GetEntriesFast():0;}
543 136 : Int_t GetNumberOfCascades() const {return fCascades?fCascades->GetEntriesFast():0;}
544 168 : Int_t GetNumberOfKinks() const {return fKinks?fKinks->GetEntriesFast():0;}
545 :
546 0 : Int_t GetNumberOfCosmicTracks() const {return fCosmicTracks ? fCosmicTracks->GetEntriesFast():0;}
547 : Int_t GetEMCALClusters(TRefArray *clusters) const;
548 : Int_t GetPHOSClusters(TRefArray *clusters) const;
549 748 : Int_t GetNumberOfCaloClusters() const {return fCaloClusters?fCaloClusters->GetEntriesFast():0;}
550 :
551 0 : void SetUseOwnList(Bool_t b){fUseOwnList = b;}
552 0 : Bool_t GetUseOwnList() const {return fUseOwnList;}
553 :
554 0 : void ResetV0s() { if(fV0s) fV0s->Clear(); }
555 0 : void ResetCascades() { if(fCascades) fCascades->Clear(); }
556 : void Reset();
557 :
558 : void Print(Option_t *option="") const;
559 :
560 : void AddObject(TObject* obj);
561 : void ReadFromTree(TTree *tree, Option_t* opt = "");
562 : TObject* FindListObject(const char *name) const;
563 48 : AliESD *GetAliESDOld(){return fESDOld;}
564 : void WriteToTree(TTree* tree) const;
565 : void GetStdContent();
566 : void ResetStdContent();
567 : void CreateStdContent();
568 : void CreateStdContent(Bool_t bUseThisList);
569 : void CompleteStdContent();
570 : void SetStdNames();
571 : void CopyFromOldESD();
572 12 : TList* GetList() const {return fESDObjects;}
573 :
574 : //part of the hlt interface
575 0 : void SetFriendEvent( AliVfriendEvent *f ) { AddObject(f); SetESDfriend(dynamic_cast<AliESDfriend*>(f));}
576 :
577 : //Following needed only for mixed event
578 0 : virtual Int_t EventIndex(Int_t) const {return 0;}
579 0 : virtual Int_t EventIndexForCaloCluster(Int_t) const {return 0;}
580 0 : virtual Int_t EventIndexForPHOSCell(Int_t) const {return 0;}
581 0 : virtual Int_t EventIndexForEMCALCell(Int_t) const {return 0;}
582 :
583 0 : void SetDetectorStatus(ULong_t detMask) {fDetectorStatus|=detMask;}
584 0 : void ResetDetectorStatus(ULong_t detMask) {fDetectorStatus&=~detMask;}
585 0 : ULong_t GetDetectorStatus() const {return fDetectorStatus;}
586 0 : Bool_t IsDetectorOn(ULong_t detMask) const {return (fDetectorStatus&detMask)>0;}
587 :
588 8 : void SetDAQDetectorPattern(UInt_t pattern) {fDAQDetectorPattern = pattern;}
589 8 : void SetDAQAttributes(UInt_t attributes) {fDAQAttributes = attributes;}
590 0 : UInt_t GetDAQDetectorPattern() const {return fDAQDetectorPattern;}
591 16 : UInt_t GetDAQAttributes() const {return fDAQAttributes;}
592 :
593 : Bool_t IsIncompleteDAQ();
594 : //
595 40 : void SetNTPCFriend2Store(Int_t v) {fNTPCFriend2Store=v;}
596 16 : Int_t GetNTPCFriend2Store() const {return fNTPCFriend2Store;}
597 : //
598 : virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
599 :
600 : protected:
601 : AliESDEvent(const AliESDEvent&);
602 : static Bool_t ResetWithPlacementNew(TObject *pObject);
603 :
604 : void AddMuonTrack(const AliESDMuonTrack *t);
605 : void AddMuonGlobalTrack(const AliESDMuonGlobalTrack *t); // AU
606 :
607 : TList *fESDObjects; // List of esd Objects
608 :
609 : AliESDRun *fESDRun; //! Run information tmp put in the Userdata
610 : AliESDHeader *fHeader; //! ESD Event Header
611 : AliESDZDC *fESDZDC; //! ZDC information
612 : AliESDFMD *fESDFMD; //! FMD object containing rough multiplicity
613 : AliESDVZERO *fESDVZERO; //! VZERO object containing rough multiplicity
614 : AliESDTZERO *fESDTZERO; //! TZEROObject
615 : AliESDFIT *fESDFIT; //! FITObject
616 : AliESDVertex *fTPCVertex; //! Primary vertex estimated by the TPC
617 : AliESDVertex *fSPDVertex; //! Primary vertex estimated by the SPD
618 : AliESDVertex *fPrimaryVertex; //! Primary vertex estimated using ESD tracks
619 : AliMultiplicity *fSPDMult; //! SPD tracklet multiplicity
620 : AliESDCaloTrigger* fPHOSTrigger; //! PHOS Trigger information
621 : AliESDCaloTrigger* fEMCALTrigger; //! PHOS Trigger information
622 : AliESDACORDE *fESDACORDE; //! ACORDE ESD object caontaining bit pattern
623 : AliESDAD *fESDAD; //! AD ESD object caontaining bit pattern
624 : AliESDTrdTrigger *fTrdTrigger; //! TRD trigger information
625 :
626 : TClonesArray *fSPDPileupVertices;//! Pileup primary vertices reconstructed by SPD
627 : TClonesArray *fTrkPileupVertices;//! Pileup primary vertices reconstructed using the tracks
628 : TClonesArray *fTracks; //! ESD tracks
629 : TClonesArray *fMuonTracks; //! MUON ESD tracks
630 : TClonesArray *fMuonClusters; //! MUON ESD clusters
631 : TClonesArray *fMuonPads; //! MUON ESD pads
632 : TClonesArray *fMuonGlobalTracks; //! MUON+MFT ESD tracks // AU
633 : TClonesArray *fPmdTracks; //! PMD ESD tracks
634 : TClonesArray *fTrdTracks; //! TRD ESD tracks (triggered)
635 : TClonesArray *fTrdTracklets; //! TRD tracklets (for trigger)
636 : TClonesArray *fV0s; //! V0 vertices
637 : TClonesArray *fCascades; //! Cascade vertices
638 : TClonesArray *fKinks; //! Kinks
639 : TClonesArray *fCaloClusters; //! Calorimeter clusters for PHOS/EMCAL
640 : AliESDCaloCells *fEMCALCells; //! EMCAL cell info
641 : AliESDCaloCells *fPHOSCells; //! PHOS cell info
642 : TClonesArray *fCosmicTracks; //! Tracks created by cosmics finder
643 : TClonesArray *fESDTOFClusters; //! TOF clusters
644 : TClonesArray *fESDTOFHits; //! TOF hits (used for clusters)
645 : TClonesArray *fESDTOFMatches; //! TOF matching info (with the reference to tracks)
646 : TClonesArray *fErrorLogs; //! Raw-data reading error messages
647 :
648 : Bool_t fOldMuonStructure; //! Flag if reading ESD with old MUON structure
649 :
650 : AliESD *fESDOld; //! Old esd Structure
651 : AliESDfriend *fESDFriendOld; //! Old friend esd Structure
652 : Bool_t fConnected; //! flag if leaves are alreday connected
653 : Bool_t fUseOwnList; //! Do not use the list from the esdTree but use the one created by this class
654 : Bool_t fTracksConnected; //! flag if tracks have already pointer to event set
655 : static const char* fgkESDListName[kESDListN]; //!
656 :
657 : AliTOFHeader *fTOFHeader; //! event times (and sigmas) as estimated by TOF
658 : // combinatorial algorithm.
659 : // It contains also TOF time resolution
660 : // and T0spread as written in OCDB
661 : AliCentrality *fCentrality; //! Centrality for AA collision
662 : AliEventplane *fEventplane; //! Event plane for AA collision
663 : Int_t fNTPCFriend2Store; //! number of TPC friend tracks to store
664 : ULong64_t fDetectorStatus; // set detector event status bit for good event selection
665 : UInt_t fDAQDetectorPattern; // Detector pattern from DAQ: bit 0 is SPD, bit 4 is TPC, etc. See event.h
666 : UInt_t fDAQAttributes; // Third word of attributes from DAQ: bit 7 corresponds to HLT decision
667 : Int_t fNTPCClusters; // number of TPC clusters
668 :
669 484 : ClassDef(AliESDEvent,27) //ESDEvent class
670 : };
671 : #endif
672 :
|
