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