c53a581693616c6d2aa1756f02172450311250e8
[u/mrichter/AliRoot.git] / ITS / AliITSLoader.cxx
1 #include "AliITSdigit.h"
2 #include "AliITSLoader.h"
3 #include "AliRunLoader.h"
4 #include "AliLog.h"
5
6 ///////////////////////////////////////////////////////////////////////////
7 // Loader for ITS
8 // it manages the I/O for:
9 // raw clusters, primary vertices
10 // V0 and cascade
11 // and tracks propagated to the origin
12 //////////////////////////////////////////////////////////////////////////
13 const TString AliITSLoader::fgkDefaultRawClustersContainerName = "TreeC";
14 const TString AliITSLoader::fgkDefaultBackTracksContainerName = "TreeB";
15 const TString AliITSLoader::fgkDefaultVerticesContainerName = "Vertex";
16 const TString AliITSLoader::fgkDefaultV0ContainerName = "V0";
17 const TString AliITSLoader::fgkDefaultCascadeContainerName = "Cascade";
18 ClassImp(AliITSLoader)
19
20 /**********************************************************************/
21   AliITSLoader::AliITSLoader():AliLoader(){
22   // Default constructor
23   fITSpid = 0;
24   fGeom = 0;
25 }
26 /*********************************************************************/
27 AliITSLoader::AliITSLoader(const Char_t *name,const Char_t *topfoldername):
28 AliLoader(name,topfoldername){
29   //ctor   
30     AliDataLoader* rawClustersDataLoader = new AliDataLoader(
31         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
32         "Raw Clusters");
33     fDataLoaders->Add(rawClustersDataLoader);
34     rawClustersDataLoader->SetEventFolder(fEventFolder);
35     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
36
37     AliDataLoader* backTracksDataLoader =  new AliDataLoader(
38         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
39         "Back Propagated Tracks");
40     fDataLoaders->Add(backTracksDataLoader);
41     backTracksDataLoader->SetEventFolder(fEventFolder);
42     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
43
44     AliDataLoader* vertexDataLoader = new AliDataLoader(
45         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
46         "Primary Vertices","O");
47     fDataLoaders->Add(vertexDataLoader);
48     vertexDataLoader->SetEventFolder(fEventFolder);
49     vertexDataLoader->SetFolder(GetDetectorDataFolder());
50
51     AliDataLoader* v0DataLoader = new AliDataLoader(
52         fDetectorName + ".V0s.root",fgkDefaultV0ContainerName,"V0 Vertices");
53     fDataLoaders->Add(v0DataLoader);
54     v0DataLoader->SetEventFolder(fEventFolder);
55     v0DataLoader->SetFolder(GetDetectorDataFolder());
56
57     AliDataLoader* cascadeDataLoader = new AliDataLoader(
58         fDetectorName + ".Cascades.root",fgkDefaultCascadeContainerName,
59         "Cascades");
60     fDataLoaders->Add(cascadeDataLoader);
61     cascadeDataLoader->SetEventFolder(fEventFolder);
62     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
63     fITSpid=0;
64     fGeom = 0;
65 }
66 /**********************************************************************/
67 AliITSLoader::AliITSLoader(const Char_t *name,TFolder *topfolder): 
68 AliLoader(name,topfolder) {
69   //ctor  
70     AliDataLoader*  rawClustersDataLoader = new AliDataLoader(
71         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
72         "Raw Clusters"); 
73     fDataLoaders->Add(rawClustersDataLoader);
74     rawClustersDataLoader->SetEventFolder(fEventFolder);
75     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
76
77     AliDataLoader*  backTracksDataLoader =  new AliDataLoader(
78         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
79         "Back Propagated Tracks");
80     fDataLoaders->Add(backTracksDataLoader);
81     backTracksDataLoader->SetEventFolder(fEventFolder);
82     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
83
84     AliDataLoader* vertexDataLoader = new AliDataLoader(
85         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
86         "Primary Vertices","O");
87     fDataLoaders->Add(vertexDataLoader);
88     vertexDataLoader->SetEventFolder(fEventFolder);
89     vertexDataLoader->SetFolder(GetDetectorDataFolder());
90
91     AliDataLoader* v0DataLoader = new AliDataLoader(
92         fDetectorName + ".V0.root",fgkDefaultV0ContainerName,"V0 Vertices");
93     fDataLoaders->Add(v0DataLoader);
94     v0DataLoader->SetEventFolder(fEventFolder);
95     v0DataLoader->SetFolder(GetDetectorDataFolder());
96
97     AliDataLoader* cascadeDataLoader = new AliDataLoader(
98         fDetectorName + ".Cascade.root",fgkDefaultCascadeContainerName,
99         "Cascades");
100     fDataLoaders->Add(cascadeDataLoader);
101     cascadeDataLoader->SetEventFolder(fEventFolder);
102     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
103     fITSpid = 0;
104     fGeom = 0;
105 }
106
107 //______________________________________________________________________
108 AliITSLoader::AliITSLoader(const AliITSLoader &ob) : AliLoader(ob) {
109   // Copy constructor
110   // Copies are not allowed. The method is protected to avoid misuse.
111   Error("AliITSLoader","Copy constructor not allowed\n");
112 }
113
114 //______________________________________________________________________
115 AliITSLoader& AliITSLoader::operator=(const AliITSLoader& /* ob */){
116   // Assignment operator
117   // Assignment is not allowed. The method is protected to avoid misuse.
118   Error("= operator","Assignment operator not allowed\n");
119   return *this;
120 }
121
122 /**********************************************************************/
123 AliITSLoader::~AliITSLoader(){
124     //destructor
125     AliDataLoader* dl = 0;
126     UnloadRawClusters();
127     dl = GetRawClLoader();
128     fDataLoaders->Remove(dl);
129
130     UnloadBackTracks();
131     dl = GetBackTracksDataLoader();
132     fDataLoaders->Remove(dl);
133
134     UnloadVertices();
135     dl = GetVertexDataLoader();
136     fDataLoaders->Remove(dl);
137
138     UnloadV0s();
139     dl = GetV0DataLoader();
140     fDataLoaders->Remove(dl);
141
142     UnloadCascades();
143     dl = GetCascadeDataLoader();
144     fDataLoaders->Remove(dl);
145     if(fITSpid)delete fITSpid;
146     if(fGeom)delete fGeom;
147     fGeom = 0;
148 }
149 /*
150 //----------------------------------------------------------------------
151 AliITS* AliITSLoader::GetITS(){
152     // Returns the pointer to the ITS, kept on the file. A short cut metthod
153     // Inputs:
154     //    none.
155     // Outputs:
156     //    none.
157     // Returns:
158     //    Returns a pointer to the ITS, if not found returns 0.
159     AliITS *its;
160
161     if(gAlice){
162         its = dynamic_cast<AliITS*> (gAlice->GetDetector(
163             GetDetectorName().Data()));
164         if(its) return its;
165     } // end if gAlice
166     AliRunLoader *rl=0;
167     rl = GetRunLoader();
168     if(!rl) return 0;
169     AliRun *ar=0;
170     ar = rl->GetAliRun();
171     if(!ar) return 0;
172     its = dynamic_cast<AliITS*> (ar->GetDetector(GetDetectorName().Data()));
173     return its;
174 }
175 //----------------------------------------------------------------------
176 void AliITSLoader::SetupDigits(AliITS *its){
177     // Sets up to store ITS Digits in side AliITS::fDtype TObjArray
178     // Inputs:
179     //    AliITS *its  Pointer to the ITS
180     // Outputs:
181     //    none.
182     // Return:
183     //    none.
184
185     its->SetTreeAddressD(TreeD());
186 }
187 */
188 //----------------------------------------------------------------------
189 void AliITSLoader::SetupDigits(TObjArray *digPerDet,Int_t n,
190                                const Char_t **digclass){
191     // Sets up digPerDet to store ITS Digits.
192     // Inputs:
193     //    TObjArray *digPerDet   A pointer to a TObject Array size>=3.
194     //    Int_t      n           The size of the TObjArray and digclass array
195     //    Char_t     **digclass  Array of digit class names
196     // Outputs:
197     //    TObjArray *digPerDet   Setup and linked to the tree of digits
198     // Return:
199     //    none.
200     Int_t i,m;
201     TClonesArray *cl = 0;
202     TTree *td = 0;
203     TBranch *br = 0;
204     Char_t branch[13];
205     const Char_t *det[3] = {"SPD","SDD","SSD"};
206
207     if(!digPerDet){
208         Error("SetUpDigits","TObject Array digPerDet does not exist");
209         return;
210     } // end if
211     m = digPerDet->GetSize();
212     if(m<n){
213         Error("SetUpDigits","TObject Array digPerDet=%p must have a size"
214               " at least that of n=%d",digPerDet,n);
215     } // end if
216     if(m<3){
217         Error("SetUpDigits","TObject Array digPerDet=%p must have a size >2",
218               digPerDet);
219         return;
220     } // end if
221     td = TreeD();
222     for(i=0;i<n;i++){
223         if(digPerDet->At(i)==0){ // set up TClones Array
224             digPerDet->AddAt(new TClonesArray(digclass[i],1000),i);
225             if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
226             else     sprintf(branch,"ITSDigits%d",i+1);
227             br = td->GetBranch(branch);
228             br->SetAddress(&((*digPerDet)[i]));
229             continue; // do next one.
230         } // end if
231         cl =  dynamic_cast<TClonesArray*> (digPerDet->At(i));
232         if(!cl && digPerDet->At(i)!=0){  // not a TClonesArray
233             Error("SetUpDigits","TObject Array digPerDet-At(%d)=%p must be "
234                   "zeroed or filled with TClonesArrays",i,digPerDet);
235             return;
236         } // end if
237         if(!(cl->GetClass()->GetBaseClass(AliITSdigit::Class()))){
238             Error("SetUPDigits","TClones array at digPerDet[%d}=%p must be"
239                   "derived from AliITSdigit",i,digPerDet->At(i));
240         } // end if
241         cl->Clear();
242         if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
243         else     sprintf(branch,"ITSDigits%d",i+1);
244         br = td->GetBranch(branch);
245         br->SetAddress(&((*digPerDet)[i]));
246         continue;
247     } // end for i
248 }
249 //---------------------------------------------------------------------
250 AliITSdigit * AliITSLoader::GetDigit(TObjArray *digPerDet,Int_t module,
251                                      Int_t digit){
252     // Gets the digit for for a specific detector type and module.
253     // To be used in conjustion with Setupdigits(AliITS *its).
254     // Inputs:
255     //   TObjArray *digPereDet    Pointer to the Array of digits
256     //   Int_t      module        Module number
257     //   Int_t      digit         Digit number
258     // Outputs:
259     //   none.
260     // Return:
261     //   returns the pointer to the digit. if zero then last digit for that
262     //   module.
263
264     if(digPerDet==0){
265         Error("GetDigit","digPerDet=%p, module=%d, digit=%d",
266               digPerDet,module,digit);
267         return 0;
268     } // end if
269     return 0;
270 }
271 /*
272 //---------------------------------------------------------------------
273 AliITSdigit * AliITSLoader::GetDigit(AliITS *its,Int_t module,Int_t digit){
274     // Gets the digit for for a specific detector type and module.
275     // To be used in conjustion with Setupdigits(AliITS *its).
276     // Inputs:
277     //   AliITS *its    Pointer to the ITS
278     //   Int_t  module  Module number
279     //   Int_t digit    Digit number
280     // Outputs:
281     //   none.
282     // Return:
283     //   returns the pointer to the digit. if zero then last digit for that
284     //   module.
285     //AliITSDetType *idtype;
286     AliITSgeom *geom = its->GetITSgeom();
287     Int_t idet = geom->GetModuleType(module);
288     TClonesArray *digits;
289  
290     its->ResetDigits();
291     TreeD()->GetEvent(module);
292     digits = its->DigitsAddress(idet);
293     if(digit>-1 && digit<digits->GetEntriesFast()){ // if in range.
294         return (AliITSdigit*) digits->At(digit);
295     } // end if
296     return 0;
297 }
298 */
299 //----------------------------------------------------------------------
300 void AliITSLoader::MakeTree(Option_t *opt){
301     // invokes AliLoader::MakeTree + specific ITS tree(s)
302     // Valid options: H,S,D,R,T and C (C=raw clusters)
303     AliLoader::MakeTree(opt);
304     const char *oC = strstr(opt,"C");
305     if (oC) MakeRawClustersContainer();
306
307     const char *oB = strstr(opt,"B");
308     if (oB) MakeBackTracksContainer();
309
310     const char *oV0 = strstr(opt,"V0");
311     if (oV0) MakeV0Container();
312
313     const char *oX = strstr(opt,"X");
314     if (oX) MakeCascadeContainer();
315 }
316
317 //----------------------------------------------------------------------
318 AliITSgeom* AliITSLoader::GetITSgeom(Bool_t force) {
319   // retrieves the ITS geometry from file
320   if(fGeom && !force)return fGeom;
321   if(fGeom && force){
322     delete fGeom;
323     fGeom = 0;
324   }
325   AliRunLoader *runLoader = GetRunLoader();
326   if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
327   if (!runLoader->GetAliRun()) {
328     Error("GetITSgeom", "couldn't get AliRun object");
329     return NULL;
330   }
331   
332   TDirectory *curdir = gDirectory;
333   runLoader->CdGAFile();
334   fGeom = (AliITSgeom*)gDirectory->Get("AliITSgeom");
335   curdir->cd();
336   if(!fGeom){
337     Error("GetITSgeom","no ITS geometry available");
338     return NULL;
339   }
340   AliWarning("AliITSgeom object has been fetched from galice.root file");
341   return fGeom;
342 }
343 //______________________________________________________________________
344 void AliITSLoader::SetITSgeom(AliITSgeom *geom){
345     // Replaces the AliITSgeom object read from file with the one
346     // given.
347     // Inputs:
348     //   AliITSgeom *geom   The AliITSgeom object to replace the one
349     //                      read from the file
350     // Outputs:
351     //   none.
352     // Return:
353     //   none.
354
355     if(fGeom==geom) return; // Same do nothing
356     if(fGeom) {
357         delete fGeom;
358         fGeom=0;
359     }// end if
360     fGeom=geom;
361 }
362