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