[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 physical 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;


// some includes for delegeated methds
#include "AliESDCaloTrigger.h"
#include "AliESDRun.h"
#include "AliESDHeader.h"
#include "AliESDTZERO.h"
#include "AliESDZDC.h"

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

class AliESDEvent : public TObject {
public:


  enum ESDListIndex_t   {kESDRun,
		       kHeader,
		       kESDZDC,
		       kESDFMD,
		       kESDVZERO,
		       kESDTZERO,
		       kSPDVertex,
		       kPrimaryVertex,
		       kSPDMult,
		       kPHOSTrigger,
		       kEMCALTrigger,
		       kTracks,
		       kMuonTracks,
		       kPmdTracks,
		       kTrdTracks,
		       kV0s,
		       kCascades,
		       kKinks,
		       kCaloClusters,
		       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(Int_t n){fESDRun->SetPeriodNumber(n);}
  Int_t   GetPeriodNumber() const {return fESDRun->GetPeriodNumber();}
  void    SetMagneticField(Float_t mf){fESDRun->SetMagneticField(mf);}
  Float_t GetMagneticField() const {return fESDRun->GetMagneticField();}
  void SetDiamond(const AliESDVertex *vertex) { fESDRun->SetDiamond(vertex);}
  Float_t GetDiamondX() const {return fESDRun->GetDiamondX();}
  Float_t GetDiamondY() const {return fESDRun->GetDiamondY();}
  Float_t GetSigma2DiamondX() const {return  fESDRun->GetSigma2DiamondX();}
  Float_t GetSigma2DiamondY() const {return  fESDRun->GetSigma2DiamondY();}
  void GetDiamondCovXY(Float_t cov[3]) const {fESDRun->GetDiamondCovXY(cov);}   
  

  // HEADER
  const 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();}
  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?
  const AliESDZDC*    GetESDZDC() const {return fESDZDC;}

  // Delegated methods for fESDZDC
  Float_t GetZDCN1Energy() const {return fESDZDC->GetZDCN1Energy();}
  Float_t GetZDCP1Energy() const {return fESDZDC->GetZDCP1Energy();}
  Float_t GetZDCN2Energy() const {return fESDZDC->GetZDCN2Energy();}
  Float_t GetZDCP2Energy() const {return fESDZDC->GetZDCP2Energy();}
  Float_t GetZDCEMEnergy() const {return fESDZDC->GetZDCEMEnergy();}
  Int_t   GetZDCParticipants() const {return fESDZDC->GetZDCParticipants();}
  void    SetZDC(Float_t n1Energy, Float_t p1Energy, Float_t emEnergy,
                 Float_t n2Energy, Float_t p2Energy, Int_t participants)
  {fESDZDC->SetZDC(n1Energy, p1Energy, emEnergy, 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

  Float_t GetT0zVertex() const {return fESDTZERO->GetT0zVertex();}
  void SetT0zVertex(Float_t z) {fESDTZERO->SetT0zVertex(z);}
  Float_t GetT0() const {return fESDTZERO->GetT0();}
  void SetT0(Float_t timeStart) {fESDTZERO->SetT0(timeStart);}
  const Float_t * GetT0time() const {return fESDTZERO->GetT0time();}
  void SetT0time(Float_t time[24]) {fESDTZERO->SetT0time(time);}
  const Float_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);
  void GetESDfriend(AliESDfriend *f) const;


  void SetVertex(const AliESDVertex *vertex); 
  const AliESDVertex *GetVertex() const {return fSPDVertex;}

  void SetPrimaryVertex(const AliESDVertex *vertex);
  const AliESDVertex *GetPrimaryVertex() const {return fPrimaryVertex;}

  void SetMultiplicity(const AliMultiplicity *mul);

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


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

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

  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 GetNumberOfCaloClusters() const {return fCaloClusters->GetEntriesFast();}

  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;}
  TArrayF *GetEMCALTriggerPosition() const {return  fEMCALTrigger->GetTriggerPosition();}
  TArrayF *GetEMCALTriggerAmplitudes() const {return  fEMCALTrigger->GetTriggerAmplitudes();}

  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 *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 {tree->Branch(fESDObjects);}
  void GetStdContent();
  void ResetStdContent();
  void CreateStdContent();
  void SetStdNames();
  void CopyFromOldESD();
  TList* GetList(){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    *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
  TClonesArray *fErrorLogs;        //! Raw-data reading error messages
 

  AliESD    *fESDOld;              //! Old esd Structure
  Bool_t    fConnected;            //! flag if leaves are alreday connected

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