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