[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"

// AliESDtrack has to be included so that the compiler 
// knows its inheritance tree (= that it is a AliVParticle).
#include "AliESDtrack.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 AliESDEvent : public AliVEvent {
public:


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

  AliESDEvent();
  virtual ~AliESDEvent(); 


  // 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);}
  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)
  {fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy, participants);}


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


  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 SetPrimaryVertex(const AliESDVertex *vertex);
  const AliESDVertex *GetPrimaryVertex() const {return fPrimaryVertex;}

  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;

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

  
  // 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);
  TObject* FindListObject(const char *name);
  AliESD *GetAliESDOld(){return fESDOld;}
  const void WriteToTree(TTree* tree) const;
  void GetStdContent();
  void ResetStdContent();
  void CreateStdContent();
  void SetStdNames();
  void CopyFromOldESD();
  TList* GetList() const {return fESDObjects;}

protected:
  AliESDEvent(const AliESDEvent&);
  AliESDEvent &operator=(const AliESDEvent& source);


  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

  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

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