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   virtual AliESDfriend* FindFriend() const;
 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   //getters for calibration
 296   Int_t GetPrimaryVertex (AliESDVertex &v) const {
 297       if(!GetPrimaryVertex()) return -1;
 298       v=*GetPrimaryVertex();
 299       return 0;
 300   }
 301
 302   Int_t GetPrimaryVertexTPC (AliESDVertex &v) const {
 303       if(!GetPrimaryVertexTPC()) return -1;
 304       v=*GetPrimaryVertexTPC();
 305       return 0;
 306   }
 307
 308   Int_t GetPrimaryVertexSPD (AliESDVertex &v) const {
 309       if(!GetPrimaryVertexSPD()) return -1;
 310       v=*GetPrimaryVertexSPD();
 311       return 0;
 312   }
 313
 314   Int_t GetPrimaryVertexTracks (AliESDVertex &v) const {
 315       if(!GetPrimaryVertexTracks()) return -1;
 316       v=*GetPrimaryVertexTracks();
 317       return 0;
 318   }
 319
 320
 321   void SetTOFHeader(const AliTOFHeader * tofEventTime);
 322   AliTOFHeader *GetTOFHeader() const {return fTOFHeader;}
 323   Float_t GetEventTimeSpread() const {if (fTOFHeader) return fTOFHeader->GetT0spread(); else return 0.;}
 324   Float_t GetTOFTimeResolution() const {if (fTOFHeader) return fTOFHeader->GetTOFResolution(); else return 0.;}
 325
 326   TClonesArray *GetESDTOFClusters() const {return fESDTOFClusters;}
 327   TClonesArray *GetESDTOFHits() const {return fESDTOFHits;}
 328   TClonesArray *GetESDTOFMatches() const {return fESDTOFMatchess;}
 329
 330   void SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster,Int_t *mapping=NULL);
 331   void SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster[],Int_t *mapping=NULL);
 332   Int_t GetNTOFclusters() const {return fESDTOFClusters ? fESDTOFClusters->GetEntriesFast() : 0;}
 333
 334   void SetMultiplicity(const AliMultiplicity *mul);
 335
 336   const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
 337   void   EstimateMultiplicity(Int_t &tracklets,Int_t &trITSTPC,Int_t &trITSSApure,
 338                               Double_t eta=1.,Bool_t useDCAFlag=kTRUE,Bool_t useV0Flag=kTRUE) const;
 339
 340   Bool_t Clean(Float_t *cleanPars);
 341   Bool_t RemoveKink(Int_t i)   const;
 342   Bool_t RemoveV0(Int_t i)     const;
 343   Bool_t RemoveTrack(Int_t i)  const;
 344
 345   const AliESDVertex *GetPileupVertexSPD(Int_t i) const {
 346     return (const AliESDVertex *)(fSPDPileupVertices?fSPDPileupVertices->At(i):0x0);
 347   }
 348   Char_t  AddPileupVertexSPD(const AliESDVertex *vtx);
 349   const AliESDVertex *GetPileupVertexTracks(Int_t i) const {
 350     return (const AliESDVertex *)(fTrkPileupVertices?fTrkPileupVertices->At(i):0x0);
 351   }
 352   Char_t  AddPileupVertexTracks(const AliESDVertex *vtx);
 353   TClonesArray* GetPileupVerticesTracks() const {return (TClonesArray*)fTrkPileupVertices;}
 354   TClonesArray* GetPileupVerticesSPD()    const {return (TClonesArray*)fSPDPileupVertices;}
 355
 356   virtual Bool_t  IsPileupFromSPD(Int_t minContributors=3,
 357                                   Double_t minZdist=0.8,
 358                                   Double_t nSigmaZdist=3.,
 359                                   Double_t nSigmaDiamXY=2.,
 360                                   Double_t nSigmaDiamZ=5.) const;
 361
 362   virtual Bool_t IsPileupFromSPDInMultBins() const;
 363
 364   void ConnectTracks();
 365   Bool_t        AreTracksConnected() const {return fTracksConnected;}
 366
 367   AliESDtrack *GetTrack(Int_t i) const {return (fTracks)?(AliESDtrack*)fTracks->At(i) : 0;}
 368   Int_t  AddTrack(const AliESDtrack *t);
 369
 370   /// add new track at the end of tracks array and return instance
 371   AliESDtrack* NewTrack();
 372
 373   AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
 374     //    return (AliESDHLTtrack *)fHLTConfMapTracks->At(i);
 375     return 0;
 376   }
 377   void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
 378     printf("ESD:: AddHLTConfMapTrack do nothing \n");
 379     //    TClonesArray &fhlt = *fHLTConfMapTracks;
 380     //  new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
 381   }
 382
 383
 384   AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
 385     //    return (AliESDHLTtrack *)fHLTHoughTracks->At(i);
 386     return 0;
 387   }
 388   void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
 389     printf("ESD:: AddHLTHoughTrack do nothing \n");
 390     //    TClonesArray &fhlt = *fHLTHoughTracks;
 391     //     new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
 392   }
 393
 394   Bool_t MoveMuonObjects();
 395
 396   AliESDMuonTrack* GetMuonTrack(Int_t i);
 397   AliESDMuonTrack* NewMuonTrack();
 398
 399   AliESDMuonCluster* GetMuonCluster(Int_t i);
 400   AliESDMuonCluster* FindMuonCluster(UInt_t clusterId);
 401   AliESDMuonCluster* NewMuonCluster();
 402
 403   AliESDMuonPad* GetMuonPad(Int_t i);
 404   AliESDMuonPad* FindMuonPad(UInt_t padId);
 405   AliESDMuonPad* NewMuonPad();
 406
 407   AliESDMuonGlobalTrack* GetMuonGlobalTrack(Int_t i);      // AU
 408   AliESDMuonGlobalTrack* NewMuonGlobalTrack();             // AU
 409
 410   AliESDPmdTrack *GetPmdTrack(Int_t i) const {
 411     return (AliESDPmdTrack *)(fPmdTracks?fPmdTracks->At(i):0x0);
 412   }
 413
 414   void AddPmdTrack(const AliESDPmdTrack *t);
 415
 416
 417   AliESDTrdTrack *GetTrdTrack(Int_t i) const {
 418     return (AliESDTrdTrack *)(fTrdTracks?fTrdTracks->At(i):0x0);
 419   }
 420
 421
 422   void SetTrdTrigger(const AliESDTrdTrigger *t);
 423
 424   AliESDTrdTrigger* GetTrdTrigger() const {
 425     return (AliESDTrdTrigger*)(fTrdTrigger);
 426   }
 427
 428   void AddTrdTrack(const AliESDTrdTrack *t);
 429
 430   AliESDTrdTracklet* GetTrdTracklet(Int_t idx) const {
 431     return (AliESDTrdTracklet*)(fTrdTracklets?fTrdTracklets->At(idx):0x0);
 432   }
 433
 434   void AddTrdTracklet(const AliESDTrdTracklet *trkl);
 435   void AddTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label = -1);
 436
 437   AliESDv0 *GetV0(Int_t i) const {
 438     return (AliESDv0*)(fV0s?fV0s->At(i):0x0);
 439   }
 440
 441   Int_t GetV0(AliESDv0 &v0dum, Int_t i) const {
 442         if(!GetV0(i)) return -1;
 443         v0dum=*GetV0(i);
 444         return 0;}
 445
 446   Int_t AddV0(const AliESDv0 *v);
 447
 448   AliESDcascade *GetCascade(Int_t i) const {
 449     return (AliESDcascade *)(fCascades?fCascades->At(i):0x0);
 450   }
 451
 452   void AddCascade(const AliESDcascade *c);
 453
 454   AliESDkink *GetKink(Int_t i) const {
 455     return (AliESDkink *)(fKinks?fKinks->At(i):0x0);
 456   }
 457   Int_t AddKink(const AliESDkink *c);
 458
 459   AliESDCaloCluster *GetCaloCluster(Int_t i) const {
 460     return (AliESDCaloCluster *)(fCaloClusters?fCaloClusters->At(i):0x0);
 461   }
 462
 463   Int_t AddCaloCluster(const AliESDCaloCluster *c);
 464
 465   AliESDCaloCells *GetEMCALCells() const {return fEMCALCells; }
 466   AliESDCaloCells *GetPHOSCells() const {return fPHOSCells; }
 467
 468   AliESDCaloTrigger* GetCaloTrigger(TString calo) const
 469   {
 470           if (calo.Contains("EMCAL")) return fEMCALTrigger;
 471           else
 472                   return fPHOSTrigger;
 473   }
 474
 475   AliESDCosmicTrack *GetCosmicTrack(Int_t i) const {
 476     return fCosmicTracks ? (AliESDCosmicTrack*) fCosmicTracks->At(i) : 0;
 477   }
 478   const TClonesArray * GetCosmicTracks() const{ return fCosmicTracks;}
 479
 480   void  AddCosmicTrack(const AliESDCosmicTrack *t);
 481
 482   AliRawDataErrorLog *GetErrorLog(Int_t i) const {
 483     return (AliRawDataErrorLog *)(fErrorLogs?fErrorLogs->At(i):0x0);
 484   }
 485   void  AddRawDataErrorLog(const AliRawDataErrorLog *log) const;
 486
 487   Int_t GetNumberOfErrorLogs()   const {return fErrorLogs?fErrorLogs->GetEntriesFast():0;}
 488
 489   Int_t GetNumberOfPileupVerticesSPD() const {
 490     return (fSPDPileupVertices?fSPDPileupVertices->GetEntriesFast():0);
 491   }
 492   Int_t GetNumberOfPileupVerticesTracks() const {
 493     return (fTrkPileupVertices?fTrkPileupVertices->GetEntriesFast():0);
 494   }
 495   Int_t GetNumberOfTracks()     const {return fTracks?fTracks->GetEntriesFast():0;}
 496   Int_t GetNumberOfESDTracks()  const { return GetNumberOfTracks(); }
 497   Int_t GetNumberOfHLTConfMapTracks()     const {return 0;}
 498   // fHLTConfMapTracks->GetEntriesFast();}
 499   Int_t GetNumberOfHLTHoughTracks()     const {return  0;  }
 500   //  fHLTHoughTracks->GetEntriesFast();  }
 501
 502   Int_t GetNumberOfMuonTracks() const {return fMuonTracks?fMuonTracks->GetEntriesFast():0;}
 503   Int_t GetNumberOfMuonClusters();
 504   Int_t GetNumberOfMuonPads();
 505   Int_t GetNumberOfMuonGlobalTracks() const {return fMuonGlobalTracks?fMuonGlobalTracks->GetEntriesFast():0;}    // AU
 506   Int_t GetNumberOfPmdTracks() const {return fPmdTracks?fPmdTracks->GetEntriesFast():0;}
 507   Int_t GetNumberOfTrdTracks() const {return fTrdTracks?fTrdTracks->GetEntriesFast():0;}
 508   Int_t GetNumberOfTrdTracklets() const {return fTrdTracklets?fTrdTracklets->GetEntriesFast():0;}
 509   Int_t GetNumberOfV0s()      const {return fV0s?fV0s->GetEntriesFast():0;}
 510   Int_t GetNumberOfCascades() const {return fCascades?fCascades->GetEntriesFast():0;}
 511   Int_t GetNumberOfKinks() const {return fKinks?fKinks->GetEntriesFast():0;}
 512
 513   Int_t GetNumberOfCosmicTracks() const {return fCosmicTracks ? fCosmicTracks->GetEntriesFast():0;}
 514   Int_t GetEMCALClusters(TRefArray *clusters) const;
 515   Int_t GetPHOSClusters(TRefArray *clusters) const;
 516   Int_t GetNumberOfCaloClusters() const {return fCaloClusters?fCaloClusters->GetEntriesFast():0;}
 517
 518   void SetUseOwnList(Bool_t b){fUseOwnList = b;}
 519   Bool_t GetUseOwnList() const {return fUseOwnList;}
 520
 521   void ResetV0s() { if(fV0s) fV0s->Clear(); }
 522   void ResetCascades() { if(fCascades) fCascades->Clear(); }
 523   void Reset();
 524
 525   void  Print(Option_t *option="") const;
 526
 527   void AddObject(TObject* obj);
 528   void ReadFromTree(TTree *tree, Option_t* opt = "");
 529   TObject* FindListObject(const char *name) const;
 530   AliESD *GetAliESDOld(){return fESDOld;}
 531   void WriteToTree(TTree* tree) const;
 532   void GetStdContent();
 533   void ResetStdContent();
 534   void CreateStdContent();
 535   void CreateStdContent(Bool_t bUseThisList);
 536   void CompleteStdContent();
 537   void SetStdNames();
 538   void CopyFromOldESD();
 539   TList* GetList() const {return fESDObjects;}
 540
 541     //Following needed only for mixed event
 542   virtual Int_t        EventIndex(Int_t)       const {return 0;}
 543   virtual Int_t        EventIndexForCaloCluster(Int_t) const {return 0;}
 544   virtual Int_t        EventIndexForPHOSCell(Int_t)    const {return 0;}
 545   virtual Int_t        EventIndexForEMCALCell(Int_t)   const {return 0;}
 546
 547   void SetDetectorStatus(ULong_t detMask) {fDetectorStatus|=detMask;}
 548   void ResetDetectorStatus(ULong_t detMask) {fDetectorStatus&=~detMask;}
 549   ULong_t GetDetectorStatus() const {return fDetectorStatus;}
 550   Bool_t IsDetectorOn(ULong_t detMask) const {return (fDetectorStatus&detMask)>0;}
 551
 552   void SetDAQDetectorPattern(UInt_t pattern) {fDAQDetectorPattern = pattern;}
 553   void SetDAQAttributes(UInt_t attributes) {fDAQAttributes = attributes;}
 554   UInt_t GetDAQDetectorPattern() const {return fDAQDetectorPattern;}
 555   UInt_t GetDAQAttributes() const {return fDAQAttributes;}
 556
 557 protected:
 558   AliESDEvent(const AliESDEvent&);
 559   static Bool_t ResetWithPlacementNew(TObject *pObject);
 560
 561   void AddMuonTrack(const AliESDMuonTrack *t);
 562   void AddMuonGlobalTrack(const AliESDMuonGlobalTrack *t);     // AU
 563
 564   TList *fESDObjects;             // List of esd Objects
 565
 566   AliESDRun       *fESDRun;           //! Run information tmp put in the Userdata
 567   AliESDHeader    *fHeader;           //! ESD Event Header
 568   AliESDZDC       *fESDZDC;           //! ZDC information
 569   AliESDFMD       *fESDFMD;           //! FMD object containing rough multiplicity
 570   AliESDVZERO     *fESDVZERO;         //! VZERO object containing rough multiplicity
 571   AliESDTZERO     *fESDTZERO;         //! TZEROObject
 572   AliESDVertex    *fTPCVertex;        //! Primary vertex estimated by the TPC
 573   AliESDVertex    *fSPDVertex;        //! Primary vertex estimated by the SPD
 574   AliESDVertex    *fPrimaryVertex;    //! Primary vertex estimated using ESD tracks
 575   AliMultiplicity *fSPDMult;          //! SPD tracklet multiplicity
 576   AliESDCaloTrigger* fPHOSTrigger;     //! PHOS Trigger information
 577   AliESDCaloTrigger* fEMCALTrigger;    //! PHOS Trigger information
 578   AliESDACORDE    *fESDACORDE;        //! ACORDE ESD object caontaining bit pattern
 579   AliESDAD    *fESDAD;        //! AD ESD object caontaining bit pattern
 580   AliESDTrdTrigger *fTrdTrigger;      //! TRD trigger information
 581
 582   TClonesArray *fSPDPileupVertices;//! Pileup primary vertices reconstructed by SPD
 583   TClonesArray *fTrkPileupVertices;//! Pileup primary vertices reconstructed using the tracks
 584   TClonesArray *fTracks;           //! ESD tracks
 585   TClonesArray *fMuonTracks;       //! MUON ESD tracks
 586   TClonesArray *fMuonClusters;     //! MUON ESD clusters
 587   TClonesArray *fMuonPads;         //! MUON ESD pads
 588   TClonesArray *fMuonGlobalTracks; //! MUON+MFT ESD tracks      // AU
 589   TClonesArray *fPmdTracks;        //! PMD ESD tracks
 590   TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
 591   TClonesArray *fTrdTracklets;     //! TRD tracklets (for trigger)
 592   TClonesArray *fV0s;              //! V0 vertices
 593   TClonesArray *fCascades;         //! Cascade vertices
 594   TClonesArray *fKinks;            //! Kinks
 595   TClonesArray *fCaloClusters;     //! Calorimeter clusters for PHOS/EMCAL
 596   AliESDCaloCells *fEMCALCells;     //! EMCAL cell info
 597   AliESDCaloCells *fPHOSCells;     //! PHOS cell info
 598   TClonesArray *fCosmicTracks;     //! Tracks created by cosmics finder
 599   TClonesArray *fESDTOFClusters;    //! TOF clusters
 600   TClonesArray *fESDTOFHits;        //! TOF hits (used for clusters)
 601   TClonesArray *fESDTOFMatchess;      //! TOF matching info (with the reference to tracks)
 602   TClonesArray *fErrorLogs;        //! Raw-data reading error messages
 603
 604   Bool_t fOldMuonStructure;        //! Flag if reading ESD with old MUON structure
 605
 606   AliESD       *fESDOld;           //! Old esd Structure
 607   AliESDfriend *fESDFriendOld;     //! Old friend esd Structure
 608   Bool_t    fConnected;            //! flag if leaves are alreday connected
 609   Bool_t    fUseOwnList;           //! Do not use the list from the esdTree but use the one created by this class
 610   Bool_t    fTracksConnected;      //! flag if tracks have already pointer to event set
 611
 612   static const char* fgkESDListName[kESDListN]; //!
 613
 614   AliTOFHeader *fTOFHeader;  //! event times (and sigmas) as estimated by TOF
 615                              //  combinatorial algorithm.
 616                              //  It contains also TOF time resolution
 617                              //  and T0spread as written in OCDB
 618   AliCentrality *fCentrality; //! Centrality for AA collision
 619   AliEventplane *fEventplane; //! Event plane for AA collision
 620
 621   ULong64_t fDetectorStatus; // set detector event status bit for good event selection
 622   UInt_t fDAQDetectorPattern; // Detector pattern from DAQ: bit 0 is SPD, bit 4 is TPC, etc. See event.h
 623   UInt_t fDAQAttributes; // Third word of attributes from DAQ: bit 7 corresponds to HLT decision
 624
 625   ClassDef(AliESDEvent,23)  //ESDEvent class
 626 };
 627 #endif
 628