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

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

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


  Bool_t Clean(Float_t *cleanPars);
  Bool_t RemoveKink(Int_t i);
  Bool_t RemoveV0(Int_t i);
  Bool_t RemoveTrack(Int_t i);

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