Made more robust
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALLoader.h
1 #ifndef ALIEMCALLOADER_H
2 #define ALIEMCALLOADER_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
29 // --- AliRoot header files ---
30
31 #include "AliRun.h"
32 #include "AliRunLoader.h"
33 #include "AliEMCALDigit.h"
34 #include "AliEMCALRecPoint.h"
35 #include "AliEMCALTrackSegment.h"
36 #include "AliEMCALClusterizer.h"
37 #include "AliEMCALTrackSegmentMaker.h" 
38 #include "AliEMCALPID.h"
39 class AliLoader ;
40 class AliEMCAL ; 
41 class AliEMCALHit ;
42 class AliEMCALRecParticle ; 
43 class AliEMCALGeometry ;
44 class AliEMCALDigitizer ; 
45 class AliEMCALSDigitizer ; 
46 class AliEMCALCalibrationDB ;
47
48
49 //
50
51 class AliEMCALLoader : public AliLoader {
52   
53  public:
54
55   AliEMCALLoader();
56   AliEMCALLoader(const AliEMCALLoader & obj):AliLoader(obj){}
57   AliEMCALLoader(const Char_t *detname,const Char_t *eventfoldername); 
58   
59   virtual ~AliEMCALLoader() ; 
60
61   // assignement operator requested by coding convention, but not needed
62   const AliEMCALLoader & operator = (const AliEMCALLoader & ) {return *this;}
63
64   Int_t   GetEvent();//extends the method on EMCAL RecPart posting
65   Int_t   SetEvent();//extends the method on EMCAL RecPart posting
66   
67   Bool_t  BranchExists(const TString& recName);
68   Int_t   LoadHits(Option_t* opt=""); //reads  from disk and sends them to folder; array as well as tree
69   Int_t   LoadSDigits(Option_t* opt="");
70   Int_t   LoadDigits(Option_t* opt=""); //reads Digits from disk and sends them to folder; array as well as tree
71   Int_t   LoadRecPoints(Option_t* opt=""); //reads RecPoints from disk and sends them to folder; array as well as tree
72   Int_t   LoadTracks(Option_t* opt="");  //reads Tracks from disk and sends them to folder; array as well as tree
73   Int_t   LoadRecParticles(Option_t* opt="");
74  
75   void    UnloadRecParticles();
76   void    UnloadTracks();
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  (AliEMCALPID * pid) const {return kTRUE;}
99
100 /*******************************************************************/
101 /*******************************************************************/
102 /*******************************************************************/
103
104   TObject** HitsRef(){return GetDetectorDataRef(Hits());}
105   TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
106   TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
107   TObject** ECARecPointsRef(){return GetDetectorDataRef(ECARecPoints());}
108   TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
109   TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
110
111   void   Track(Int_t itrack) ;
112
113   static AliEMCALGeometry* GetEMCALGeometry();
114   static AliEMCALLoader* GetEMCALLoader(const  char* eventfoldername);
115
116   //Method to be used when digitizing under AliRunDigitizer, who opens all files etc.
117   Int_t  EventNumber()       { return (Int_t) GetRunLoader()->GetEventNumber();}
118   Int_t  MaxEvent()          { return (Int_t) GetRunLoader()->TreeE()->GetEntries();}
119
120   const AliEMCAL *         EMCAL();
121   const AliEMCALGeometry  *EMCALGeometry() ; 
122
123   /*********************************************/
124   /************    TClonesArrays     ***********/
125   /*********************************************/
126   /****   H i t s  ****/
127   TClonesArray*  Hits(void);
128   const AliEMCALHit*    Hit(Int_t index);
129   void MakeHitsArray();
130   /****   S D i g i t s  ****/ 
131   TClonesArray*  SDigits();
132   const AliEMCALDigit*  SDigit(Int_t index);
133   void MakeSDigitsArray();
134   /****  D i g i t s  ****/
135   TClonesArray*   Digits();
136   const AliEMCALDigit *  Digit(Int_t index);
137   void MakeDigitsArray();
138   /****  R e c P o i n t s  ****/
139   TObjArray * ECARecPoints();
140   const AliEMCALRecPoint * ECARecPoint(Int_t index) ;
141   void MakeRecPointsArray();
142   /****   T r a c k S e g m e n t s ****/
143   TClonesArray * TrackSegments();
144   const AliEMCALTrackSegment * TrackSegment(Int_t index);
145   void MakeTrackSegmentsArray();
146   /****  R e c P a r t ic l e s   ****/
147   TClonesArray * RecParticles() ;
148   const AliEMCALRecParticle * RecParticle(Int_t index);
149   void MakeRecParticlesArray();
150
151   /*********************************************/
152   /************    T A S K S      **************/
153   /*********************************************/
154   // 
155   //  AliEMCALSDigitizer*  EMCALSDigitizer(TString name = AliConfig::fgkDefaultEventFolderName);
156   //AliEMCALDigitizer*   EMCALDigitizer()  { return  dynamic_cast<AliEMCALDigitizer*>(Digitizer()) ;}
157
158   AliEMCALClusterizer* Clusterizer ()  {return dynamic_cast<AliEMCALClusterizer*>(Reconstructioner()) ;}
159   Int_t PostClusterizer(TTask* clust){return PostReconstructioner(clust);}
160   Int_t LoadClusterizer(Option_t * opt="") {return LoadReconstructioner(opt);}
161   Int_t WriteClusterizer(Option_t * opt="") {return WriteReconstructioner(opt);}
162
163   AliEMCALPID * PID (){return dynamic_cast<AliEMCALPID*>(PIDTask()) ;}
164   Int_t PostPID(TTask* pid){return PostPIDTask(pid);}
165   Int_t LoadPID(Option_t * opt="") {return LoadPIDTask(opt);}
166   Int_t WritePID(Option_t * opt="") {return WritePIDTask(opt);}
167
168
169   AliEMCALTrackSegmentMaker * TrackSegmentMaker ()  { return dynamic_cast<AliEMCALTrackSegmentMaker *>(Tracker()) ;}
170   Int_t PostTrackSegmentMaker(TTask* segmaker){return PostTracker(segmaker);}
171   Int_t LoadTrackSegmentMaker(Option_t * opt="") {return LoadTracker(opt);}
172   Int_t WriteTrackSegmentMaker(Option_t * opt="") {return WriteTracker(opt);}
173
174   
175   void   SetDebug(Int_t level) {fDebug = level;} // Set debug level
176   void   SetBranchTitle(const TString& btitle);
177   
178   AliEMCALCalibrationDB * CalibrationDB(){return  fcdb; }
179   //void ReadCalibrationDB(const char * name, const char * filename);
180   
181
182   static TString HitsName() { return fgkHitsName ; }   //Name for TClonesArray with hits from one event
183   static TString SDigitsName() { return fgkSDigitsName ;} //Name for TClonesArray 
184   static TString DigitsName() { return fgkDigitsName ;} //Name for TClonesArray 
185   static TString ECARecPointsName() { return fgkECARecPointsName ;} //Name for TClonesArray y 
186   static TString TracksName() { return fgkTracksName ;} //Name for TClonesArray 
187   static TString RecParticlesName() { return fgkRecParticlesName ;} //Name for TClonesArray
188   static TString ECARecPointsBranchName() { return fgkECARecPointsBranchName ;} //Name for branch
189   static TString TrackSegmentsBranchName() { return fgkTrackSegmentsBranchName ;} //Name for branch
190   static TString RecParticlesBranchName() { return fgkRecParticlesBranchName ;} //Name for branch
191
192 protected:
193   TString fBranchTitle;            //Title of the branch
194   Bool_t  fRecParticlesLoaded;     //Flag signing if Reconstructed Particles are loaded
195   Bool_t  fTracksLoaded;           //Flag signing if Tracks are loaded
196   TString fRecParticlesFileOption; //Loading Option for Reconstructed Particles
197   AliEMCALCalibrationDB * fcdb ;       //!
198
199 private:
200
201   Int_t ReadHits();
202   Int_t ReadDigits();
203   Int_t ReadSDigits();
204   Int_t ReadRecPoints();
205   Int_t ReadTracks();
206   Int_t ReadRecParticles();
207
208   static const TString fgkHitsName;//Name for TClonesArray with hits from one event
209   static const TString fgkSDigitsName;//Name for TClonesArray 
210   static const TString fgkDigitsName;//Name for TClonesArray 
211   static const TString fgkECARecPointsName;//Name for TClonesArray 
212   static const TString fgkTracksName;//Name for TClonesArray 
213   static const TString fgkRecParticlesName;//Name for TClonesArray
214
215   static const TString fgkECARecPointsBranchName;//Name for branch
216   static const TString fgkTrackSegmentsBranchName;//Name for branch
217   static const TString fgkRecParticlesBranchName;//Name for branch
218   Int_t  fDebug ;             // Debug level
219  
220
221   
222   ClassDef(AliEMCALLoader,4)  // Algorithm class that provides methods to retrieve objects from a list knowing the index 
223
224 };
225
226 /******************************************************************************/
227 /****************    I N L I N E S     ****************************************/
228 /******************************************************************************/
229
230 inline TClonesArray* AliEMCALLoader::Hits()  
231 {
232  return (TClonesArray*)GetDetectorData(fgkHitsName);
233 }
234 /******************************************************************************/
235
236 inline const AliEMCALHit* AliEMCALLoader::Hit(Int_t index)  
237 {
238   const TClonesArray* tcarr = Hits();
239   if (tcarr)
240     return (const AliEMCALHit*) tcarr->At(index);
241   return 0x0; 
242 }
243 /******************************************************************************/
244
245 inline TClonesArray* AliEMCALLoader::SDigits()
246 {
247    return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
248 }
249 /******************************************************************************/
250
251 inline const AliEMCALDigit*  AliEMCALLoader::SDigit(Int_t index)
252 {
253   const TClonesArray* tcarr = SDigits();
254   if (tcarr)
255     return (const AliEMCALDigit*) tcarr->At(index);
256   return 0x0; 
257 }
258 /******************************************************************************/
259
260 inline TClonesArray* AliEMCALLoader::Digits()
261 {
262  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
263 }
264 /******************************************************************************/
265
266 inline const AliEMCALDigit*  AliEMCALLoader::Digit(Int_t index)
267 {
268   const TClonesArray* tcarr = Digits();
269   if (tcarr)
270     return (const AliEMCALDigit*) tcarr->At(index);
271   return 0x0; 
272 }
273
274 /******************************************************************************/
275
276 inline TObjArray * AliEMCALLoader::ECARecPoints()
277 {
278  return dynamic_cast<TObjArray*>(GetDetectorData(fgkECARecPointsName));
279 }
280
281 /******************************************************************************/
282
283 inline const AliEMCALRecPoint * AliEMCALLoader::ECARecPoint(Int_t index)
284 {
285   TObjArray* tcarr = ECARecPoints();
286   if (tcarr)
287     return dynamic_cast<const AliEMCALRecPoint*>(tcarr->At(index));
288   return 0x0; 
289 }
290
291 /******************************************************************************/
292
293 inline TClonesArray * AliEMCALLoader::TrackSegments()
294 {
295  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
296 }
297 /******************************************************************************/
298
299 inline const AliEMCALTrackSegment * AliEMCALLoader::TrackSegment(Int_t index)
300 {
301   const TClonesArray* tcarr = TrackSegments();
302   if (tcarr)
303     return (const AliEMCALTrackSegment*) tcarr->At(index);
304   return 0x0; 
305 }
306 /******************************************************************************/
307
308 inline TClonesArray * AliEMCALLoader::RecParticles() 
309 {
310  return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName)); 
311 }
312 /******************************************************************************/
313
314 inline const AliEMCALRecParticle* AliEMCALLoader::RecParticle(Int_t index)
315 {
316   TClonesArray* tcarr = RecParticles();
317   if (tcarr)
318     return (const AliEMCALRecParticle*) tcarr->At(index);
319   return 0x0;  
320 }
321
322 #endif // AliEMCALLOADER_H