ESD can init the Bfield via AliESDRun::InitMagneticField()
[u/mrichter/AliRoot.git] / STEER / AliESDEvent.h
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 //-------------------------------------------------------------------------
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
23 class TList;
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 "AliESDZDC.h"
32 #include "AliESDACORDE.h"
33
34 // AliESDtrack has to be included so that the compiler 
35 // knows its inheritance tree (= that it is a AliVParticle).
36 #include "AliESDtrack.h"
37 // same for AliESDVertex (which is a AliVVertex)
38 #include "AliESDVertex.h"
39
40 class AliESDfriend;
41 class AliESDVZERO;
42 class AliESDHLTtrack;
43 class AliESDVertex;
44 class AliESDPmdTrack;
45 class AliESDFMD;
46 class AliESDkink;
47 class AliESDCaloCluster;
48 class AliESDCaloCells;
49 class AliESDv0;
50 class AliMultiplicity;
51 class AliRawDataErrorLog;
52 class AliESDRun;
53 class AliESDTrdTrack;
54 class AliESDMuonTrack;
55 class AliESD;
56 class AliESDcascade;
57 class TRefArray;
58 class AliESDACORDE;
59
60 class AliESDEvent : public AliVEvent {
61 public:
62
63
64   enum ESDListIndex   {kESDRun,
65                        kHeader,
66                        kESDZDC,
67                        kESDFMD,
68                        kESDVZERO,
69                        kESDTZERO,
70                        kTPCVertex,
71                        kSPDVertex,
72                        kPrimaryVertex,
73                        kSPDMult,
74                        kPHOSTrigger,
75                        kEMCALTrigger,
76                        kSPDPileupVertices,
77                        kTrkPileupVertices,
78                        kTracks,
79                        kMuonTracks,
80                        kPmdTracks,
81                        kTrdTracks,
82                        kV0s,
83                        kCascades,
84                        kKinks,
85                        kCaloClusters,
86                        kEMCALCells,
87                        kPHOSCells,
88                        kErrorLogs,
89                        kESDACORDE,
90                        kESDListN
91   };
92
93   AliESDEvent();
94   virtual ~AliESDEvent();
95   AliESDEvent &operator=(const AliESDEvent& source); // or make private and use only copy? 
96   virtual void Copy(TObject& obj) const;
97
98   // RUN
99   // move this to the UserData!!!
100   const AliESDRun*    GetESDRun() const {return fESDRun;}
101
102   // Delegated methods for fESDRun
103   void     SetRunNumber(Int_t n) {fESDRun->SetRunNumber(n);}
104   Int_t    GetRunNumber() const {return fESDRun->GetRunNumber();}
105   void     SetPeriodNumber(UInt_t n){fESDRun->SetPeriodNumber(n);}
106   UInt_t   GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
107   void     SetMagneticField(Double_t mf){fESDRun->SetMagneticField(mf);}
108   Double_t GetMagneticField() const {return fESDRun->GetMagneticField();}
109   void     SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
110   Double_t  GetDiamondX() const {return fESDRun->GetDiamondX();}
111   Double_t  GetDiamondY() const {return fESDRun->GetDiamondY();}
112   Double_t  GetSigma2DiamondX() const {return  fESDRun->GetSigma2DiamondX();}
113   Double_t  GetSigma2DiamondY() const {return  fESDRun->GetSigma2DiamondY();}
114   void      GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}   
115   void     SetTriggerClass(const char*name, Int_t index) {fESDRun->SetTriggerClass(name,index);}
116   void     SetPHOSMatrix(TGeoHMatrix*matrix, Int_t i) {fESDRun->SetPHOSMatrix(matrix,i);}
117   const TGeoHMatrix* GetPHOSMatrix(Int_t i) const {return fESDRun->GetPHOSMatrix(i);}
118   void     SetEMCALMatrix(TGeoHMatrix*matrix, Int_t i) {fESDRun->SetEMCALMatrix(matrix,i);}
119   const TGeoHMatrix* GetEMCALMatrix(Int_t i) const {return fESDRun->GetEMCALMatrix(i);}
120   //
121   void        SetCurrentL3(Float_t cur)           const  {fESDRun->SetCurrentL3(cur);}
122   void        SetCurrentDip(Float_t cur)          const  {fESDRun->SetCurrentDip(cur);}
123   void        SetBeamEnergy(Float_t be)           const  {fESDRun->SetBeamEnergy(be);}
124   void        SetBeamType(const char* bt)         const  {fESDRun->SetBeamType(bt);}
125   void        SetUniformBMap(Bool_t val=kTRUE)    const  {fESDRun->SetBit(AliESDRun::kUniformBMap,val);}
126   void        SetBInfoStored(Bool_t val=kTRUE)    const  {fESDRun->SetBit(AliESDRun::kBInfoStored,val);}
127   //
128   Float_t     GetCurrentL3()                      const  {return fESDRun->GetCurrentL3();}
129   Float_t     GetCurrentDip()                     const  {return fESDRun->GetCurrentDip();}
130   Float_t     SetBeamEnergy()                     const  {return fESDRun->GetBeamEnergy();}
131   const char* GetBeamType()                       const  {return fESDRun->GetBeamType();}
132   Bool_t      IsUniformBMap()                     const  {return fESDRun->TestBit(AliESDRun::kUniformBMap);}
133   //
134   Bool_t      InitMagneticField()                 const  {return fESDRun->InitMagneticField();} 
135   // HEADER
136   AliESDHeader* GetHeader() const {return fHeader;}
137
138   // Delegated methods for fHeader
139   void      SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
140   void      SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
141   void      SetTimeStamp(UInt_t timeStamp){fHeader->SetTimeStamp(timeStamp);}
142   void      SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
143   void      SetEventNumberInFile(Int_t n) {fHeader->SetEventNumberInFile(n);}
144   //  void     SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
145   void      SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
146   void      SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
147   
148   ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
149   TString   GetFiredTriggerClasses() const {return fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask());}
150   Bool_t    IsTriggerClassFired(const char *name) const {return fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name);}
151   Bool_t    IsEventSelected(const char *trigExpr) const;
152   TObject*  GetHLTTriggerDecision() const;
153   TString   GetHLTTriggerDescription() const;
154   Bool_t    IsHLTTriggerFired(const char* name=NULL) const;
155   UInt_t    GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
156   UInt_t    GetTimeStamp()  const { return fHeader->GetTimeStamp();}
157   UInt_t    GetEventType()  const { return fHeader->GetEventType();}
158   Int_t     GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
159   UShort_t  GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
160   UChar_t   GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
161
162   // ZDC CKB: put this in the header?
163   AliESDZDC*    GetESDZDC() const {return fESDZDC;}
164
165   // Delegated methods for fESDZDC
166   Double_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
167   Double_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
168   Double_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
169   Double_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
170   Double_t GetZDCEMEnergy(Int_t i=0) const {return fESDZDC->GetZDCEMEnergy(i);}
171   Int_t   GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
172   void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t em1Energy, Float_t em2Energy,
173                  Float_t n2Energy, Float_t p2Energy, Int_t participants, Int_t nPartA,
174                  Int_t nPartC, Double_t b, Double_t bA, Double_t bC, UInt_t recoflag)
175   {fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy, 
176    participants, nPartA, nPartC, b, bA, bC,  recoflag);}
177
178
179   // FMD
180   void SetFMDData(AliESDFMD * obj);
181   AliESDFMD *GetFMDData(){ return fESDFMD; }
182
183
184   // TZERO CKB: put this in the header?
185   const AliESDTZERO*    GetESDTZERO() const {return fESDTZERO;}
186   // delegetated methods for fESDTZERO
187
188   Double_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
189   void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
190   Double_t GetT0() const {return fESDTZERO->GetT0();}
191   void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
192   Float_t GetT0clock() const {return fESDTZERO->GetT0clock();}
193   void SetT0clock(Float_t timeStart) {fESDTZERO->SetT0clock(timeStart);}
194   const Double_t * GetT0time() const {return fESDTZERO->GetT0time();}
195   void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
196   const Double_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
197   void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}
198
199   // VZERO 
200   AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
201   void SetVZEROData(AliESDVZERO * obj);
202
203  // ACORDE
204   AliESDACORDE *GetACORDEData() const { return fESDACORDE;}
205   void SetACORDEData(AliESDACORDE * obj);
206
207   void SetESDfriend(const AliESDfriend *f) const;
208   void GetESDfriend(AliESDfriend *f) const;
209
210
211
212   void SetPrimaryVertexTPC(const AliESDVertex *vertex); 
213   const AliESDVertex *GetPrimaryVertexTPC() const {return fTPCVertex;}
214
215   void SetPrimaryVertexSPD(const AliESDVertex *vertex); 
216   const AliESDVertex *GetPrimaryVertexSPD() const {return fSPDVertex;}
217   const AliESDVertex *GetVertex() const {
218     //For the backward compatibily only
219      return GetPrimaryVertexSPD();
220   }
221
222   void SetPrimaryVertexTracks(const AliESDVertex *vertex);
223   const AliESDVertex *GetPrimaryVertexTracks() const {return fPrimaryVertex;}
224   AliESDVertex *PrimaryVertexTracksUnconstrained() const;
225
226   const AliESDVertex *GetPrimaryVertex() const;
227
228   void SetMultiplicity(const AliMultiplicity *mul);
229
230   const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
231
232
233   Bool_t Clean(Float_t *cleanPars);
234   Bool_t RemoveKink(Int_t i)   const;
235   Bool_t RemoveV0(Int_t i)     const;
236   Bool_t RemoveTrack(Int_t i)  const;
237
238   const AliESDVertex *GetPileupVertexSPD(Int_t i) const {
239     return (const AliESDVertex *)fSPDPileupVertices->UncheckedAt(i);
240   }
241   Char_t  AddPileupVertexSPD(const AliESDVertex *vtx);
242
243   const AliESDVertex *GetPileupVertexTracks(Int_t i) const {
244     return (const AliESDVertex *)fTrkPileupVertices->UncheckedAt(i);
245   }
246   Char_t  AddPileupVertexTracks(const AliESDVertex *vtx);
247
248   AliESDtrack *GetTrack(Int_t i) const {
249     return (AliESDtrack *)fTracks->UncheckedAt(i);
250   }
251   Int_t  AddTrack(const AliESDtrack *t);
252
253   
254   AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
255     //    return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
256     return 0;
257   }
258   void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
259     printf("ESD:: AddHLTConfMapTrack do nothing \n");
260     //    TClonesArray &fhlt = *fHLTConfMapTracks;
261     //  new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
262   }
263   
264
265   AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
266     //    return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
267     return 0;
268   }
269   void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
270     printf("ESD:: AddHLTHoughTrack do nothing \n");
271     //    TClonesArray &fhlt = *fHLTHoughTracks;
272     //     new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
273   }
274   
275   AliESDMuonTrack *GetMuonTrack(Int_t i) const {
276     return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
277   }
278
279   void AddMuonTrack(const AliESDMuonTrack *t);
280
281   AliESDPmdTrack *GetPmdTrack(Int_t i) const {
282     return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
283   }
284
285   void AddPmdTrack(const AliESDPmdTrack *t);
286
287
288   AliESDTrdTrack *GetTrdTrack(Int_t i) const {
289     return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
290   }
291
292   
293   void AddTrdTrack(const AliESDTrdTrack *t);
294
295   AliESDv0 *GetV0(Int_t i) const {
296     return (AliESDv0*)fV0s->UncheckedAt(i);
297   }
298   Int_t AddV0(const AliESDv0 *v);
299
300   AliESDcascade *GetCascade(Int_t i) const {
301     return (AliESDcascade *)fCascades->UncheckedAt(i);
302   }
303
304   void AddCascade(const AliESDcascade *c);
305
306   AliESDkink *GetKink(Int_t i) const {
307     return (AliESDkink *)fKinks->UncheckedAt(i);
308   }
309   Int_t AddKink(const AliESDkink *c);
310
311   AliESDCaloCluster *GetCaloCluster(Int_t i) const {
312     return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
313   }
314
315   Int_t AddCaloCluster(const AliESDCaloCluster *c);
316
317   AliESDCaloCells *GetEMCALCells() const {return fEMCALCells; }  
318   AliESDCaloCells *GetPHOSCells() const {return fPHOSCells; }  
319
320   AliRawDataErrorLog *GetErrorLog(Int_t i) const {
321     return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
322   }
323   void  AddRawDataErrorLog(const AliRawDataErrorLog *log) const;
324
325   Int_t GetNumberOfErrorLogs()   const {return fErrorLogs->GetEntriesFast();}
326
327     
328   void AddPHOSTriggerPosition(TArrayF array)   { fPHOSTrigger->AddTriggerPosition(array); }
329   void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
330   void AddEMCALTriggerPosition(TArrayF array)  { fEMCALTrigger->AddTriggerPosition(array); }
331   void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }
332
333   Int_t GetNumberOfPileupVerticesSPD() const {
334     return (fSPDPileupVertices?fSPDPileupVertices->GetEntriesFast():0);
335   }
336   Int_t GetNumberOfPileupVerticesTracks() const {
337     return (fTrkPileupVertices?fTrkPileupVertices->GetEntriesFast():0);
338   }
339   Int_t GetNumberOfTracks()     const {return fTracks->GetEntriesFast();}
340   Int_t GetNumberOfHLTConfMapTracks()     const {return 0;} 
341   // fHLTConfMapTracks->GetEntriesFast();}
342   Int_t GetNumberOfHLTHoughTracks()     const {return  0;  }
343   //  fHLTHoughTracks->GetEntriesFast();  }
344
345   Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
346   Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
347   Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
348   Int_t GetNumberOfV0s()      const {return fV0s->GetEntriesFast();}
349   Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
350   Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
351   
352   Int_t GetEMCALClusters(TRefArray *clusters) const;
353   Int_t GetPHOSClusters(TRefArray *clusters) const;
354   Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}
355
356   void SetUseOwnList(Bool_t b){fUseOwnList = b;}
357   Bool_t GetUseOwnList(){return fUseOwnList;}
358   
359   // Remove this stuff CKB?
360   //---------------------------------------------------
361   Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
362   void  SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
363   Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
364   void  SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
365  
366   Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
367   void  SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
368   void  SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; } 
369   Int_t GetFirstPHOSCluster() const  { return fFirstPHOSCluster ; }
370   //-------------------------------------------------------
371
372   TArrayF *GetEMCALTriggerPosition() const {return  fEMCALTrigger->GetTriggerPosition();}
373   TArrayF *GetEMCALTriggerAmplitudes() const {return  fEMCALTrigger->GetTriggerAmplitudes();}
374   TArrayF *GetPHOSTriggerPosition() const {return  fPHOSTrigger->GetTriggerPosition();}
375   TArrayF *GetPHOSTriggerAmplitudes() const {return  fPHOSTrigger->GetTriggerAmplitudes();}
376
377   void ResetV0s() { fV0s->Clear(); }
378   void ResetCascades() { fCascades->Clear(); }
379   void Reset();
380
381   void  Print(Option_t *option="") const;
382
383   void AddObject(TObject* obj);
384   void ReadFromTree(TTree *tree, Option_t* opt = "");
385   TObject* FindListObject(const char *name);
386   AliESD *GetAliESDOld(){return fESDOld;}
387   void WriteToTree(TTree* tree) const;
388   void GetStdContent();
389   void ResetStdContent();
390   void CreateStdContent();
391   void CreateStdContent(Bool_t bUseThisList);
392   void SetStdNames();
393   void CopyFromOldESD();
394   TList* GetList() const {return fESDObjects;}
395
396 protected:
397   AliESDEvent(const AliESDEvent&);
398   static Bool_t ResetWithPlacementNew(TObject *pObject);
399
400   TList *fESDObjects;             // List of esd Objects
401
402   AliESDRun       *fESDRun;           //! Run information tmp put in the Userdata
403   AliESDHeader    *fHeader;           //! ESD Event Header
404   AliESDZDC       *fESDZDC;           //! ZDC information
405   AliESDFMD       *fESDFMD;           //! FMD object containing rough multiplicity
406   AliESDVZERO     *fESDVZERO;         //! VZERO object containing rough multiplicity
407   AliESDTZERO     *fESDTZERO;         //! TZEROObject
408   AliESDVertex    *fTPCVertex;        //! Primary vertex estimated by the TPC
409   AliESDVertex    *fSPDVertex;        //! Primary vertex estimated by the SPD
410   AliESDVertex    *fPrimaryVertex;    //! Primary vertex estimated using ESD tracks
411   AliMultiplicity *fSPDMult;          //! SPD tracklet multiplicity
412   AliESDCaloTrigger* fPHOSTrigger;     //! PHOS Trigger information
413   AliESDCaloTrigger* fEMCALTrigger;    //! PHOS Trigger information
414   AliESDACORDE    *fESDACORDE;        //! ACORDE ESD object caontaining bit pattern
415
416   TClonesArray *fSPDPileupVertices;//! Pileup primary vertices reconstructed by SPD 
417   TClonesArray *fTrkPileupVertices;//! Pileup primary vertices reconstructed using the tracks 
418   TClonesArray *fTracks;           //! ESD tracks 
419   TClonesArray *fMuonTracks;       //! MUON ESD tracks
420   TClonesArray *fPmdTracks;        //! PMD ESD tracks
421   TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
422   TClonesArray *fV0s;              //! V0 vertices
423   TClonesArray *fCascades;         //! Cascade vertices
424   TClonesArray *fKinks;            //! Kinks
425   TClonesArray *fCaloClusters;     //! Calorimeter clusters for PHOS/EMCAL
426   AliESDCaloCells *fEMCALCells;     //! EMCAL cell info
427   AliESDCaloCells *fPHOSCells;     //! PHOS cell info
428   TClonesArray *fErrorLogs;        //! Raw-data reading error messages
429  
430
431
432   AliESD       *fESDOld;           //! Old esd Structure
433   AliESDfriend *fESDFriendOld;     //! Old friend esd Structure
434   Bool_t    fConnected;            //! flag if leaves are alreday connected
435   Bool_t    fUseOwnList;           //! Do not use the list from the esdTree but use the one created by this class 
436
437   static const char* fgkESDListName[kESDListN]; //!
438
439   // Remove this stuff CKB
440   Int_t        fEMCALClusters;   // Number of EMCAL clusters (subset of caloclusters)
441   Int_t        fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list 
442
443   Int_t        fPHOSClusters;     // Number of PHOS clusters (subset of caloclusters)
444   Int_t        fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list 
445
446   ClassDef(AliESDEvent,10)  //ESDEvent class 
447 };
448 #endif 
449