Enlarging array
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALLoader.h
CommitLineData
88cb7938 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"
23class TString ;
24class TParticle ;
25class TTask ;
26
27// --- Standard library ---
88cb7938 28
29// --- AliRoot header files ---
30
31#include "AliRun.h"
88cb7938 32#include "AliRunLoader.h"
88cb7938 33#include "AliEMCALDigit.h"
d64c959b 34#include "AliEMCALRecPoint.h"
88cb7938 35#include "AliEMCALTrackSegment.h"
88cb7938 36#include "AliEMCALClusterizer.h"
d64c959b 37#include "AliEMCALTrackSegmentMaker.h"
88cb7938 38#include "AliEMCALPID.h"
d64c959b 39class AliLoader ;
40class AliEMCAL ;
41class AliEMCALHit ;
42class AliEMCALRecParticle ;
43class AliEMCALGeometry ;
44class AliEMCALDigitizer ;
45class AliEMCALSDigitizer ;
88cb7938 46class AliEMCALCalibrationDB ;
47
48
49//
50
51class AliEMCALLoader : public AliLoader {
52
53 public:
54
55 AliEMCALLoader();
39200c71 56 AliEMCALLoader(const AliEMCALLoader & obj):AliLoader(obj){}
88cb7938 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
d64c959b 62 const AliEMCALLoader & operator = (const AliEMCALLoader & ) {return *this;}
88cb7938 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;}
fdebddeb 99
88cb7938 100/*******************************************************************/
101/*******************************************************************/
102/*******************************************************************/
103
104 TObject** HitsRef(){return GetDetectorDataRef(Hits());}
105 TObject** SDigitsRef(){return GetDetectorDataRef(SDigits());}
106 TObject** DigitsRef(){return GetDetectorDataRef(Digits());}
88cb7938 107 TObject** ECARecPointsRef(){return GetDetectorDataRef(ECARecPoints());}
88cb7938 108 TObject** TracksRef(){return GetDetectorDataRef(TrackSegments());}
109 TObject** RecParticlesRef(){return GetDetectorDataRef(RecParticles());}
fdebddeb 110
88cb7938 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() ;
88cb7938 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 ****/
88cb7938 139 TObjArray * ECARecPoints();
70a93198 140 const AliEMCALRecPoint * ECARecPoint(Int_t index) ;
88cb7938 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
d64c959b 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
fdebddeb 185 static TString ECARecPointsName() { return fgkECARecPointsName ;} //Name for TClonesArray y
d64c959b 186 static TString TracksName() { return fgkTracksName ;} //Name for TClonesArray
187 static TString RecParticlesName() { return fgkRecParticlesName ;} //Name for TClonesArray
d64c959b 188 static TString ECARecPointsBranchName() { return fgkECARecPointsBranchName ;} //Name for branch
d64c959b 189 static TString TrackSegmentsBranchName() { return fgkTrackSegmentsBranchName ;} //Name for branch
190 static TString RecParticlesBranchName() { return fgkRecParticlesBranchName ;} //Name for branch
191
88cb7938 192protected:
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
199private:
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();
88cb7938 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
88cb7938 211 static const TString fgkECARecPointsName;//Name for TClonesArray
88cb7938 212 static const TString fgkTracksName;//Name for TClonesArray
213 static const TString fgkRecParticlesName;//Name for TClonesArray
214
88cb7938 215 static const TString fgkECARecPointsBranchName;//Name for branch
88cb7938 216 static const TString fgkTrackSegmentsBranchName;//Name for branch
217 static const TString fgkRecParticlesBranchName;//Name for branch
d64c959b 218 Int_t fDebug ; // Debug level
219
220
88cb7938 221
75cc8a15 222 ClassDef(AliEMCALLoader,4) // Algorithm class that provides methods to retrieve objects from a list knowing the index
88cb7938 223
224};
225
226/******************************************************************************/
227/**************** I N L I N E S ****************************************/
228/******************************************************************************/
229
230inline TClonesArray* AliEMCALLoader::Hits()
231{
232 return (TClonesArray*)GetDetectorData(fgkHitsName);
233}
234/******************************************************************************/
235
236inline 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
245inline TClonesArray* AliEMCALLoader::SDigits()
246{
247 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkSDigitsName));
248}
249/******************************************************************************/
250
251inline 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
260inline TClonesArray* AliEMCALLoader::Digits()
261{
262 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkDigitsName));
263}
264/******************************************************************************/
265
266inline 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
88cb7938 276inline TObjArray * AliEMCALLoader::ECARecPoints()
277{
278 return dynamic_cast<TObjArray*>(GetDetectorData(fgkECARecPointsName));
279}
280
281/******************************************************************************/
282
70a93198 283inline const AliEMCALRecPoint * AliEMCALLoader::ECARecPoint(Int_t index)
88cb7938 284{
285 TObjArray* tcarr = ECARecPoints();
286 if (tcarr)
70a93198 287 return dynamic_cast<const AliEMCALRecPoint*>(tcarr->At(index));
88cb7938 288 return 0x0;
289}
290
291/******************************************************************************/
292
88cb7938 293inline TClonesArray * AliEMCALLoader::TrackSegments()
294{
295 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkTracksName));
296}
297/******************************************************************************/
298
299inline 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
308inline TClonesArray * AliEMCALLoader::RecParticles()
309{
310 return dynamic_cast<TClonesArray*>(GetDetectorData(fgkRecParticlesName));
311}
312/******************************************************************************/
313
314inline 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}
88cb7938 321
322#endif // AliEMCALLOADER_H