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

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

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


  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

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