[u/mrichter/AliRoot.git] / PHOS / AliPHOSLoader.h

#ifndef ALIPHOSLOADER_H
#define ALIPHOSLOADER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

//_________________________________________________________________________
//  A singleton that returns various objects 
//  Should be used on the analysis stage to avoid confusing between different
//  branches of reconstruction tree: e.g. reading RecPoints and TS made from 
//  another set of RecPoints.
// 
//  The objects are retrived from folders.  
//*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
//    


// --- ROOT system ---
#include "TClonesArray.h"
#include "TFolder.h"  
#include "TTree.h"
class TString ;
class TParticle ;
class TTask ;

// --- Standard library ---
#include <stdlib.h>
#include <Riostream.h>

// --- AliRoot header files ---

#include "AliRun.h"
#include "AliLoader.h"
#include "AliRunLoader.h"
#include "AliPHOS.h" 
#include "AliPHOSHit.h" 
#include "AliPHOSDigit.h"
#include "AliPHOSEmcRecPoint.h"
#include "AliPHOSCpvRecPoint.h"
#include "AliPHOSTrackSegment.h"
#include "AliPHOSRecParticle.h"
class AliPHOSGeometry ;
#include "AliPHOSDigitizer.h"
#include "AliPHOSSDigitizer.h"
#include "AliPHOSClusterizer.h"
#include "AliPHOSTrackSegmentMaker.h"
#include "AliPHOSPID.h"
class AliPHOSCalibrationDB ;


//

class AliPHOSLoader : public AliLoader {
  
 public:

  AliPHOSLoader();
  AliPHOSLoader(const AliPHOSLoader & obj) : AliLoader(obj) {}
  AliPHOSLoader(const Char_t *detname,const Char_t *eventfoldername); 
  
  virtual ~AliPHOSLoader() ; 

  // assignement operator requested by coding convention, but not needed
  AliPHOSLoader & operator = (const AliPHOSLoader & ) {return *this;}

  Int_t   GetEvent();//extends the method on PHOS RecPart posting
  Int_t   SetEvent();//extends the method on PHOS RecPart posting
  
  Bool_t  BranchExists(const TString& recName);
  Int_t   LoadHits(Option_t* opt=""); //reads  from disk and sends them to folder; array as well as tree
  Int_t   LoadSDigits(Option_t* opt="");
  Int_t   LoadDigits(Option_t* opt=""); //reads Digits from disk and sends them to folder; array as well as tree
  Int_t   LoadRecPoints(Option_t* opt=""); //reads RecPoints from disk and sends them to folder; array as well as tree
  Int_t   LoadTracks(Option_t* opt="");  //reads Tracks from disk and sends them to folder; array as well as tree
  Int_t   LoadRecParticles(Option_t* opt="");
   
  Int_t   PostHits();  //Posts the 
  Int_t   PostSDigits();
  Int_t   PostDigits();
  Int_t   PostRecPoints();
  Int_t   PostTracks();
  Int_t   PostRecParticles();
  
  void    CleanFolders();//cleans all the stuff loaded by this detector + calls AliLoader::Clean

  void    CleanHits();
  void    CleanSDigits();
  void    CleanDigits();
  void    CleanRecPoints();
  void    CleanTracks();
  void    CleanRecParticles();

//up to now it is only here -> no definition about global/incremental tracking/PID
 
//   Int_t   WriteRecParticles(Option_t* opt="");//writes the reconstructed particles
//   Int_t   WritePID(Option_t* opt="");//writes the task for PID to file
//   Bool_t  PostPID  (AliPHOSPID * pid) const {return kTRUE;}
//  Bool_t  PostQA   (void) const ; //it was empty anyway
  
/*******************************************************************/
/*******************************************************************/
/*******************************************************************/

  TObject** HitsRef(){return GetDetectorDataRef(Hits());}
  TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
  TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
  TObject** EmcRecPointsRef(){return GetDetectorDataRef(EmcRecPoints());}
  TObject** CpvRecPointsRef(){return GetDetectorDataRef(CpvRecPoints());}
  TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
  TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
  TObject** AlarmsRef(){return GetDetectorDataRef(Alarms());}
  void   Track(Int_t itrack) ;

  static AliPHOSGeometry* GetPHOSGeometry();
  static AliPHOSLoader* GetPHOSLoader(const  char* eventfoldername);

  //Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
  Int_t  EventNumber()       { return (Int_t) GetRunLoader()->GetEventNumber();}
  Int_t  MaxEvent()          { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}

  const AliPHOS *         PHOS();
  const AliPHOSGeometry  *PHOSGeometry() ; 
  // Alarms
  // TFolder * Alarms() const { return (TFolder*)(ReturnO("Alarms", 0)); }
  TObjArray *  Alarms();  

  /*********************************************/
  /************    TClonesArrays     ***********/
  /*********************************************/
  /****   H i t s  ****/
  TClonesArray*  Hits(void);
  const AliPHOSHit*    Hit(Int_t index);
  void MakeHitsArray();
  /****   S D i g i t s  ****/ 
  TClonesArray*  SDigits();
  const AliPHOSDigit*  SDigit(Int_t index);
  void MakeSDigitsArray();
  /****  D i g i t s  ****/
  TClonesArray*   Digits();
  const AliPHOSDigit *  Digit(Int_t index);
  void MakeDigitsArray();
  /****  R e c P o i n t s  ****/
  TObjArray * EmcRecPoints();
  TObjArray * CpvRecPoints();
  const AliPHOSEmcRecPoint * EmcRecPoint(Int_t index) ;
  const AliPHOSCpvRecPoint * CpvRecPoint(Int_t index) ;
  void MakeRecPointsArray();
  /****   T r a c k S e g m e n t s ****/
  TClonesArray * TrackSegments();
  const AliPHOSTrackSegment * TrackSegment(Int_t index);
  void MakeTrackSegmentsArray();
  /****  R e c P a r t ic l e s   ****/
  TClonesArray * RecParticles() ;
  const AliPHOSRecParticle * RecParticle(Int_t index);
  void MakeRecParticlesArray();

  /*********************************************/
  /************    T A S K S      **************/
  /*********************************************/
  // 
  //  AliPHOSSDigitizer*  PHOSSDigitizer(TString name = AliConfig::fgkDefaultEventFolderName);
  //AliPHOSDigitizer*   PHOSDigitizer()  { return  dynamic_cast<AliPHOSDigitizer*>(Digitizer()) ;}

  AliPHOSClusterizer* Clusterizer ()  {return dynamic_cast<AliPHOSClusterizer*>(Reconstructioner()) ;}
  Int_t PostClusterizer(TTask* clust){return PostReconstructioner(clust);}
  Int_t LoadClusterizer(Option_t * opt="") {return LoadReconstructioner(opt);}
  Int_t WriteClusterizer(Option_t * opt="") {return WriteReconstructioner(opt);}

  AliPHOSPID * PID (){return dynamic_cast<AliPHOSPID*>(PIDTask()) ;}
  Int_t PostPID(TTask* pid){return PostPIDTask(pid);}
  Int_t LoadPID(Option_t * opt="") {return LoadPIDTask(opt);}
  Int_t WritePID(Option_t * opt="") {return WritePIDTask(opt);}


  AliPHOSTrackSegmentMaker * TrackSegmentMaker ()  { return dynamic_cast<AliPHOSTrackSegmentMaker *>(Tracker()) ;}
  Int_t PostTrackSegmentMaker(TTask* segmaker){return PostTracker(segmaker);}
  Int_t LoadTrackSegmentMaker(Option_t * opt="") {return LoadTracker(opt);}
  Int_t WriteTrackSegmentMaker(Option_t * opt="") {return WriteTracker(opt);}

  
  void   SetDebug(Int_t level) {fDebug = level;} // Set debug level
  void   SetBranchTitle(const TString& btitle);
  
  AliPHOSCalibrationDB * CalibrationDB(){return  fcdb; }
  void ReadCalibrationDB(const char * name, const char * filename);
  
protected:
  TString fBranchTitle;            //Title of the branch
  AliPHOSCalibrationDB * fcdb ;       //!

private:

  Int_t ReadHits();
  Int_t ReadDigits();
  Int_t ReadSDigits();
  Int_t ReadRecPoints();
  Int_t ReadTracks();
  Int_t ReadRecParticles();
  
  void  ReadTreeQA() ;
  Int_t  fDebug ;             // Debug level
 
 public:

  static const TString fgkHitsName;//Name for TClonesArray with hits from one event
  static const TString fgkSDigitsName;//Name for TClonesArray 
  static const TString fgkDigitsName;//Name for TClonesArray 
  static const TString fgkEmcRecPointsName;//Name for TClonesArray 
  static const TString fgkCpvRecPointsName;//Name for TClonesArray 
  static const TString fgkTracksName;//Name for TClonesArray 
  static const TString fgkRecParticlesName;//Name for TClonesArray

  static const TString fgkEmcRecPointsBranchName;//Name for branch
  static const TString fgkCpvRecPointsBranchName;//Name for branch
  static const TString fgkTrackSegmentsBranchName;//Name for branch
  static const TString fgkRecParticlesBranchName;//Name for branch
  
  ClassDef(AliPHOSLoader,3)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 

};

/******************************************************************************/
/****************    I N L I N E S     ****************************************/
/******************************************************************************/

inline TClonesArray* AliPHOSLoader::Hits()  
{
 return (TClonesArray*)GetDetectorData(fgkHitsName);
}
/******************************************************************************/

inline const AliPHOSHit* AliPHOSLoader::Hit(Int_t index)  
{
  const TClonesArray* tcarr = Hits();
  if (tcarr)
    return (const AliPHOSHit*) tcarr->At(index);
  return 0x0; 
}
/******************************************************************************/

inline TClonesArray* AliPHOSLoader::SDigits()
{
   return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
}
/******************************************************************************/

inline const AliPHOSDigit*  AliPHOSLoader::SDigit(Int_t index)
{
  const TClonesArray* tcarr = SDigits();
  if (tcarr)
    return (const AliPHOSDigit*) tcarr->At(index);
  return 0x0; 
}
/******************************************************************************/

inline TClonesArray* AliPHOSLoader::Digits()
{
 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
}
/******************************************************************************/

inline const AliPHOSDigit*  AliPHOSLoader::Digit(Int_t index)
{
  const TClonesArray* tcarr = Digits();
  if (tcarr)
    return (const AliPHOSDigit*) tcarr->At(index);
  return 0x0; 
}
/******************************************************************************/

inline TObjArray * AliPHOSLoader::EmcRecPoints()
{
 return dynamic_cast<TObjArray*>(GetDetectorData(fgkEmcRecPointsName));
}
/******************************************************************************/

inline const AliPHOSEmcRecPoint * AliPHOSLoader::EmcRecPoint(Int_t index)
{
  TObjArray* tcarr = EmcRecPoints();
  if (tcarr)
    return (const AliPHOSEmcRecPoint*) tcarr->At(index);
  return 0x0; 
}
/******************************************************************************/

inline TObjArray * AliPHOSLoader::CpvRecPoints()
{
 return dynamic_cast<TObjArray*>(GetDetectorData(fgkCpvRecPointsName));
}
/******************************************************************************/

inline const AliPHOSCpvRecPoint * AliPHOSLoader::CpvRecPoint(Int_t index)
{
  TObjArray* tcarr = CpvRecPoints();
  if (tcarr)
    return (const AliPHOSCpvRecPoint*) tcarr->At(index);
  return 0x0; 
}
/******************************************************************************/

inline TClonesArray * AliPHOSLoader::TrackSegments()
{
 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
}
/******************************************************************************/

inline const AliPHOSTrackSegment * AliPHOSLoader::TrackSegment(Int_t index)
{
  const TClonesArray* tcarr = TrackSegments();
  if (tcarr)
    return (const AliPHOSTrackSegment*) tcarr->At(index);
  return 0x0; 
}
/******************************************************************************/

inline TClonesArray * AliPHOSLoader::RecParticles() 
{
 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName)); 
}
/******************************************************************************/

inline const AliPHOSRecParticle* AliPHOSLoader::RecParticle(Int_t index)
{
  TClonesArray* tcarr = RecParticles();
  if (tcarr)
    return (const AliPHOSRecParticle*) tcarr->At(index);
  return 0x0;  
}
/******************************************************************************/
inline TObjArray *  AliPHOSLoader::Alarms()
{ return (TObjArray*)(GetQAFolder()->FindObject(fDetectorName));}

#endif // AliPHOSLOADER_H
Commit	Line	Data
88cb7938	1	#ifndef ALIPHOSLOADER_H
	2	#define ALIPHOSLOADER_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	//_________________________________________________________________________
	9	// A singleton that returns various objects
	10	// Should be used on the analysis stage to avoid confusing between different
	11	// branches of reconstruction tree: e.g. reading RecPoints and TS made from
	12	// another set of RecPoints.
	13	//
	14	// The objects are retrived from folders.
	15	//*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
	16	//
	17
	18
	19	// --- ROOT system ---
	20	#include "TClonesArray.h"
	21	#include "TFolder.h"
	22	#include "TTree.h"
	23	class TString ;
	24	class TParticle ;
	25	class TTask ;
	26
	27	// --- Standard library ---
	28	#include <stdlib.h>
	29	#include <Riostream.h>
	30
	31	// --- AliRoot header files ---
	32
	33	#include "AliRun.h"
	34	#include "AliLoader.h"
	35	#include "AliRunLoader.h"
	36	#include "AliPHOS.h"
	37	#include "AliPHOSHit.h"
	38	#include "AliPHOSDigit.h"
	39	#include "AliPHOSEmcRecPoint.h"
	40	#include "AliPHOSCpvRecPoint.h"
	41	#include "AliPHOSTrackSegment.h"
	42	#include "AliPHOSRecParticle.h"
	43	class AliPHOSGeometry ;
	44	#include "AliPHOSDigitizer.h"
	45	#include "AliPHOSSDigitizer.h"
	46	#include "AliPHOSClusterizer.h"
	47	#include "AliPHOSTrackSegmentMaker.h"
	48	#include "AliPHOSPID.h"
	49	class AliPHOSCalibrationDB ;
	50
	51
	52	//
	53
	54	class AliPHOSLoader : public AliLoader {
	55
	56	public:
	57
	58	AliPHOSLoader();
a8c47ab6	59	AliPHOSLoader(const AliPHOSLoader & obj) : AliLoader(obj) {}
88cb7938	60	AliPHOSLoader(const Char_t detname,const Char_t eventfoldername);
	61
	62	virtual ~AliPHOSLoader() ;
	63
	64	// assignement operator requested by coding convention, but not needed
	65	AliPHOSLoader & operator = (const AliPHOSLoader & ) {return *this;}
	66
	67	Int_t GetEvent();//extends the method on PHOS RecPart posting
	68	Int_t SetEvent();//extends the method on PHOS RecPart posting
	69
	70	Bool_t BranchExists(const TString& recName);
	71	Int_t LoadHits(Option_t* opt=""); //reads from disk and sends them to folder; array as well as tree
	72	Int_t LoadSDigits(Option_t* opt="");
	73	Int_t LoadDigits(Option_t* opt=""); //reads Digits from disk and sends them to folder; array as well as tree
	74	Int_t LoadRecPoints(Option_t* opt=""); //reads RecPoints from disk and sends them to folder; array as well as tree
	75	Int_t LoadTracks(Option_t* opt=""); //reads Tracks from disk and sends them to folder; array as well as tree
	76	Int_t LoadRecParticles(Option_t* opt="");
	77
	78	Int_t PostHits(); //Posts the
	79	Int_t PostSDigits();
	80	Int_t PostDigits();
	81	Int_t PostRecPoints();
	82	Int_t PostTracks();
	83	Int_t PostRecParticles();
	84
	85	void CleanFolders();//cleans all the stuff loaded by this detector + calls AliLoader::Clean
	86
	87	void CleanHits();
	88	void CleanSDigits();
	89	void CleanDigits();
	90	void CleanRecPoints();
	91	void CleanTracks();
	92	void CleanRecParticles();
	93
	94	//up to now it is only here -> no definition about global/incremental tracking/PID
	95
	96	// Int_t WriteRecParticles(Option_t* opt="");//writes the reconstructed particles
	97	// Int_t WritePID(Option_t* opt="");//writes the task for PID to file
	98	// Bool_t PostPID (AliPHOSPID * pid) const {return kTRUE;}
	99	// Bool_t PostQA (void) const ; //it was empty anyway
	100
	101	/*******************************************************************/
	102	/*******************************************************************/
	103	/*******************************************************************/
	104
	105	TObject** HitsRef(){return GetDetectorDataRef(Hits());}
	106	TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
	107	TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
	108	TObject** EmcRecPointsRef(){return GetDetectorDataRef(EmcRecPoints());}
	109	TObject** CpvRecPointsRef(){return GetDetectorDataRef(CpvRecPoints());}
	110	TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
	111	TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
	112	TObject** AlarmsRef(){return GetDetectorDataRef(Alarms());}
	113	void Track(Int_t itrack) ;
	114
	115	static AliPHOSGeometry* GetPHOSGeometry();
	116	static AliPHOSLoader* GetPHOSLoader(const char* eventfoldername);
	117
	118	//Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
	119	Int_t EventNumber() { return (Int_t) GetRunLoader()->GetEventNumber();}
	120	Int_t MaxEvent() { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}
	121
	122	const AliPHOS * PHOS();
	123	const AliPHOSGeometry *PHOSGeometry() ;
124	// Alarms
125	// TFolder * Alarms() const { return (TFolder*)(ReturnO("Alarms", 0)); }
126	TObjArray * Alarms();
127
128	/*********************************************/
129	/********** TClonesArrays *********/
130	/*********************************************/
131	/** H i t s **/
132	TClonesArray* Hits(void);
133	const AliPHOSHit* Hit(Int_t index);
134	void MakeHitsArray();
135	/** S D i g i t s **/
136	TClonesArray* SDigits();
137	const AliPHOSDigit* SDigit(Int_t index);
138	void MakeSDigitsArray();
139	/** D i g i t s **/
140	TClonesArray* Digits();
141	const AliPHOSDigit * Digit(Int_t index);
142	void MakeDigitsArray();
143	/** R e c P o i n t s **/
144	TObjArray * EmcRecPoints();
145	TObjArray * CpvRecPoints();
146	const AliPHOSEmcRecPoint * EmcRecPoint(Int_t index) ;
147	const AliPHOSCpvRecPoint * CpvRecPoint(Int_t index) ;
148	void MakeRecPointsArray();
149	/** T r a c k S e g m e n t s **/
150	TClonesArray * TrackSegments();
151	const AliPHOSTrackSegment * TrackSegment(Int_t index);
152	void MakeTrackSegmentsArray();
153	/** R e c P a r t ic l e s **/
154	TClonesArray * RecParticles() ;
155	const AliPHOSRecParticle * RecParticle(Int_t index);
156	void MakeRecParticlesArray();
157
158	/*********************************************/
159	/********** T A S K S ************/
160	/*********************************************/
161	//
162	// AliPHOSSDigitizer* PHOSSDigitizer(TString name = AliConfig::fgkDefaultEventFolderName);
163	//AliPHOSDigitizer* PHOSDigitizer() { return dynamic_cast<AliPHOSDigitizer*>(Digitizer()) ;}
164
165	AliPHOSClusterizer* Clusterizer () {return dynamic_cast<AliPHOSClusterizer*>(Reconstructioner()) ;}
166	Int_t PostClusterizer(TTask* clust){return PostReconstructioner(clust);}
167	Int_t LoadClusterizer(Option_t * opt="") {return LoadReconstructioner(opt);}
168	Int_t WriteClusterizer(Option_t * opt="") {return WriteReconstructioner(opt);}
169
170	AliPHOSPID * PID (){return dynamic_cast<AliPHOSPID*>(PIDTask()) ;}
171	Int_t PostPID(TTask* pid){return PostPIDTask(pid);}
172	Int_t LoadPID(Option_t * opt="") {return LoadPIDTask(opt);}
173	Int_t WritePID(Option_t * opt="") {return WritePIDTask(opt);}
174
175
176	AliPHOSTrackSegmentMaker * TrackSegmentMaker () { return dynamic_cast<AliPHOSTrackSegmentMaker *>(Tracker()) ;}
177	Int_t PostTrackSegmentMaker(TTask* segmaker){return PostTracker(segmaker);}
178	Int_t LoadTrackSegmentMaker(Option_t * opt="") {return LoadTracker(opt);}
179	Int_t WriteTrackSegmentMaker(Option_t * opt="") {return WriteTracker(opt);}
180
181
182	void SetDebug(Int_t level) {fDebug = level;} // Set debug level
183	void SetBranchTitle(const TString& btitle);
184
185	AliPHOSCalibrationDB * CalibrationDB(){return fcdb; }
186	void ReadCalibrationDB(const char * name, const char * filename);
187
188	protected:
189	TString fBranchTitle; //Title of the branch
190	AliPHOSCalibrationDB * fcdb ; //!
191
192	private:
193
194	Int_t ReadHits();
195	Int_t ReadDigits();
196	Int_t ReadSDigits();
197	Int_t ReadRecPoints();
198	Int_t ReadTracks();
199	Int_t ReadRecParticles();
200
201	void ReadTreeQA() ;
202	Int_t fDebug ; // Debug level
203
204	public:
205
206	static const TString fgkHitsName;//Name for TClonesArray with hits from one event
207	static const TString fgkSDigitsName;//Name for TClonesArray
208	static const TString fgkDigitsName;//Name for TClonesArray
209	static const TString fgkEmcRecPointsName;//Name for TClonesArray
210	static const TString fgkCpvRecPointsName;//Name for TClonesArray
211	static const TString fgkTracksName;//Name for TClonesArray
212	static const TString fgkRecParticlesName;//Name for TClonesArray
213
214	static const TString fgkEmcRecPointsBranchName;//Name for branch
215	static const TString fgkCpvRecPointsBranchName;//Name for branch
216	static const TString fgkTrackSegmentsBranchName;//Name for branch
217	static const TString fgkRecParticlesBranchName;//Name for branch
218
219	ClassDef(AliPHOSLoader,3) // Algorithm class that provides methods to retrieve objects from a list knowing the index
220
221	};
222
223	/******************************************************************************/
224	/************** I N L I N E S **************************************/
225	/******************************************************************************/
226
227	inline TClonesArray* AliPHOSLoader::Hits()
228	{
229	return (TClonesArray*)GetDetectorData(fgkHitsName);
230	}
231	/******************************************************************************/
232
233	inline const AliPHOSHit* AliPHOSLoader::Hit(Int_t index)
234	{
235	const TClonesArray* tcarr = Hits();
236	if (tcarr)
237	return (const AliPHOSHit*) tcarr->At(index);
238	return 0x0;
239	}
240	/******************************************************************************/
241
242	inline TClonesArray* AliPHOSLoader::SDigits()
243	{
244	return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
245	}
246	/******************************************************************************/
247
248	inline const AliPHOSDigit* AliPHOSLoader::SDigit(Int_t index)
249	{
250	const TClonesArray* tcarr = SDigits();
251	if (tcarr)
252	return (const AliPHOSDigit*) tcarr->At(index);
253	return 0x0;
254	}
255	/******************************************************************************/
256
257	inline TClonesArray* AliPHOSLoader::Digits()
258	{
259	return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
260	}
261	/******************************************************************************/
262
263	inline const AliPHOSDigit* AliPHOSLoader::Digit(Int_t index)
264	{
265	const TClonesArray* tcarr = Digits();
266	if (tcarr)
267	return (const AliPHOSDigit*) tcarr->At(index);
268	return 0x0;
269	}
270	/******************************************************************************/
271
272	inline TObjArray * AliPHOSLoader::EmcRecPoints()
273	{
274	return dynamic_cast<TObjArray*>(GetDetectorData(fgkEmcRecPointsName));
275	}
276	/******************************************************************************/
277
278	inline const AliPHOSEmcRecPoint * AliPHOSLoader::EmcRecPoint(Int_t index)
279	{
280	TObjArray* tcarr = EmcRecPoints();
281	if (tcarr)
282	return (const AliPHOSEmcRecPoint*) tcarr->At(index);
283	return 0x0;
284	}
285	/******************************************************************************/
286
287	inline TObjArray * AliPHOSLoader::CpvRecPoints()
288	{
289	return dynamic_cast<TObjArray*>(GetDetectorData(fgkCpvRecPointsName));
290	}
291	/******************************************************************************/
292
293	inline const AliPHOSCpvRecPoint * AliPHOSLoader::CpvRecPoint(Int_t index)
294	{
295	TObjArray* tcarr = CpvRecPoints();
296	if (tcarr)
297	return (const AliPHOSCpvRecPoint*) tcarr->At(index);
298	return 0x0;
299	}
300	/******************************************************************************/
301
302	inline TClonesArray * AliPHOSLoader::TrackSegments()
303	{
304	return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
305	}
306	/******************************************************************************/
307
308	inline const AliPHOSTrackSegment * AliPHOSLoader::TrackSegment(Int_t index)
309	{
310	const TClonesArray* tcarr = TrackSegments();
311	if (tcarr)
312	return (const AliPHOSTrackSegment*) tcarr->At(index);
313	return 0x0;
314	}
315	/******************************************************************************/
316
317	inline TClonesArray * AliPHOSLoader::RecParticles()
318	{
319	return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName));
320	}
321	/******************************************************************************/
322
323	inline const AliPHOSRecParticle* AliPHOSLoader::RecParticle(Int_t index)
324	{
325	TClonesArray* tcarr = RecParticles();
326	if (tcarr)
327	return (const AliPHOSRecParticle*) tcarr->At(index);
328	return 0x0;
329	}
330	/******************************************************************************/
331	inline TObjArray * AliPHOSLoader::Alarms()
332	{ return (TObjArray*)(GetQAFolder()->FindObject(fDetectorName));}
333
334	#endif // AliPHOSLOADER_H