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