[u/mrichter/AliRoot.git] / STEER / AliESDEvent.h

// -*- mode: C++ -*- 
#ifndef ALIESDEVENT_H
#define ALIESDEVENT_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */


/* $Id$ */

//-------------------------------------------------------------------------
//                          Class AliESDEvent
//   This is the class to deal with during the physics analysis of data.
//   It also ensures the backward compatibility with the old ESD format.
//      
// Origin: Christian Klein-Boesing, CERN, Christian.Klein-Boesing@cern.ch 
//-------------------------------------------------------------------------

#include <TClonesArray.h>
#include <TObject.h>
#include <TTree.h>
#include <TArrayF.h>

class TList;

#include "AliVEvent.h"
// some includes for delegated methods
#include "AliESDCaloTrigger.h"
#include "AliESDRun.h"
#include "AliESDHeader.h"
#include "AliESDTZERO.h"
#include "AliESDZDC.h"
#include "AliESDACORDE.h"

// AliESDtrack has to be included so that the compiler 
// knows its inheritance tree (= that it is a AliVParticle).
#include "AliESDtrack.h"
// same for AliESDVertex (which is a AliVVertex)
#include "AliESDVertex.h"

class AliESDfriend;
class AliESDVZERO;
class AliESDHLTtrack;
class AliESDVertex;
class AliESDPmdTrack;
class AliESDFMD;
class AliESDkink;
class AliESDCaloCluster;
class AliESDCaloCells;
class AliESDv0;
class AliMultiplicity;
class AliRawDataErrorLog;
class AliESDRun;
class AliESDTrdTrack;
class AliESDMuonTrack;
class AliESD;
class AliESDcascade;
class TRefArray;
class AliESDACORDE;

class AliESDEvent : public AliVEvent {
public:


  enum ESDListIndex   {kESDRun,
		       kHeader,
		       kESDZDC,
		       kESDFMD,
		       kESDVZERO,
		       kESDTZERO,
		       kTPCVertex,
		       kSPDVertex,
		       kPrimaryVertex,
		       kSPDMult,
		       kPHOSTrigger,
		       kEMCALTrigger,
		       kSPDPileupVertices,
		       kTrkPileupVertices,
		       kTracks,
		       kMuonTracks,
		       kPmdTracks,
		       kTrdTracks,
		       kV0s,
		       kCascades,
		       kKinks,
		       kCaloClusters,
		       kEMCALCells,
		       kPHOSCells,
		       kErrorLogs,
                       kESDACORDE,
		       kESDListN
  };

  AliESDEvent();
  virtual ~AliESDEvent();
  AliESDEvent &operator=(const AliESDEvent& source); // or make private and use only copy? 
  virtual void Copy(TObject& obj) const;

  // RUN
  // move this to the UserData!!!
  const AliESDRun*    GetESDRun() const {return fESDRun;}

  // Delegated methods for fESDRun
  void     SetRunNumber(Int_t n) {fESDRun->SetRunNumber(n);}
  Int_t    GetRunNumber() const {return fESDRun->GetRunNumber();}
  void     SetPeriodNumber(UInt_t n){fESDRun->SetPeriodNumber(n);}
  UInt_t   GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
  void     SetMagneticField(Double_t mf){fESDRun->SetMagneticField(mf);}
  Double_t GetMagneticField() const {return fESDRun->GetMagneticField();}
  void     SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
  Double_t  GetDiamondX() const {return fESDRun->GetDiamondX();}
  Double_t  GetDiamondY() const {return fESDRun->GetDiamondY();}
  Double_t  GetSigma2DiamondX() const {return  fESDRun->GetSigma2DiamondX();}
  Double_t  GetSigma2DiamondY() const {return  fESDRun->GetSigma2DiamondY();}
  void      GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}   
  void     SetTriggerClass(const char*name, Int_t index) {fESDRun->SetTriggerClass(name,index);}
  void     SetPHOSMatrix(TGeoHMatrix*matrix, Int_t i) {fESDRun->SetPHOSMatrix(matrix,i);}
  const TGeoHMatrix* GetPHOSMatrix(Int_t i) const {return fESDRun->GetPHOSMatrix(i);}
  void     SetEMCALMatrix(TGeoHMatrix*matrix, Int_t i) {fESDRun->SetEMCALMatrix(matrix,i);}
  const TGeoHMatrix* GetEMCALMatrix(Int_t i) const {return fESDRun->GetEMCALMatrix(i);}
  //
  void        SetCurrentL3(Float_t cur)           const  {fESDRun->SetCurrentL3(cur);}
  void        SetCurrentDip(Float_t cur)          const  {fESDRun->SetCurrentDip(cur);}
  void        SetBeamEnergy(Float_t be)           const  {fESDRun->SetBeamEnergy(be);}
  void        SetBeamType(const char* bt)         const  {fESDRun->SetBeamType(bt);}
  void        SetUniformBMap(Bool_t val=kTRUE)    const  {fESDRun->SetBit(AliESDRun::kUniformBMap,val);}
  void        SetBInfoStored(Bool_t val=kTRUE)    const  {fESDRun->SetBit(AliESDRun::kBInfoStored,val);}
  //
  Float_t     GetCurrentL3()                      const  {return fESDRun->GetCurrentL3();}
  Float_t     GetCurrentDip()                     const  {return fESDRun->GetCurrentDip();}
  Float_t     GetBeamEnergy()                     const  {return fESDRun->GetBeamEnergy();}
  const char* GetBeamType()                       const  {return fESDRun->GetBeamType();}
  Bool_t      IsUniformBMap()                     const  {return fESDRun->TestBit(AliESDRun::kUniformBMap);}
  //
  Bool_t      InitMagneticField()                 const  {return fESDRun->InitMagneticField();} 
  // HEADER
  AliESDHeader* GetHeader() const {return fHeader;}

  // Delegated methods for fHeader
  void      SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
  void      SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
  void      SetTimeStamp(UInt_t timeStamp){fHeader->SetTimeStamp(timeStamp);}
  void      SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
  void      SetEventSpecie(UInt_t eventSpecie){fHeader->SetEventSpecie(eventSpecie);}
  void      SetEventNumberInFile(Int_t n) {fHeader->SetEventNumberInFile(n);}
  //  void     SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
  void      SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
  void      SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
  
  ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
  TString   GetFiredTriggerClasses() const {return fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask());}
  Bool_t    IsTriggerClassFired(const char *name) const {return fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name);}
  Bool_t    IsEventSelected(const char *trigExpr) const;
  TObject*  GetHLTTriggerDecision() const;
  TString   GetHLTTriggerDescription() const;
  Bool_t    IsHLTTriggerFired(const char* name=NULL) const;
  UInt_t    GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
  UInt_t    GetTimeStamp()  const { return fHeader->GetTimeStamp();}
  UInt_t    GetEventType()  const { return fHeader->GetEventType();}
  UInt_t    GetEventSpecie()  const { return fHeader->GetEventSpecie();}
  Int_t     GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
  UShort_t  GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
  UChar_t   GetTriggerCluster() const {return fHeader->GetTriggerCluster();}

  // ZDC CKB: put this in the header?
  AliESDZDC*    GetESDZDC() const {return fESDZDC;}

  // Delegated methods for fESDZDC
  Double_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
  Double_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
  Double_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
  Double_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
  Double_t GetZDCEMEnergy(Int_t i=0) const {return fESDZDC->GetZDCEMEnergy(i);}
  Int_t    GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
  void     SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t em1Energy, Float_t em2Energy,
                  Float_t n2Energy, Float_t p2Energy, Int_t participants, Int_t nPartA,
	 	  Int_t nPartC, Double_t b, Double_t bA, Double_t bC, UInt_t recoflag)
           {fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy, 
            participants, nPartA, nPartC, b, bA, bC,  recoflag);}
  void     SetZDCScaler(UInt_t *counts) {fESDZDC->SetZDCScaler(counts);}


  // FMD
  void SetFMDData(AliESDFMD * obj);
  AliESDFMD *GetFMDData() const { return fESDFMD; }


  // TZERO CKB: put this in the header?
  const AliESDTZERO*    GetESDTZERO() const {return fESDTZERO;}
  // delegetated methods for fESDTZERO

  Double_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
  void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
  Double_t GetT0() const {return fESDTZERO->GetT0();}
  void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
  Float_t GetT0clock() const {return fESDTZERO->GetT0clock();}
  void SetT0clock(Float_t timeStart) {fESDTZERO->SetT0clock(timeStart);}
  const Double_t * GetT0time() const {return fESDTZERO->GetT0time();}
  void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
  const Double_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
  void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}

  // VZERO 
  AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
  void SetVZEROData(AliESDVZERO * obj);

 // ACORDE
  AliESDACORDE *GetACORDEData() const { return fESDACORDE;}
  void SetACORDEData(AliESDACORDE * obj);

  void SetESDfriend(const AliESDfriend *f) const;
  void GetESDfriend(AliESDfriend *f) const;


  void SetPrimaryVertexTPC(const AliESDVertex *vertex); 
  const AliESDVertex *GetPrimaryVertexTPC() const {return fTPCVertex;}

  void SetPrimaryVertexSPD(const AliESDVertex *vertex); 
  const AliESDVertex *GetPrimaryVertexSPD() const {return fSPDVertex;}
  const AliESDVertex *GetVertex() const {
    //For the backward compatibily only
     return GetPrimaryVertexSPD();
  }

  void SetPrimaryVertexTracks(const AliESDVertex *vertex);
  const AliESDVertex *GetPrimaryVertexTracks() const {return fPrimaryVertex;}
  AliESDVertex *PrimaryVertexTracksUnconstrained() const;

  const AliESDVertex *GetPrimaryVertex() const;

  void SetMultiplicity(const AliMultiplicity *mul);

  const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}


  Bool_t Clean(Float_t *cleanPars);
  Bool_t RemoveKink(Int_t i)   const;
  Bool_t RemoveV0(Int_t i)     const;
  Bool_t RemoveTrack(Int_t i)  const;

  const AliESDVertex *GetPileupVertexSPD(Int_t i) const {
    return (const AliESDVertex *)fSPDPileupVertices->UncheckedAt(i);
  }
  Char_t  AddPileupVertexSPD(const AliESDVertex *vtx);
  Bool_t  IsPileupFromSPD(Int_t ncont=2, Double_t nSigmaDeltaZ=3., Double_t nSigmaXY=2., Int_t option=0) const;

  const AliESDVertex *GetPileupVertexTracks(Int_t i) const {
    return (const AliESDVertex *)fTrkPileupVertices->UncheckedAt(i);
  }
  Char_t  AddPileupVertexTracks(const AliESDVertex *vtx);

  AliESDtrack *GetTrack(Int_t i) const {
    return (AliESDtrack *)fTracks->UncheckedAt(i);
  }
  Int_t  AddTrack(const AliESDtrack *t);

  
  AliESDHLTtrack *GetHLTConfMapTrack(Int_t /*i*/) const {
    //    return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
    return 0;
  }
  void AddHLTConfMapTrack(const AliESDHLTtrack */*t*/) {
    printf("ESD:: AddHLTConfMapTrack do nothing \n");
    //    TClonesArray &fhlt = *fHLTConfMapTracks;
    //  new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
  }
  

  AliESDHLTtrack *GetHLTHoughTrack(Int_t /*i*/) const {
    //    return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
    return 0;
  }
  void AddHLTHoughTrack(const AliESDHLTtrack */*t*/) {
    printf("ESD:: AddHLTHoughTrack do nothing \n");
    //    TClonesArray &fhlt = *fHLTHoughTracks;
    //     new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
  }
  
  AliESDMuonTrack *GetMuonTrack(Int_t i) const {
    return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
  }

  void AddMuonTrack(const AliESDMuonTrack *t);

  AliESDPmdTrack *GetPmdTrack(Int_t i) const {
    return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
  }

  void AddPmdTrack(const AliESDPmdTrack *t);


  AliESDTrdTrack *GetTrdTrack(Int_t i) const {
    return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
  }

  
  void AddTrdTrack(const AliESDTrdTrack *t);

  AliESDv0 *GetV0(Int_t i) const {
    return (AliESDv0*)fV0s->UncheckedAt(i);
  }
  Int_t AddV0(const AliESDv0 *v);

  AliESDcascade *GetCascade(Int_t i) const {
    return (AliESDcascade *)fCascades->UncheckedAt(i);
  }

  void AddCascade(const AliESDcascade *c);

  AliESDkink *GetKink(Int_t i) const {
    return (AliESDkink *)fKinks->UncheckedAt(i);
  }
  Int_t AddKink(const AliESDkink *c);

  AliESDCaloCluster *GetCaloCluster(Int_t i) const {
    return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
  }

  Int_t AddCaloCluster(const AliESDCaloCluster *c);

  AliESDCaloCells *GetEMCALCells() const {return fEMCALCells; }  
  AliESDCaloCells *GetPHOSCells() const {return fPHOSCells; }  

  AliRawDataErrorLog *GetErrorLog(Int_t i) const {
    return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
  }
  void  AddRawDataErrorLog(const AliRawDataErrorLog *log) const;

  Int_t GetNumberOfErrorLogs()   const {return fErrorLogs->GetEntriesFast();}

    
  void AddPHOSTriggerPosition(TArrayF array)   { fPHOSTrigger->AddTriggerPosition(array); }
  void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
  void AddEMCALTriggerPosition(TArrayF array)  { fEMCALTrigger->AddTriggerPosition(array); }
  void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }

  Int_t GetNumberOfPileupVerticesSPD() const {
    return (fSPDPileupVertices?fSPDPileupVertices->GetEntriesFast():0);
  }
  Int_t GetNumberOfPileupVerticesTracks() const {
    return (fTrkPileupVertices?fTrkPileupVertices->GetEntriesFast():0);
  }
  Int_t GetNumberOfTracks()     const {return fTracks->GetEntriesFast();}
  Int_t GetNumberOfHLTConfMapTracks()     const {return 0;} 
  // fHLTConfMapTracks->GetEntriesFast();}
  Int_t GetNumberOfHLTHoughTracks()     const {return  0;  }
  //  fHLTHoughTracks->GetEntriesFast();  }

  Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
  Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
  Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
  Int_t GetNumberOfV0s()      const {return fV0s->GetEntriesFast();}
  Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
  Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
  
  Int_t GetEMCALClusters(TRefArray *clusters) const;
  Int_t GetPHOSClusters(TRefArray *clusters) const;
  Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}

  void SetUseOwnList(Bool_t b){fUseOwnList = b;}
  Bool_t GetUseOwnList() const {return fUseOwnList;}
  
  // Remove this stuff CKB?
  //---------------------------------------------------
  Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
  void  SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
  Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
  void  SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
 
  Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
  void  SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
  void  SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; } 
  Int_t GetFirstPHOSCluster() const  { return fFirstPHOSCluster ; }
  //-------------------------------------------------------

  TArrayF *GetEMCALTriggerPosition() const {return  fEMCALTrigger->GetTriggerPosition();}
  TArrayF *GetEMCALTriggerAmplitudes() const {return  fEMCALTrigger->GetTriggerAmplitudes();}
  TArrayF *GetPHOSTriggerPosition() const {return  fPHOSTrigger->GetTriggerPosition();}
  TArrayF *GetPHOSTriggerAmplitudes() const {return  fPHOSTrigger->GetTriggerAmplitudes();}

  void ResetV0s() { fV0s->Clear(); }
  void ResetCascades() { fCascades->Clear(); }
  void Reset();

  void  Print(Option_t *option="") const;

  void AddObject(TObject* obj);
  void ReadFromTree(TTree *tree, Option_t* opt = "");
  TObject* FindListObject(const char *name);
  AliESD *GetAliESDOld(){return fESDOld;}
  void WriteToTree(TTree* tree) const;
  void GetStdContent();
  void ResetStdContent();
  void CreateStdContent();
  void CreateStdContent(Bool_t bUseThisList);
  void SetStdNames();
  void CopyFromOldESD();
  TList* GetList() const {return fESDObjects;}

protected:
  AliESDEvent(const AliESDEvent&);
  static Bool_t ResetWithPlacementNew(TObject *pObject);

  TList *fESDObjects;             // List of esd Objects

  AliESDRun       *fESDRun;           //! Run information tmp put in the Userdata
  AliESDHeader    *fHeader;           //! ESD Event Header
  AliESDZDC       *fESDZDC;           //! ZDC information
  AliESDFMD       *fESDFMD;           //! FMD object containing rough multiplicity
  AliESDVZERO     *fESDVZERO;         //! VZERO object containing rough multiplicity
  AliESDTZERO     *fESDTZERO;         //! TZEROObject
  AliESDVertex    *fTPCVertex;        //! Primary vertex estimated by the TPC
  AliESDVertex    *fSPDVertex;        //! Primary vertex estimated by the SPD
  AliESDVertex    *fPrimaryVertex;    //! Primary vertex estimated using ESD tracks
  AliMultiplicity *fSPDMult;          //! SPD tracklet multiplicity
  AliESDCaloTrigger* fPHOSTrigger;     //! PHOS Trigger information
  AliESDCaloTrigger* fEMCALTrigger;    //! PHOS Trigger information
  AliESDACORDE    *fESDACORDE;        //! ACORDE ESD object caontaining bit pattern

  TClonesArray *fSPDPileupVertices;//! Pileup primary vertices reconstructed by SPD 
  TClonesArray *fTrkPileupVertices;//! Pileup primary vertices reconstructed using the tracks 
  TClonesArray *fTracks;           //! ESD tracks 
  TClonesArray *fMuonTracks;       //! MUON ESD tracks
  TClonesArray *fPmdTracks;        //! PMD ESD tracks
  TClonesArray *fTrdTracks;        //! TRD ESD tracks (triggered)
  TClonesArray *fV0s;              //! V0 vertices
  TClonesArray *fCascades;         //! Cascade vertices
  TClonesArray *fKinks;            //! Kinks
  TClonesArray *fCaloClusters;     //! Calorimeter clusters for PHOS/EMCAL
  AliESDCaloCells *fEMCALCells;     //! EMCAL cell info
  AliESDCaloCells *fPHOSCells;     //! PHOS cell info
  TClonesArray *fErrorLogs;        //! Raw-data reading error messages
 

  AliESD       *fESDOld;           //! Old esd Structure
  AliESDfriend *fESDFriendOld;     //! Old friend esd Structure
  Bool_t    fConnected;            //! flag if leaves are alreday connected
  Bool_t    fUseOwnList;           //! Do not use the list from the esdTree but use the one created by this class 

  static const char* fgkESDListName[kESDListN]; //!

  // Remove this stuff CKB
  Int_t        fEMCALClusters;   // Number of EMCAL clusters (subset of caloclusters)
  Int_t        fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list 

  Int_t        fPHOSClusters;     // Number of PHOS clusters (subset of caloclusters)
  Int_t        fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list 

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