Most of these updates are related to the offline software needed for the pixel trigge...
[u/mrichter/AliRoot.git] / ITS / AliITSLoader.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 #include <TClonesArray.h>
19 #include <TClass.h>
20 #include <TGeoManager.h>
21
22 #include "AliITSdigit.h"
23 #include "AliITSLoader.h"
24 #include "AliRunLoader.h"
25 #include "AliObjectLoader.h"
26 #include "AliITSInitGeometry.h"
27 #include "AliLog.h"
28
29 ///////////////////////////////////////////////////////////////////////////
30 // Loader for ITS
31 // it manages the I/O for:
32 // raw clusters, primary vertices
33 // V0 and cascade
34 // and tracks propagated to the origin
35 //////////////////////////////////////////////////////////////////////////
36 const TString AliITSLoader::fgkDefaultRawClustersContainerName = "TreeC";
37 const TString AliITSLoader::fgkDefaultBackTracksContainerName = "TreeB";
38 const TString AliITSLoader::fgkDefaultVerticesContainerName = "Vertex";
39 const TString AliITSLoader::fgkDefaultV0ContainerName = "V0";
40 const TString AliITSLoader::fgkDefaultCascadeContainerName = "Cascade";
41 ClassImp(AliITSLoader)
42
43 /**********************************************************************/
44   AliITSLoader::AliITSLoader():AliLoader(),
45 fITSpid(0),
46 fGeom(0){
47   // Default constructor
48 }
49 /*********************************************************************/
50 AliITSLoader::AliITSLoader(const Char_t *name,const Char_t *topfoldername):
51 AliLoader(name,topfoldername),
52 fITSpid(0),
53 fGeom(0){
54   //Constructor   
55     AliDataLoader* rawClustersDataLoader = new AliDataLoader(
56         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
57         "Raw Clusters");
58     fDataLoaders->Add(rawClustersDataLoader);
59     rawClustersDataLoader->SetEventFolder(fEventFolder);
60     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
61
62     AliDataLoader* backTracksDataLoader =  new AliDataLoader(
63         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
64         "Back Propagated Tracks");
65     fDataLoaders->Add(backTracksDataLoader);
66     backTracksDataLoader->SetEventFolder(fEventFolder);
67     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
68
69     AliDataLoader* vertexDataLoader = new AliDataLoader(
70         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
71         "Primary Vertices","O");
72     fDataLoaders->Add(vertexDataLoader);
73     vertexDataLoader->SetEventFolder(fEventFolder);
74     vertexDataLoader->SetFolder(GetDetectorDataFolder());
75
76     AliDataLoader* v0DataLoader = new AliDataLoader(
77         fDetectorName + ".V0s.root",fgkDefaultV0ContainerName,"V0 Vertices");
78     fDataLoaders->Add(v0DataLoader);
79     v0DataLoader->SetEventFolder(fEventFolder);
80     v0DataLoader->SetFolder(GetDetectorDataFolder());
81
82     AliDataLoader* cascadeDataLoader = new AliDataLoader(
83         fDetectorName + ".Cascades.root",fgkDefaultCascadeContainerName,
84         "Cascades");
85     fDataLoaders->Add(cascadeDataLoader);
86     cascadeDataLoader->SetEventFolder(fEventFolder);
87     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
88     
89     // 2009/03/03: addition of object loader for fast-or signals (Henrik Tydesjo)
90     AliDataLoader* dl = GetDigitsDataLoader();
91     AliBaseLoader* foLoader = new AliObjectLoader("AliITSFOSignalsSPD",dl);
92     dl->AddBaseLoader(foLoader);
93     
94 }
95 /**********************************************************************/
96 AliITSLoader::AliITSLoader(const Char_t *name,TFolder *topfolder): 
97   AliLoader(name,topfolder),
98 fITSpid(0),
99 fGeom(0){
100   //ctor  
101     AliDataLoader*  rawClustersDataLoader = new AliDataLoader(
102         fDetectorName + ".RawCl.root",fgkDefaultRawClustersContainerName,
103         "Raw Clusters"); 
104     fDataLoaders->Add(rawClustersDataLoader);
105     rawClustersDataLoader->SetEventFolder(fEventFolder);
106     rawClustersDataLoader->SetFolder(GetDetectorDataFolder());
107
108     AliDataLoader*  backTracksDataLoader =  new AliDataLoader(
109         fDetectorName + ".BackTracks.root",fgkDefaultBackTracksContainerName,
110         "Back Propagated Tracks");
111     fDataLoaders->Add(backTracksDataLoader);
112     backTracksDataLoader->SetEventFolder(fEventFolder);
113     backTracksDataLoader->SetFolder(GetDetectorDataFolder());
114
115     AliDataLoader* vertexDataLoader = new AliDataLoader(
116         fDetectorName + ".Vertex.root",fgkDefaultVerticesContainerName,
117         "Primary Vertices","O");
118     fDataLoaders->Add(vertexDataLoader);
119     vertexDataLoader->SetEventFolder(fEventFolder);
120     vertexDataLoader->SetFolder(GetDetectorDataFolder());
121
122     AliDataLoader* v0DataLoader = new AliDataLoader(
123         fDetectorName + ".V0.root",fgkDefaultV0ContainerName,"V0 Vertices");
124     fDataLoaders->Add(v0DataLoader);
125     v0DataLoader->SetEventFolder(fEventFolder);
126     v0DataLoader->SetFolder(GetDetectorDataFolder());
127
128     AliDataLoader* cascadeDataLoader = new AliDataLoader(
129         fDetectorName + ".Cascade.root",fgkDefaultCascadeContainerName,
130         "Cascades");
131     fDataLoaders->Add(cascadeDataLoader);
132     cascadeDataLoader->SetEventFolder(fEventFolder);
133     cascadeDataLoader->SetFolder(GetDetectorDataFolder());
134     
135     // 2009/03/03: addition of object loader for fast-or signals (Henrik Tydesjo)
136     AliDataLoader* dl = GetDigitsDataLoader();
137     AliBaseLoader* foLoader = new AliObjectLoader("AliITSFOSignalsSPD",dl);
138     dl->AddBaseLoader(foLoader);
139
140     
141 }
142
143
144 /**********************************************************************/
145 AliITSLoader::~AliITSLoader(){
146     //destructor
147     AliDataLoader* dl = 0;
148     UnloadRawClusters();
149     dl = GetRawClLoader();
150     fDataLoaders->Remove(dl);
151
152     UnloadBackTracks();
153     dl = GetBackTracksDataLoader();
154     fDataLoaders->Remove(dl);
155
156     UnloadVertices();
157     dl = GetVertexDataLoader();
158     fDataLoaders->Remove(dl);
159
160     UnloadV0s();
161     dl = GetV0DataLoader();
162     fDataLoaders->Remove(dl);
163
164     UnloadCascades();
165     dl = GetCascadeDataLoader();
166     fDataLoaders->Remove(dl);
167   
168     if(fGeom)delete fGeom;
169     fGeom = 0;
170 }
171 /*
172 //----------------------------------------------------------------------
173 AliITS* AliITSLoader::GetITS(){
174     // Returns the pointer to the ITS, kept on the file. A short cut metthod
175     // Inputs:
176     //    none.
177     // Outputs:
178     //    none.
179     // Returns:
180     //    Returns a pointer to the ITS, if not found returns 0.
181     AliITS *its;
182
183     if(gAlice){
184         its = dynamic_cast<AliITS*> (gAlice->GetDetector(
185             GetDetectorName().Data()));
186         if(its) return its;
187     } // end if gAlice
188     AliRunLoader *rl=0;
189     rl = GetRunLoader();
190     if(!rl) return 0;
191     AliRun *ar=0;
192     ar = rl->GetAliRun();
193     if(!ar) return 0;
194     its = dynamic_cast<AliITS*> (ar->GetDetector(GetDetectorName().Data()));
195     return its;
196 }
197 //----------------------------------------------------------------------
198 void AliITSLoader::SetupDigits(AliITS *its){
199     // Sets up to store ITS Digits in side AliITS::fDtype TObjArray
200     // Inputs:
201     //    AliITS *its  Pointer to the ITS
202     // Outputs:
203     //    none.
204     // Return:
205     //    none.
206
207     its->SetTreeAddressD(TreeD());
208 }
209 */
210 //----------------------------------------------------------------------
211 void AliITSLoader::SetupDigits(TObjArray *digPerDet,Int_t n,
212                                const Char_t **digclass){
213     // Sets up digPerDet to store ITS Digits.
214     // Inputs:
215     //    TObjArray *digPerDet   A pointer to a TObject Array size>=3.
216     //    Int_t      n           The size of the TObjArray and digclass array
217     //    Char_t     **digclass  Array of digit class names
218     // Outputs:
219     //    TObjArray *digPerDet   Setup and linked to the tree of digits
220     // Return:
221     //    none.
222     Int_t i,m;
223     TClonesArray *cl = 0;
224     TTree *td = 0;
225     TBranch *br = 0;
226     Char_t branch[13];
227     const Char_t *det[3] = {"SPD","SDD","SSD"};
228
229     if(!digPerDet){
230         Error("SetUpDigits","TObject Array digPerDet does not exist");
231         return;
232     } // end if
233     m = digPerDet->GetSize();
234     if(m<n){
235         Error("SetUpDigits","TObject Array digPerDet=%p must have a size"
236               " at least that of n=%d",digPerDet,n);
237     } // end if
238     if(m<3){
239         Error("SetUpDigits","TObject Array digPerDet=%p must have a size >2",
240               digPerDet);
241         return;
242     } // end if
243     td = TreeD();
244     for(i=0;i<n;i++){
245         if(digPerDet->At(i)==0){ // set up TClones Array
246             digPerDet->AddAt(new TClonesArray(digclass[i],1000),i);
247             if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
248             else     sprintf(branch,"ITSDigits%d",i+1);
249             br = td->GetBranch(branch);
250             br->SetAddress(&((*digPerDet)[i]));
251             continue; // do next one.
252         } // end if
253         cl =  dynamic_cast<TClonesArray*> (digPerDet->At(i));
254         if(!cl && digPerDet->At(i)!=0){  // not a TClonesArray
255             Error("SetUpDigits","TObject Array digPerDet-At(%d)=%p must be "
256                   "zeroed or filled with TClonesArrays",i,digPerDet);
257             return;
258         } // end if
259         if(!(cl->GetClass()->GetBaseClass(AliITSdigit::Class()))){
260             Error("SetUPDigits","TClones array at digPerDet[%d}=%p must be"
261                   "derived from AliITSdigit",i,digPerDet->At(i));
262         } // end if
263         cl->Clear();
264         if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
265         else     sprintf(branch,"ITSDigits%d",i+1);
266         br = td->GetBranch(branch);
267         br->SetAddress(&((*digPerDet)[i]));
268         continue;
269     } // end for i
270 }
271 //---------------------------------------------------------------------
272 AliITSdigit * AliITSLoader::GetDigit(TObjArray *digPerDet,Int_t module,
273                                      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     //   TObjArray *digPereDet    Pointer to the Array of digits
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
286     if(digPerDet==0){
287         Error("GetDigit","digPerDet=%p, module=%d, digit=%d",
288               digPerDet,module,digit);
289         return 0;
290     } // end if
291     return 0;
292 }
293 /*
294 //---------------------------------------------------------------------
295 AliITSdigit * AliITSLoader::GetDigit(AliITS *its,Int_t module,Int_t digit){
296     // Gets the digit for for a specific detector type and module.
297     // To be used in conjustion with Setupdigits(AliITS *its).
298     // Inputs:
299     //   AliITS *its    Pointer to the ITS
300     //   Int_t  module  Module number
301     //   Int_t digit    Digit number
302     // Outputs:
303     //   none.
304     // Return:
305     //   returns the pointer to the digit. if zero then last digit for that
306     //   module.
307     //AliITSDetType *idtype;
308     AliITSgeom *geom = its->GetITSgeom();
309     Int_t idet = geom->GetModuleType(module);
310     TClonesArray *digits;
311  
312     its->ResetDigits();
313     TreeD()->GetEvent(module);
314     digits = its->DigitsAddress(idet);
315     if(digit>-1 && digit<digits->GetEntriesFast()){ // if in range.
316         return (AliITSdigit*) digits->At(digit);
317     } // end if
318     return 0;
319 }
320 */
321 //----------------------------------------------------------------------
322 void AliITSLoader::MakeTree(Option_t *opt){
323     // invokes AliLoader::MakeTree + specific ITS tree(s)
324     // Valid options: H,S,D,R,T and C (C=raw clusters)
325     AliLoader::MakeTree(opt);
326     const char *oC = strstr(opt,"C");
327     if (oC) MakeRawClustersContainer();
328
329     const char *oB = strstr(opt,"B");
330     if (oB) MakeBackTracksContainer();
331
332     const char *oV0 = strstr(opt,"V0");
333     if (oV0) MakeV0Container();
334
335     const char *oX = strstr(opt,"X");
336     if (oX) MakeCascadeContainer();
337 }
338
339 //----------------------------------------------------------------------
340 AliITSgeom* AliITSLoader::GetITSgeom(Bool_t force) {
341   // retrieves the ITS geometry from file
342   if(fGeom && !force)return fGeom;
343   if(fGeom && force){
344     delete fGeom;
345     fGeom = 0;
346   }
347   if(!gGeoManager){
348     AliError("gGeoManager is a null pointer - ITS geometry not built");
349     return fGeom;
350   }
351   AliITSInitGeometry initgeom;
352   fGeom = initgeom.CreateAliITSgeom();
353   AliDebug(1,"AliITSgeom object has been initialized from TGeo\n");
354   AliInfo(Form("Geometry name: %s",(initgeom.GetGeometryName()).Data()));
355   return fGeom;
356 }
357 //______________________________________________________________________
358 void AliITSLoader::SetITSgeom(AliITSgeom *geom){
359     // Replaces the AliITSgeom object read from file with the one
360     // given.
361     // Inputs:
362     //   AliITSgeom *geom   The AliITSgeom object to replace the one
363     //                      read from the file
364     // Outputs:
365     //   none.
366     // Return:
367     //   none.
368
369     if(fGeom==geom) return; // Same do nothing
370     if(fGeom) {
371         delete fGeom;
372         fGeom=0;
373     }// end if
374     fGeom=geom;
375 }
376 //______________________________________________________________________
377 AliBaseLoader* AliITSLoader::GetFOSignalsLoader() {
378   // return pointer to FO signals base loader
379   AliDataLoader* dl = GetDigitsDataLoader();
380   if (!dl) {
381     AliError("Data loader is NULL.");
382     return NULL;
383   }
384   return dl->GetBaseLoader("AliITSFOSignalsSPD");
385 }
386