[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);}
  

  // 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      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);}
  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();}
  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);}


  // FMD
  void SetFMDData(AliESDFMD * obj);
  AliESDFMD *GetFMDData(){ 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);}
  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;}

  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);

  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->GetEntriesFast();
  }
  Int_t GetNumberOfPileupVerticesTracks() const {
     return fTrkPileupVertices->GetEntriesFast();
  }
  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(){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
	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	//-------------------------------------------------------------------------
	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
	23	class TList;
	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
	34	// AliESDtrack has to be included so that the compiler
	35	// knows its inheritance tree (= that it is a AliVParticle).
	36	#include "AliESDtrack.h"
	37	// same for AliESDVertex (which is a AliVVertex)
	38	#include "AliESDVertex.h"
	39
	40	class AliESDfriend;
	41	class AliESDVZERO;
	42	class AliESDHLTtrack;
	43	class AliESDVertex;
	44	class AliESDPmdTrack;
	45	class AliESDFMD;
	46	class AliESDkink;
	47	class AliESDCaloCluster;
	48	class AliESDCaloCells;
	49	class AliESDv0;
	50	class AliMultiplicity;
	51	class AliRawDataErrorLog;
	52	class AliESDRun;
	53	class AliESDTrdTrack;
	54	class AliESDMuonTrack;
	55	class AliESD;
	56	class AliESDcascade;
	57	class TRefArray;
	58	class AliESDACORDE;
	59
	60	class AliESDEvent : public AliVEvent {
	61	public:
	62
	63
	64	enum ESDListIndex {kESDRun,
	65	kHeader,
	66	kESDZDC,
	67	kESDFMD,
	68	kESDVZERO,
	69	kESDTZERO,
	70	kTPCVertex,
	71	kSPDVertex,
	72	kPrimaryVertex,
	73	kSPDMult,
	74	kPHOSTrigger,
	75	kEMCALTrigger,
	76	kSPDPileupVertices,
	77	kTrkPileupVertices,
	78	kTracks,
	79	kMuonTracks,
	80	kPmdTracks,
	81	kTrdTracks,
	82	kV0s,
	83	kCascades,
	84	kKinks,
	85	kCaloClusters,
	86	kEMCALCells,
	87	kPHOSCells,
	88	kErrorLogs,
	89	kESDACORDE,
	90	kESDListN
	91	};
	92
	93	AliESDEvent();
	94	virtual ~AliESDEvent();
	95	AliESDEvent &operator=(const AliESDEvent& source); // or make private and use only copy?
	96	virtual void Copy(TObject& obj) const;
	97
	98	// RUN
	99	// move this to the UserData!!!
	100	const AliESDRun* GetESDRun() const {return fESDRun;}
	101
	102	// Delegated methods for fESDRun
	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);}
	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);}
	115	void SetTriggerClass(const char*name, Int_t index) {fESDRun->SetTriggerClass(name,index);}
	116
	117
	118	// HEADER
	119	AliESDHeader* GetHeader() const {return fHeader;}
	120
	121	// Delegated methods for fHeader
	122	void SetTriggerMask(ULong64_t n) {fHeader->SetTriggerMask(n);}
	123	void SetOrbitNumber(UInt_t n) {fHeader->SetOrbitNumber(n);}
	124	void SetTimeStamp(UInt_t timeStamp){fHeader->SetTimeStamp(timeStamp);}
	125	void SetEventType(UInt_t eventType){fHeader->SetEventType(eventType);}
	126	void SetEventNumberInFile(Int_t n) {fHeader->SetEventNumberInFile(n);}
	127	// void SetRunNumber(Int_t n) {fHeader->SetRunNumber(n);}
	128	void SetBunchCrossNumber(UShort_t n) {fHeader->SetBunchCrossNumber(n);}
	129	void SetTriggerCluster(UChar_t n) {fHeader->SetTriggerCluster(n);}
	130
	131	ULong64_t GetTriggerMask() const {return fHeader->GetTriggerMask();}
	132	TString GetFiredTriggerClasses() const {return fESDRun->GetFiredTriggerClasses(fHeader->GetTriggerMask());}
	133	Bool_t IsTriggerClassFired(const char *name) const {return fESDRun->IsTriggerClassFired(fHeader->GetTriggerMask(),name);}
	134	TObject* GetHLTTriggerDecision() const;
	135	TString GetHLTTriggerDescription() const;
	136	Bool_t IsHLTTriggerFired(const char* name=NULL) const;
	137	UInt_t GetOrbitNumber() const {return fHeader->GetOrbitNumber();}
	138	UInt_t GetTimeStamp() const { return fHeader->GetTimeStamp();}
	139	UInt_t GetEventType() const { return fHeader->GetEventType();}
	140	Int_t GetEventNumberInFile() const {return fHeader->GetEventNumberInFile();}
	141	UShort_t GetBunchCrossNumber() const {return fHeader->GetBunchCrossNumber();}
	142	UChar_t GetTriggerCluster() const {return fHeader->GetTriggerCluster();}
	143
	144	// ZDC CKB: put this in the header?
	145	AliESDZDC* GetESDZDC() const {return fESDZDC;}
	146
	147	// Delegated methods for fESDZDC
	148	Double_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
	149	Double_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
	150	Double_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
	151	Double_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
	152	Double_t GetZDCEMEnergy(Int_t i=0) const {return fESDZDC->GetZDCEMEnergy(i);}
	153	Int_t GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
	154	void SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t em1Energy, Float_t em2Energy,
	155	Float_t n2Energy, Float_t p2Energy, Int_t participants, Int_t nPartA,
	156	Int_t nPartC, Double_t b, Double_t bA, Double_t bC, UInt_t recoflag)
	157	{fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy,
	158	participants, nPartA, nPartC, b, bA, bC, recoflag);}
	159
	160
	161	// FMD
	162	void SetFMDData(AliESDFMD * obj);
	163	AliESDFMD *GetFMDData(){ return fESDFMD; }
	164
	165
	166	// TZERO CKB: put this in the header?
	167	const AliESDTZERO* GetESDTZERO() const {return fESDTZERO;}
	168	// delegetated methods for fESDTZERO
	169
	170	Double_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
	171	void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
	172	Double_t GetT0() const {return fESDTZERO->GetT0();}
	173	void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
	174	const Double_t * GetT0time() const {return fESDTZERO->GetT0time();}
	175	void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
	176	const Double_t * GetT0amplitude() const {return fESDTZERO->GetT0amplitude();}
	177	void SetT0amplitude(Float_t amp[24]){fESDTZERO->SetT0amplitude(amp);}
	178
	179	// VZERO
	180	AliESDVZERO *GetVZEROData() const { return fESDVZERO; }
	181	void SetVZEROData(AliESDVZERO * obj);
	182
	183	// ACORDE
	184	AliESDACORDE *GetACORDEData() const { return fESDACORDE;}
	185	void SetACORDEData(AliESDACORDE * obj);
	186
	187	void SetESDfriend(const AliESDfriend *f) const;
	188	void GetESDfriend(AliESDfriend *f) const;
	189
	190
	191
	192	void SetPrimaryVertexTPC(const AliESDVertex *vertex);
	193	const AliESDVertex *GetPrimaryVertexTPC() const {return fTPCVertex;}
	194
	195	void SetPrimaryVertexSPD(const AliESDVertex *vertex);
	196	const AliESDVertex *GetPrimaryVertexSPD() const {return fSPDVertex;}
	197	const AliESDVertex *GetVertex() const {
	198	//For the backward compatibily only
	199	return GetPrimaryVertexSPD();
	200	}
	201
	202	void SetPrimaryVertexTracks(const AliESDVertex *vertex);
	203	const AliESDVertex *GetPrimaryVertexTracks() const {return fPrimaryVertex;}
	204
	205	const AliESDVertex *GetPrimaryVertex() const;
	206
	207	void SetMultiplicity(const AliMultiplicity *mul);
	208
	209	const AliMultiplicity *GetMultiplicity() const {return fSPDMult;}
	210
	211
	212	Bool_t Clean(Float_t *cleanPars);
	213	Bool_t RemoveKink(Int_t i) const;
	214	Bool_t RemoveV0(Int_t i) const;
	215	Bool_t RemoveTrack(Int_t i) const;
	216
	217	const AliESDVertex *GetPileupVertexSPD(Int_t i) const {
	218	return (const AliESDVertex *)fSPDPileupVertices->UncheckedAt(i);
	219	}
	220	Char_t AddPileupVertexSPD(const AliESDVertex *vtx);
	221
	222	const AliESDVertex *GetPileupVertexTracks(Int_t i) const {
	223	return (const AliESDVertex *)fTrkPileupVertices->UncheckedAt(i);
	224	}
	225	Char_t AddPileupVertexTracks(const AliESDVertex *vtx);
	226
	227	AliESDtrack *GetTrack(Int_t i) const {
	228	return (AliESDtrack *)fTracks->UncheckedAt(i);
	229	}
	230	Int_t AddTrack(const AliESDtrack *t);
	231
	232
	233	AliESDHLTtrack GetHLTConfMapTrack(Int_t /i*/) const {
	234	// return (AliESDHLTtrack *)fHLTConfMapTracks->UncheckedAt(i);
	235	return 0;
	236	}
	237	void AddHLTConfMapTrack(const AliESDHLTtrack /t*/) {
	238	printf("ESD:: AddHLTConfMapTrack do nothing \n");
	239	// TClonesArray &fhlt = *fHLTConfMapTracks;
	240	// new(fhlt[fHLTConfMapTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
	241	}
	242
	243
	244	AliESDHLTtrack GetHLTHoughTrack(Int_t /i*/) const {
	245	// return (AliESDHLTtrack *)fHLTHoughTracks->UncheckedAt(i);
	246	return 0;
	247	}
	248	void AddHLTHoughTrack(const AliESDHLTtrack /t*/) {
	249	printf("ESD:: AddHLTHoughTrack do nothing \n");
	250	// TClonesArray &fhlt = *fHLTHoughTracks;
	251	// new(fhlt[fHLTHoughTracks->GetEntriesFast()]) AliESDHLTtrack(*t);
	252	}
	253
	254	AliESDMuonTrack *GetMuonTrack(Int_t i) const {
	255	return (AliESDMuonTrack *)fMuonTracks->UncheckedAt(i);
	256	}
	257
	258	void AddMuonTrack(const AliESDMuonTrack *t);
	259
	260	AliESDPmdTrack *GetPmdTrack(Int_t i) const {
	261	return (AliESDPmdTrack *)fPmdTracks->UncheckedAt(i);
	262	}
	263
	264	void AddPmdTrack(const AliESDPmdTrack *t);
	265
	266
	267	AliESDTrdTrack *GetTrdTrack(Int_t i) const {
	268	return (AliESDTrdTrack *)fTrdTracks->UncheckedAt(i);
	269	}
	270
	271
	272	void AddTrdTrack(const AliESDTrdTrack *t);
	273
	274	AliESDv0 *GetV0(Int_t i) const {
	275	return (AliESDv0*)fV0s->UncheckedAt(i);
	276	}
	277	Int_t AddV0(const AliESDv0 *v);
	278
	279	AliESDcascade *GetCascade(Int_t i) const {
	280	return (AliESDcascade *)fCascades->UncheckedAt(i);
	281	}
	282
	283	void AddCascade(const AliESDcascade *c);
	284
	285	AliESDkink *GetKink(Int_t i) const {
	286	return (AliESDkink *)fKinks->UncheckedAt(i);
	287	}
	288	Int_t AddKink(const AliESDkink *c);
	289
	290	AliESDCaloCluster *GetCaloCluster(Int_t i) const {
	291	return (AliESDCaloCluster *)fCaloClusters->UncheckedAt(i);
	292	}
	293
	294	Int_t AddCaloCluster(const AliESDCaloCluster *c);
	295
	296	AliESDCaloCells *GetEMCALCells() const {return fEMCALCells; }
	297	AliESDCaloCells *GetPHOSCells() const {return fPHOSCells; }
	298
	299	AliRawDataErrorLog *GetErrorLog(Int_t i) const {
	300	return (AliRawDataErrorLog *)fErrorLogs->UncheckedAt(i);
	301	}
	302	void AddRawDataErrorLog(const AliRawDataErrorLog *log) const;
	303
	304	Int_t GetNumberOfErrorLogs() const {return fErrorLogs->GetEntriesFast();}
	305
	306
	307	void AddPHOSTriggerPosition(TArrayF array) { fPHOSTrigger->AddTriggerPosition(array); }
	308	void AddPHOSTriggerAmplitudes(TArrayF array) { fPHOSTrigger->AddTriggerAmplitudes(array);}
	309	void AddEMCALTriggerPosition(TArrayF array) { fEMCALTrigger->AddTriggerPosition(array); }
	310	void AddEMCALTriggerAmplitudes(TArrayF array){ fEMCALTrigger->AddTriggerAmplitudes(array); }
	311
	312	Int_t GetNumberOfPileupVerticesSPD() const {
	313	return fSPDPileupVertices->GetEntriesFast();
	314	}
	315	Int_t GetNumberOfPileupVerticesTracks() const {
	316	return fTrkPileupVertices->GetEntriesFast();
	317	}
	318	Int_t GetNumberOfTracks() const {return fTracks->GetEntriesFast();}
	319	Int_t GetNumberOfHLTConfMapTracks() const {return 0;}
	320	// fHLTConfMapTracks->GetEntriesFast();}
	321	Int_t GetNumberOfHLTHoughTracks() const {return 0; }
	322	// fHLTHoughTracks->GetEntriesFast(); }
	323
	324	Int_t GetNumberOfMuonTracks() const {return fMuonTracks->GetEntriesFast();}
	325	Int_t GetNumberOfPmdTracks() const {return fPmdTracks->GetEntriesFast();}
	326	Int_t GetNumberOfTrdTracks() const {return fTrdTracks->GetEntriesFast();}
	327	Int_t GetNumberOfV0s() const {return fV0s->GetEntriesFast();}
	328	Int_t GetNumberOfCascades() const {return fCascades->GetEntriesFast();}
	329	Int_t GetNumberOfKinks() const {return fKinks->GetEntriesFast();}
	330
	331	Int_t GetEMCALClusters(TRefArray *clusters) const;
	332	Int_t GetPHOSClusters(TRefArray *clusters) const;
	333	Int_t GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}
	334
	335	void SetUseOwnList(Bool_t b){fUseOwnList = b;}
	336	Bool_t GetUseOwnList(){return fUseOwnList;}
	337
	338	// Remove this stuff CKB?
	339	//---------------------------------------------------
	340	Int_t GetNumberOfEMCALClusters() const {return fEMCALClusters;}
	341	void SetNumberOfEMCALClusters(Int_t clus) {fEMCALClusters = clus;}
	342	Int_t GetFirstEMCALCluster() const {return fFirstEMCALCluster;}
	343	void SetFirstEMCALCluster(Int_t index) {fFirstEMCALCluster = index;}
	344
	345	Int_t GetNumberOfPHOSClusters() const {return fPHOSClusters;}
	346	void SetNumberOfPHOSClusters(Int_t part) { fPHOSClusters = part ; }
	347	void SetFirstPHOSCluster(Int_t index) { fFirstPHOSCluster = index ; }
	348	Int_t GetFirstPHOSCluster() const { return fFirstPHOSCluster ; }
	349	//-------------------------------------------------------
	350
	351	TArrayF *GetEMCALTriggerPosition() const {return fEMCALTrigger->GetTriggerPosition();}
	352	TArrayF *GetEMCALTriggerAmplitudes() const {return fEMCALTrigger->GetTriggerAmplitudes();}
	353	TArrayF *GetPHOSTriggerPosition() const {return fPHOSTrigger->GetTriggerPosition();}
	354	TArrayF *GetPHOSTriggerAmplitudes() const {return fPHOSTrigger->GetTriggerAmplitudes();}
	355
	356	void ResetV0s() { fV0s->Clear(); }
	357	void ResetCascades() { fCascades->Clear(); }
	358	void Reset();
	359
	360	void Print(Option_t *option="") const;
	361
	362	void AddObject(TObject* obj);
	363	void ReadFromTree(TTree tree, Option_t opt = "");
	364	TObject* FindListObject(const char *name);
	365	AliESD *GetAliESDOld(){return fESDOld;}
	366	void WriteToTree(TTree* tree) const;
	367	void GetStdContent();
	368	void ResetStdContent();
	369	void CreateStdContent();
	370	void CreateStdContent(Bool_t bUseThisList);
	371	void SetStdNames();
	372	void CopyFromOldESD();
	373	TList* GetList() const {return fESDObjects;}
	374
	375	protected:
	376	AliESDEvent(const AliESDEvent&);
	377	static Bool_t ResetWithPlacementNew(TObject *pObject);
	378
	379	TList *fESDObjects; // List of esd Objects
	380
	381	AliESDRun *fESDRun; //! Run information tmp put in the Userdata
	382	AliESDHeader *fHeader; //! ESD Event Header
	383	AliESDZDC *fESDZDC; //! ZDC information
	384	AliESDFMD *fESDFMD; //! FMD object containing rough multiplicity
	385	AliESDVZERO *fESDVZERO; //! VZERO object containing rough multiplicity
	386	AliESDTZERO *fESDTZERO; //! TZEROObject
	387	AliESDVertex *fTPCVertex; //! Primary vertex estimated by the TPC
	388	AliESDVertex *fSPDVertex; //! Primary vertex estimated by the SPD
	389	AliESDVertex *fPrimaryVertex; //! Primary vertex estimated using ESD tracks
	390	AliMultiplicity *fSPDMult; //! SPD tracklet multiplicity
	391	AliESDCaloTrigger* fPHOSTrigger; //! PHOS Trigger information
	392	AliESDCaloTrigger* fEMCALTrigger; //! PHOS Trigger information
	393	AliESDACORDE *fESDACORDE; //! ACORDE ESD object caontaining bit pattern
	394
	395	TClonesArray *fSPDPileupVertices;//! Pileup primary vertices reconstructed by SPD
	396	TClonesArray *fTrkPileupVertices;//! Pileup primary vertices reconstructed using the tracks
	397	TClonesArray *fTracks; //! ESD tracks
	398	TClonesArray *fMuonTracks; //! MUON ESD tracks
	399	TClonesArray *fPmdTracks; //! PMD ESD tracks
	400	TClonesArray *fTrdTracks; //! TRD ESD tracks (triggered)
	401	TClonesArray *fV0s; //! V0 vertices
	402	TClonesArray *fCascades; //! Cascade vertices
	403	TClonesArray *fKinks; //! Kinks
	404	TClonesArray *fCaloClusters; //! Calorimeter clusters for PHOS/EMCAL
	405	AliESDCaloCells *fEMCALCells; //! EMCAL cell info
	406	AliESDCaloCells *fPHOSCells; //! PHOS cell info
	407	TClonesArray *fErrorLogs; //! Raw-data reading error messages
	408
	409
	410
	411	AliESD *fESDOld; //! Old esd Structure
	412	AliESDfriend *fESDFriendOld; //! Old friend esd Structure
	413	Bool_t fConnected; //! flag if leaves are alreday connected
	414	Bool_t fUseOwnList; //! Do not use the list from the esdTree but use the one created by this class
	415
	416	static const char* fgkESDListName[kESDListN]; //!
	417
	418	// Remove this stuff CKB
	419	Int_t fEMCALClusters; // Number of EMCAL clusters (subset of caloclusters)
	420	Int_t fFirstEMCALCluster; // First EMCAL cluster in the fCaloClusters list
	421
	422	Int_t fPHOSClusters; // Number of PHOS clusters (subset of caloclusters)
	423	Int_t fFirstPHOSCluster; // First PHOS cluster in the fCaloClusters list
	424
	425	ClassDef(AliESDEvent,10) //ESDEvent class
	426	};
	427	#endif
	428