Possibility to use loadlibs.C on Solaris x86
[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(fGeom)delete fGeom;
146     fGeom = 0;
147 }
148 /*
149 //----------------------------------------------------------------------
150 AliITS* AliITSLoader::GetITS(){
151     // Returns the pointer to the ITS, kept on the file. A short cut metthod
152     // Inputs:
153     //    none.
154     // Outputs:
155     //    none.
156     // Returns:
157     //    Returns a pointer to the ITS, if not found returns 0.
158     AliITS *its;
159
160     if(gAlice){
161         its = dynamic_cast<AliITS*> (gAlice->GetDetector(
162             GetDetectorName().Data()));
163         if(its) return its;
164     } // end if gAlice
165     AliRunLoader *rl=0;
166     rl = GetRunLoader();
167     if(!rl) return 0;
168     AliRun *ar=0;
169     ar = rl->GetAliRun();
170     if(!ar) return 0;
171     its = dynamic_cast<AliITS*> (ar->GetDetector(GetDetectorName().Data()));
172     return its;
173 }
174 //----------------------------------------------------------------------
175 void AliITSLoader::SetupDigits(AliITS *its){
176     // Sets up to store ITS Digits in side AliITS::fDtype TObjArray
177     // Inputs:
178     //    AliITS *its  Pointer to the ITS
179     // Outputs:
180     //    none.
181     // Return:
182     //    none.
183
184     its->SetTreeAddressD(TreeD());
185 }
186 */
187 //----------------------------------------------------------------------
188 void AliITSLoader::SetupDigits(TObjArray *digPerDet,Int_t n,
189                                const Char_t **digclass){
190     // Sets up digPerDet to store ITS Digits.
191     // Inputs:
192     //    TObjArray *digPerDet   A pointer to a TObject Array size>=3.
193     //    Int_t      n           The size of the TObjArray and digclass array
194     //    Char_t     **digclass  Array of digit class names
195     // Outputs:
196     //    TObjArray *digPerDet   Setup and linked to the tree of digits
197     // Return:
198     //    none.
199     Int_t i,m;
200     TClonesArray *cl = 0;
201     TTree *td = 0;
202     TBranch *br = 0;
203     Char_t branch[13];
204     const Char_t *det[3] = {"SPD","SDD","SSD"};
205
206     if(!digPerDet){
207         Error("SetUpDigits","TObject Array digPerDet does not exist");
208         return;
209     } // end if
210     m = digPerDet->GetSize();
211     if(m<n){
212         Error("SetUpDigits","TObject Array digPerDet=%p must have a size"
213               " at least that of n=%d",digPerDet,n);
214     } // end if
215     if(m<3){
216         Error("SetUpDigits","TObject Array digPerDet=%p must have a size >2",
217               digPerDet);
218         return;
219     } // end if
220     td = TreeD();
221     for(i=0;i<n;i++){
222         if(digPerDet->At(i)==0){ // set up TClones Array
223             digPerDet->AddAt(new TClonesArray(digclass[i],1000),i);
224             if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
225             else     sprintf(branch,"ITSDigits%d",i+1);
226             br = td->GetBranch(branch);
227             br->SetAddress(&((*digPerDet)[i]));
228             continue; // do next one.
229         } // end if
230         cl =  dynamic_cast<TClonesArray*> (digPerDet->At(i));
231         if(!cl && digPerDet->At(i)!=0){  // not a TClonesArray
232             Error("SetUpDigits","TObject Array digPerDet-At(%d)=%p must be "
233                   "zeroed or filled with TClonesArrays",i,digPerDet);
234             return;
235         } // end if
236         if(!(cl->GetClass()->GetBaseClass(AliITSdigit::Class()))){
237             Error("SetUPDigits","TClones array at digPerDet[%d}=%p must be"
238                   "derived from AliITSdigit",i,digPerDet->At(i));
239         } // end if
240         cl->Clear();
241         if(n==3) sprintf(branch,"ITSDigits%s",det[i]);
242         else     sprintf(branch,"ITSDigits%d",i+1);
243         br = td->GetBranch(branch);
244         br->SetAddress(&((*digPerDet)[i]));
245         continue;
246     } // end for i
247 }
248 //---------------------------------------------------------------------
249 AliITSdigit * AliITSLoader::GetDigit(TObjArray *digPerDet,Int_t module,
250                                      Int_t digit){
251     // Gets the digit for for a specific detector type and module.
252     // To be used in conjustion with Setupdigits(AliITS *its).
253     // Inputs:
254     //   TObjArray *digPereDet    Pointer to the Array of digits
255     //   Int_t      module        Module number
256     //   Int_t      digit         Digit number
257     // Outputs:
258     //   none.
259     // Return:
260     //   returns the pointer to the digit. if zero then last digit for that
261     //   module.
262
263     if(digPerDet==0){
264         Error("GetDigit","digPerDet=%p, module=%d, digit=%d",
265               digPerDet,module,digit);
266         return 0;
267     } // end if
268     return 0;
269 }
270 /*
271 //---------------------------------------------------------------------
272 AliITSdigit * AliITSLoader::GetDigit(AliITS *its,Int_t module,Int_t digit){
273     // Gets the digit for for a specific detector type and module.
274     // To be used in conjustion with Setupdigits(AliITS *its).
275     // Inputs:
276     //   AliITS *its    Pointer to the ITS
277     //   Int_t  module  Module number
278     //   Int_t digit    Digit number
279     // Outputs:
280     //   none.
281     // Return:
282     //   returns the pointer to the digit. if zero then last digit for that
283     //   module.
284     //AliITSDetType *idtype;
285     AliITSgeom *geom = its->GetITSgeom();
286     Int_t idet = geom->GetModuleType(module);
287     TClonesArray *digits;
288  
289     its->ResetDigits();
290     TreeD()->GetEvent(module);
291     digits = its->DigitsAddress(idet);
292     if(digit>-1 && digit<digits->GetEntriesFast()){ // if in range.
293         return (AliITSdigit*) digits->At(digit);
294     } // end if
295     return 0;
296 }
297 */
298 //----------------------------------------------------------------------
299 void AliITSLoader::MakeTree(Option_t *opt){
300     // invokes AliLoader::MakeTree + specific ITS tree(s)
301     // Valid options: H,S,D,R,T and C (C=raw clusters)
302     AliLoader::MakeTree(opt);
303     const char *oC = strstr(opt,"C");
304     if (oC) MakeRawClustersContainer();
305
306     const char *oB = strstr(opt,"B");
307     if (oB) MakeBackTracksContainer();
308
309     const char *oV0 = strstr(opt,"V0");
310     if (oV0) MakeV0Container();
311
312     const char *oX = strstr(opt,"X");
313     if (oX) MakeCascadeContainer();
314 }
315
316 //----------------------------------------------------------------------
317 AliITSgeom* AliITSLoader::GetITSgeom(Bool_t force) {
318   // retrieves the ITS geometry from file
319   if(fGeom && !force)return fGeom;
320   if(fGeom && force){
321     delete fGeom;
322     fGeom = 0;
323   }
324   AliRunLoader *runLoader = GetRunLoader();
325   if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
326   if (!runLoader->GetAliRun()) {
327     Error("GetITSgeom", "couldn't get AliRun object");
328     return NULL;
329   }
330   
331   TDirectory *curdir = gDirectory;
332   runLoader->CdGAFile();
333   fGeom = (AliITSgeom*)gDirectory->Get("AliITSgeom");
334   curdir->cd();
335   if(!fGeom){
336     Error("GetITSgeom","no ITS geometry available");
337     return NULL;
338   }
339   AliWarning("AliITSgeom object has been fetched from galice.root file");
340   return fGeom;
341 }
342 //______________________________________________________________________
343 void AliITSLoader::SetITSgeom(AliITSgeom *geom){
344     // Replaces the AliITSgeom object read from file with the one
345     // given.
346     // Inputs:
347     //   AliITSgeom *geom   The AliITSgeom object to replace the one
348     //                      read from the file
349     // Outputs:
350     //   none.
351     // Return:
352     //   none.
353
354     if(fGeom==geom) return; // Same do nothing
355     if(fGeom) {
356         delete fGeom;
357         fGeom=0;
358     }// end if
359     fGeom=geom;
360 }
361