[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,
		       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);}
  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();}
  Int_t   GetZDCParticipants2() const {return fESDZDC->GetZDCParticipants2();}
  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 participants2)
  {fESDZDC->SetZDC(n1Energy, p1Energy, em1Energy, em2Energy, n2Energy, p2Energy, 
   participants, participants2);}


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

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

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