can now read from HPSS
[u/mrichter/AliRoot.git] / PHOS / AliPHOSIndexToObject.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 //_________________________________________________________________________
19 //  A singleton. This class should be used on the analysiz stage to get 
20 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
21 //  instead of direct reading them from galice.root file. This container 
22 //  ensures, that one reads Digits, made of these particular digits RecPoints, 
23 //  made of these particlar RecPoints TrackSegments and RecParticles, what is
24 //  not trivial if there are several identical branches, but produced with
25 //  different set of parameters. 
26 //
27 //  An example of use (see as well class AliPHOSAnalyser):
28 //  AliPHOSIndexToObject * please = AliPHOSIndexToObject::GetInstance("galice.root","RecParticles","") ;
29 //  for(Int_t irecp = 0; irecp < please->GimeNRecParticles() ; irecp++)
30 //     AliPHOSRecParticle * part = please->GimeRecParticle(1) ;
31 //     ................
32 //  please->GetEvent(event) ;    // reads new event from galice.root
33 //                  
34 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
35 //*--         Complitely redesigned by Dmitri Peressounko March 2001  
36 //////////////////////////////////////////////////////////////////////////////
37
38
39 // --- ROOT system ---
40
41 #include "TFile.h"
42 #include "TTree.h"
43 #include "TROOT.h"
44 #include "TObjString.h"
45
46 // --- Standard library ---
47 #include <iostream.h>
48
49 // --- AliRoot header files ---
50
51 #include "AliRun.h"
52 #include "AliPHOSIndexToObject.h"
53 #include "AliPHOSDigitizer.h"
54 #include "AliPHOSClusterizer.h"
55 #include "AliPHOSTrackSegmentMaker.h"
56 #include "AliPHOSPID.h" 
57
58 ClassImp(AliPHOSIndexToObject)
59   
60   AliPHOSIndexToObject * AliPHOSIndexToObject::fgObjGetter = 0 ; 
61
62 //____________________________________________________________________________ 
63 AliPHOSIndexToObject::AliPHOSIndexToObject(char* headerFile,char* branch,char* branchTitle )
64 {
65   //Initiate all lists
66   fEvent = 0 ;
67
68   fDigits = new TClonesArray("AliPHOSDigit",100) ;
69   fEmcRecPoints = new TObjArray(100) ;
70   fCpvRecPoints = new TObjArray(100) ;
71   fTS = new TClonesArray("AliPHOSTrackSegment",100) ;
72   fRecParticles = new TClonesArray("AliPHOSRecParticle",100) ;
73   fPrimaries = new TObjArray(1) ;
74
75   fDigitizer = 0 ;
76   fClusterizer = 0 ;
77   fTSMaker = 0 ;
78   fPID = 0 ;
79
80   //open headers file
81   fHeaderFile = headerFile ;
82   TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ;
83
84   if(file == 0){
85     if(fHeaderFile.Contains("rfio")) // if we read file using HPSS
86       file =    TFile::Open(fHeaderFile.Data(),"update") ;
87     else
88       file = new TFile(fHeaderFile.Data(),"update") ;
89     gAlice = (AliRun *) file->Get("gAlice") ;
90   }
91
92   fMaxEvent = (Int_t) gAlice->TreeE()->GetEntries() ;
93
94   char * dummyfile = 0 ;
95
96   gAlice->GetEvent(fEvent) ;
97
98   Bool_t isRead = kFALSE;
99   //now read branches 
100   if((strcmp(branch,"PHOSRP")==0) || (strcmp(branch,"PHOSPID")==0)){
101     ReadRecParticles(branchTitle) ;  //first read RecPartcles and branche TS from which they are made
102     ReadTS(dummyfile);              //read TS from which made RecParticles above
103     ReadRecPoints(dummyfile) ;     //RecPoints from which TS above made
104     ReadDigits(dummyfile) ;         //digits. from whic RecPoints made
105     isRead= kTRUE ;
106   }
107   
108   if((strcmp(branch,"PHOSTS")==0) || (strcmp(branch,"PHOSTSMaker")==0)){
109     ReadTS(branchTitle);            //read TS and branch of RecPoints from which they are made
110     ReadRecPoints(dummyfile) ;     //recpoints abd branch of digits
111     ReadDigits(dummyfile) ;       //digits and branch of Primaries
112     ReadRecParticles(dummyfile) ;  //posiible completion of TS
113     isRead= kTRUE ;
114   }
115
116   if((strcmp(branch,"PHOSEmcRP")==0)|| (strcmp(branch,"PHOSCpvRP")==0) || 
117      (strcmp(branch,"PHOSClusterizer")==0)){
118     ReadRecPoints(branchTitle) ;    //RecPoints and Digits branch filename
119     ReadDigits(dummyfile) ;        //digits and primary file name
120     ReadTS(dummyfile);             //possible completion of RecPoints
121     ReadRecParticles(dummyfile) ;  //possible completion of TS
122     isRead= kTRUE ;
123   }
124
125   if((strcmp(branch,"PHOS")==0) || (strcmp(branch,"PHOSDigitizer")==0)){
126     ReadDigits(branchTitle) ;
127     ReadRecPoints(dummyfile) ;
128     ReadTS(dummyfile);
129     ReadRecParticles(dummyfile) ;
130     isRead= kTRUE ;
131   }
132
133   if(!isRead){
134     cout << "AliPHOSIndexToObject: wrong branch name specified: " << branch << endl ;
135     cout << "   avalilable names are `PHOSRP', `PHOSPID'"<<endl ;
136     cout << "                        `PHOSTS', `PHOSTSMaker'"<<endl ;
137     cout << "                        `PHOSEmcRP', `PHOSCpvRP', `PHOSClusterizer'"<< endl ;
138     cout << "                        `PHOS' and `PHOSDigitizer'"<< endl ;
139   }
140   ReadPrimaries() ; // should be called when digits are already read 
141
142 }
143 //____________________________________________________________________________ 
144 AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance()
145 {
146   // Returns the pointer of the unique instance already defined
147   
148   AliPHOSIndexToObject * rv = 0 ;
149   if ( fgObjGetter )
150     rv = fgObjGetter ;
151   else
152     cout << "AliPHOSIndexToObject::GetInstance ERROR: not yet initialized" << endl ;
153
154   return rv ;
155 }
156
157 //____________________________________________________________________________ 
158 AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance(char* headerFile,char* branch,char* branchTitle)
159 {
160   // Creates and returns the pointer of the unique instance
161   // Must be called only when the environment has changed 
162
163   if ( fgObjGetter )      // delete it if already exists
164     delete fgObjGetter ; 
165
166   fgObjGetter = new AliPHOSIndexToObject(headerFile,branch,branchTitle) ; 
167   
168   return fgObjGetter ; 
169   
170 }
171
172 //____________________________________________________________________________ 
173 TParticle * AliPHOSIndexToObject::GimePrimary(Int_t index)
174 {
175   
176   
177   Int_t primaryList = (Int_t) (TMath::Ceil(index/10000000.) ) - 1 ;
178   Int_t primaryIndex = index - primaryList*10000000 ; 
179   
180   if ( primaryList > 0  ) {
181     cout << " IndexToObject does not support currently Mixing of primary " << endl ;
182     cout << "   can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ;
183     return 0;
184   }
185   
186   return gAlice->Particle(primaryIndex) ;
187   
188 }
189
190 //____________________________________________________________________________ 
191 Bool_t AliPHOSIndexToObject::ReadRecParticles(char * branchTitle){
192
193   if(gAlice->TreeR()==0)
194     return kFALSE ;
195   
196   if(fPID) // already read
197     branchTitle = fPID->GetRecParticlesBranch() ;
198
199
200   if(branchTitle){ // we should read a specific branch
201     TBranch * pidBranch = 0;
202     TBranch * rpBranch = 0;
203     
204     TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
205     Int_t ibranch;
206     Bool_t pidNotFound = kTRUE ;
207     Bool_t rpNotFound = kTRUE ;
208     
209     for(ibranch = 0;(ibranch <branches->GetEntries())&&(pidNotFound||rpNotFound);ibranch++){
210
211       if(pidNotFound){
212         pidBranch=(TBranch *) branches->At(ibranch) ;
213         if( (strcmp(branchTitle,pidBranch->GetTitle())==0 ) &&
214             (strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) )
215           pidNotFound = kFALSE ;
216       }
217       if(rpNotFound){
218         rpBranch=(TBranch *) branches->At(ibranch) ;
219         if( (strcmp(branchTitle,rpBranch->GetTitle())==0 ) &&
220             (strcmp(rpBranch->GetName(),"PHOSRP") == 0) )
221           rpNotFound = kFALSE ;
222       }
223     }
224     
225     if(pidNotFound ||rpNotFound ){
226       cout << "AliPHOSIndexToObject error" << endl ;
227       cout << "     Can't find Branch with PID and RecParticles " ;
228       return kFALSE ;
229     }
230     
231     pidBranch->SetAddress(&fPID) ;
232     rpBranch->SetAddress(&fRecParticles) ;
233     gAlice->TreeR()->GetEvent(0) ;    
234   }
235   else{ //we Should read any branch and print warning if there are other possibilities
236     if(fTSMaker){//if TrackSegments already read, we should read RecParticles Made from it
237       TBranch * pidBranch = 0;
238       TBranch * rpBranch = 0;
239     
240       TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
241
242       Int_t branchRead = 0;
243       Bool_t allNotFound = kTRUE ;
244       while(allNotFound){
245         Bool_t pidNotFound = kTRUE ;
246         Bool_t rpNotFound = kTRUE ;
247         Int_t ibranch ;
248         for(ibranch = branchRead;(ibranch <branches->GetEntries() )&& pidNotFound;ibranch++){
249           pidBranch=(TBranch *) branches->At(ibranch) ;
250           if(strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) 
251             pidNotFound = kFALSE ;
252         }
253         branchRead = ibranch +1 ; 
254         for(ibranch = 0 ;(ibranch <branches->GetEntries() )&& rpNotFound;ibranch++){
255           rpBranch=(TBranch *) branches->At(ibranch) ;
256           if( (strcmp(pidBranch->GetTitle(),rpBranch->GetTitle())==0 ) &&
257               (strcmp(rpBranch->GetName(),"PHOSRP") == 0) )
258             rpNotFound = kFALSE ;
259         }
260         
261         if(pidNotFound ||rpNotFound ){
262           cout << "AliPHOSIndexToObject error" << endl ;
263           cout << "     Can't find Branch with PID and RecParticles " ;
264           return kFALSE ;
265         }
266     
267         pidBranch->SetAddress(&fPID) ;
268         rpBranch->SetAddress(&fRecParticles) ;
269         gAlice->TreeR()->GetEvent(0) ;    
270         
271         if(strcmp(fTSMaker->GetTrackSegmentsBranch(),fPID->GetTrackSegmentsBranch()) == 0)
272           allNotFound = kFALSE ;
273       }
274     }
275     else{//we read any (first) recparticles
276       TBranch * pidBranch = 0;
277       TBranch * rpBranch = 0;
278       TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
279
280       Bool_t pidNotFound = kTRUE ;
281       Bool_t rpNotFound = kTRUE ;
282       Int_t ibranch ;
283       for(ibranch = 0;(ibranch <branches->GetEntries() )&& pidNotFound;ibranch++){
284         pidBranch=(TBranch *) branches->At(ibranch) ;
285         if(strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) 
286           pidNotFound = kFALSE ;
287       }
288       for(ibranch = 0 ;(ibranch <branches->GetEntries() )&& rpNotFound;ibranch++){
289         rpBranch=(TBranch *) branches->At(ibranch) ;
290         if( (strcmp(pidBranch->GetTitle(),rpBranch->GetTitle())==0 ) &&
291             (strcmp(rpBranch->GetName(),"PHOSRP") == 0) )
292           rpNotFound = kFALSE ;
293       }
294       
295       if(pidNotFound ||rpNotFound ){
296         cout << "AliPHOSIndexToObject worning: " << endl ;
297         cout << "     Can't find Branch with PID and RecParticles " << endl;
298         return kFALSE ;
299       }
300       
301       pidBranch->SetAddress(&fPID) ;
302       rpBranch->SetAddress(&fRecParticles) ;
303       gAlice->TreeR()->GetEvent(0) ;    
304       
305     }
306   }
307   return kTRUE ;
308 }
309 //____________________________________________________________________________ 
310 Bool_t AliPHOSIndexToObject::ReadTS(char * branchTitle){
311
312   if(gAlice->TreeR()==0)
313     return kFALSE ;
314
315   if(fPID)//if RecParticles already read, we should read TS from which they are made
316     branchTitle= fPID->GetTrackSegmentsBranch() ;
317   
318   if(branchTitle){   // we should read a specific branch
319     
320     TBranch * tsMakerBranch = 0;
321     TBranch * tsBranch = 0;
322     
323     TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
324     Int_t ibranch;
325     Bool_t tsMakerNotFound = kTRUE ;
326     Bool_t tsNotFound = kTRUE ;
327     
328     for(ibranch = 0;(ibranch <branches->GetEntries())&&(tsMakerNotFound||tsNotFound);ibranch++){
329       if(tsMakerNotFound){
330         tsMakerBranch=(TBranch *) branches->At(ibranch) ;
331         if( strcmp(branchTitle,tsMakerBranch->GetTitle())==0 )
332           if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) 
333             tsMakerNotFound = kFALSE ;
334       }
335       if(tsNotFound){
336         tsBranch=(TBranch *) branches->At(ibranch) ;
337         if( strcmp(branchTitle,tsBranch->GetTitle())==0 )
338           if( strcmp(tsBranch->GetName(),"PHOSTS") == 0) 
339             tsNotFound = kFALSE ;
340       }
341     }
342     
343     if(tsMakerNotFound ||tsNotFound ){
344       cout << "AliPHOSIndexToObject error" << endl ;
345       cout << "       Can't find Branch with TrackSegmentMaker and TrackSegments " ;
346       cout << "       Do nothing" <<endl  ;
347       return kFALSE ;
348     }
349     
350     tsMakerBranch->SetAddress(&fTSMaker) ;
351     tsBranch->SetAddress(&fTS) ;
352     gAlice->TreeR()->GetEvent(0) ;
353     
354   }
355   else{ 
356     if(fClusterizer){//Clusterizer aready read, 
357                      //we should read TrackSegments made from these RecPoints
358
359       Int_t branchRead = 0 ; 
360       TBranch * tsMakerBranch = 0;
361       TBranch * tsBranch = 0;
362     
363       TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
364       Int_t ibranch;
365       Bool_t allNotFound = kTRUE ;
366       while(allNotFound){
367         Bool_t tsMakerNotFound = kTRUE ;
368         Bool_t tsNotFound = kTRUE ;
369         
370         for(ibranch = branchRead;(ibranch <branches->GetEntries())&&(tsMakerNotFound);ibranch++){
371           tsMakerBranch=(TBranch *) branches->At(ibranch) ;
372           if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) 
373             tsMakerNotFound = kFALSE ;
374         }
375         branchRead = ibranch++ ;
376         for(ibranch = 0 ;(ibranch <branches->GetEntries())&&(tsNotFound);ibranch++){
377           tsBranch=(TBranch *) branches->At(ibranch) ;
378           if( (strcmp(tsBranch->GetName(),"PHOSTS") == 0) && 
379               (strcmp(tsBranch->GetName(),tsMakerBranch->GetTitle())==0))
380             tsNotFound = kFALSE ;
381         }
382         
383         branchRead = ibranch++ ;
384         
385         if(tsMakerNotFound ||tsNotFound ){
386           cout << "AliPHOSIndexToObject error" << endl ;
387           cout << "       Can't find Branch with TrackSegmentMaker and TrackSegments " ;
388           cout << "       Do nothing" <<endl  ;
389           return kFALSE ;
390         }
391         
392         tsMakerBranch->SetAddress(&fTSMaker) ;
393         tsBranch->SetAddress(&fTS) ;
394         gAlice->TreeR()->GetEvent(0) ;
395         
396         if(strcmp(fTSMaker->GetRecPointsBranch(),fClusterizer->GetRecPointsBranch()) == 0)
397           allNotFound = kFALSE ;
398       }
399       
400     }
401     else{//Neither Title,neither fPID, neither fClusterizer: we read any (first) occurence
402       TBranch * tsMakerBranch = 0;
403       TBranch * tsBranch = 0;    
404       TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
405       Bool_t tsMakerNotFound = kTRUE ;
406       Bool_t tsNotFound = kTRUE ;
407       Int_t ibranch ;
408       for(ibranch =  0;(ibranch <branches->GetEntries())&& tsMakerNotFound;ibranch++){
409         tsMakerBranch=(TBranch *) branches->At(ibranch) ;
410         if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) 
411           tsMakerNotFound = kFALSE ;
412       }
413       for(ibranch = 0 ;(ibranch <branches->GetEntries())&&(tsNotFound);ibranch++){
414         tsBranch=(TBranch *) branches->At(ibranch) ;
415         if( (strcmp(tsBranch->GetName(),"PHOSTS") == 0) && 
416             (strcmp(tsBranch->GetName(),tsMakerBranch->GetTitle())==0))
417           tsNotFound = kFALSE ;
418       } 
419       if(tsMakerNotFound ||tsNotFound ){
420         cout << "AliPHOSIndexToObject error" << endl ;
421         cout << "       Can't find Branch with TrackSegmentMaker and TrackSegments " ;
422         cout << "       Do nothing" <<endl  ;
423         return kFALSE ;
424       }
425       
426       tsMakerBranch->SetAddress(&fTSMaker) ;
427       tsBranch->SetAddress(&fTS) ;
428       gAlice->TreeR()->GetEvent(0) ;     
429     }
430   }
431
432   return kTRUE ;  
433 }
434 //____________________________________________________________________________ 
435 Bool_t AliPHOSIndexToObject::ReadRecPoints(char * branchTitle){
436   
437   if(gAlice->TreeR() == 0)
438     return kFALSE ;
439
440   if(fTSMaker) //if TrackSegment maker already read, read corresponding branches
441     branchTitle = fTSMaker->GetRecPointsBranch() ;
442
443   if(branchTitle){ // we should read a specific branch
444     TBranch * emcBranch = 0;
445     TBranch * cpvBranch = 0;
446     TBranch * clusterizerBranch = 0;
447     
448     TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
449     Int_t ibranch;
450     Bool_t emcNotFound = kTRUE ;
451     Bool_t cpvNotFound = kTRUE ;  
452     Bool_t clusterizerNotFound = kTRUE ;
453     
454     for(ibranch = 0;((ibranch < branches->GetEntries())&&(emcNotFound ||cpvNotFound || clusterizerNotFound)) ;ibranch++){
455       if(emcNotFound){
456         emcBranch=(TBranch *) branches->At(ibranch) ;
457         if( (strcmp(emcBranch->GetTitle(),branchTitle) == 0) && 
458             (strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0) )
459           emcNotFound = kFALSE ;
460       }
461       if(cpvNotFound){
462         cpvBranch=(TBranch *) branches->At(ibranch) ;
463         if( (strcmp(cpvBranch->GetTitle(),branchTitle) == 0) &&
464             (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) )
465           cpvNotFound = kFALSE ;
466       }
467       if(clusterizerNotFound){
468         clusterizerBranch = (TBranch *) branches->At(ibranch) ;
469         if( (strcmp(clusterizerBranch->GetTitle(),branchTitle) == 0) &&
470             (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) )
471           clusterizerNotFound = kFALSE ;
472       }
473       
474     }
475     
476     if(clusterizerNotFound || emcNotFound || cpvNotFound){
477       cout << "AliPHOSIndexToObject error" << endl ;
478       cout << "       Can't find Branch with RecPoints or Clusterizer " << endl ;
479       return kFALSE ;
480     }
481     
482     emcBranch->SetAddress(&fEmcRecPoints) ;
483     cpvBranch->SetAddress(&fCpvRecPoints) ;
484     clusterizerBranch->SetAddress(&fClusterizer) ;
485     gAlice->TreeR()->GetEvent(0) ;
486   }
487   else{ //no specific branch
488     if(fDigitizer){//Digitizer aready read, 
489                    //we should read RecPoints made from these Digits
490       TBranch * emcBranch = 0;
491       TBranch * cpvBranch = 0;
492       TBranch * clusterizerBranch = 0;
493       
494       TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
495       Int_t branchRead = 0;
496       Bool_t allNotFound = kTRUE ;
497       while(allNotFound){
498         Bool_t emcNotFound = kTRUE ;
499         Bool_t cpvNotFound = kTRUE ;  
500         Bool_t clusterizerNotFound = kTRUE ;
501         Int_t ibranch ;
502         for(ibranch = branchRead;ibranch < branches->GetEntries();ibranch++){
503           emcBranch=(TBranch *) branches->At(ibranch) ;
504           if( strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0)
505             emcNotFound = kFALSE ;
506         }
507         branchRead = ibranch + 1 ;
508         for(ibranch =  0 ;ibranch < branches->GetEntries();ibranch++){
509           cpvBranch=(TBranch *) branches->At(ibranch) ;
510           if( (strcmp(cpvBranch->GetTitle(),emcBranch->GetTitle()) == 0) &&
511               (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) )
512             cpvNotFound = kFALSE ;
513         }
514         for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){
515           clusterizerBranch = (TBranch *) branches->At(ibranch) ;
516           if( (strcmp(clusterizerBranch->GetTitle(),emcBranch->GetTitle()) == 0) &&
517               (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) )
518             clusterizerNotFound = kFALSE ;
519         }
520         
521         if(clusterizerNotFound || emcNotFound || cpvNotFound){
522           cout << "AliPHOSIndexToObject error" << endl ;
523           cout << "       Can't find Branch with RecPoints or Clusterizer " << endl ;
524           return kFALSE ;
525         }
526     
527         emcBranch->SetAddress(&fEmcRecPoints) ;
528         cpvBranch->SetAddress(&fCpvRecPoints) ;
529         clusterizerBranch->SetAddress(&fClusterizer) ;
530         gAlice->TreeR()->GetEvent(0) ;
531         
532         if(strcmp(fClusterizer->GetDigitsBranch(),fDigitizer->GetDigitsBranch())== 0)
533           allNotFound = kFALSE ;
534       }
535     }
536     else{//Neither Title, Neither TSMaker, Neither Digits: we read any (first) RecPoints
537       TBranch * emcBranch = 0;
538       TBranch * cpvBranch = 0;
539       TBranch * clusterizerBranch = 0;
540       TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
541       Bool_t emcNotFound = kTRUE ;
542       Bool_t cpvNotFound = kTRUE ;  
543       Bool_t clusterizerNotFound = kTRUE ;
544       Int_t ibranch ;
545       for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){
546         emcBranch=(TBranch *) branches->At(ibranch) ;
547         if( strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0)
548           emcNotFound = kFALSE ;
549       }
550       for(ibranch = 0 ;ibranch < branches->GetEntries();ibranch++){
551         cpvBranch=(TBranch *) branches->At(ibranch) ;
552         if( (strcmp(cpvBranch->GetTitle(),emcBranch->GetTitle()) == 0) &&
553             (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) )
554           cpvNotFound = kFALSE ;
555       }
556       for(ibranch = 0;ibranch < branches->GetEntries();ibranch++){
557         clusterizerBranch = (TBranch *) branches->At(ibranch) ;
558         if( (strcmp(clusterizerBranch->GetTitle(),emcBranch->GetTitle()) == 0) &&
559             (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) )
560           clusterizerNotFound = kFALSE ;
561       }
562       
563       if(clusterizerNotFound || emcNotFound || cpvNotFound){
564         cout << "AliPHOSIndexToObject error" << endl ;
565         cout << "       Can't find Branch with RecPoints or Clusterizer " << endl ;
566         return kFALSE ;
567       }
568       
569       emcBranch->SetAddress(&fEmcRecPoints) ;
570       cpvBranch->SetAddress(&fCpvRecPoints) ;
571       clusterizerBranch->SetAddress(&fClusterizer) ;
572       gAlice->TreeR()->GetEvent(0) ;
573     }
574   }
575
576   return kTRUE ;
577 }
578 //____________________________________________________________________________ 
579 Bool_t AliPHOSIndexToObject::ReadDigits(char * branchTitle){
580
581   if(gAlice->TreeD()== 0)
582     return kFALSE ;
583
584
585   
586   //if RecPoints are already read, we should read Digits from which they are made
587   if(fClusterizer)
588     branchTitle = fClusterizer->GetDigitsBranch() ;
589   
590   if(branchTitle){ // we should read a specific branch
591     TBranch * digitsBranch = 0;
592     TBranch * digitizerBranch = 0;
593
594     TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ;
595     Int_t ibranch;
596     Bool_t phosNotFound = kTRUE ;
597     Bool_t digitizerNotFound = kTRUE ;
598     
599     for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
600       
601       if(phosNotFound){
602         digitsBranch=(TBranch *) branches->At(ibranch) ;
603         if( (strcmp(digitsBranch->GetTitle(),branchTitle)==0 ) &&
604             (strcmp(digitsBranch->GetName(),"PHOS") == 0) )
605           phosNotFound = kFALSE ;
606       }
607       if(digitizerNotFound){
608         digitizerBranch = (TBranch *) branches->At(ibranch) ;
609         if( (strcmp(digitizerBranch->GetTitle(),branchTitle) == 0) && 
610             (strcmp(digitizerBranch->GetName(),"AliPHOSDigitizer") == 0) )
611           digitizerNotFound = kFALSE ;
612       } 
613     }
614     
615     if(digitizerNotFound || phosNotFound){
616       cout << "AliPHOSIndexToObject error: " << endl ;
617       cout << "       Can't find Branch with Digits or Digitizer "<< endl ; ;
618       return kFALSE ;
619     }
620     
621     digitsBranch->SetAddress(&fDigits) ;
622     digitizerBranch->SetAddress(&fDigitizer) ;
623   
624   }
625   else{ //we should read any branch and print warning if there are other possibilities
626     TBranch * digitsBranch = 0;
627     TBranch * digitizerBranch = 0;
628     
629     TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ;
630     Int_t ibranch;
631     Bool_t phosNotFound = kTRUE ;
632     Bool_t digitizerNotFound = kTRUE ;
633     
634     for(ibranch = 0;(ibranch <branches->GetEntries())&& phosNotFound ;ibranch++){
635       digitsBranch=(TBranch *) branches->At(ibranch) ;
636       if(strcmp(digitsBranch->GetName(),"PHOS") == 0) 
637         phosNotFound = kFALSE ;
638     }
639     for(ibranch = 0;(ibranch <branches->GetEntries())&& digitizerNotFound ;ibranch++){
640       digitizerBranch = (TBranch *) branches->At(ibranch) ;
641       if( (strcmp(digitizerBranch->GetTitle(),digitsBranch->GetTitle()) == 0) && 
642           (strcmp(digitizerBranch->GetName(),"AliPHOSDigitizer") == 0) )
643         digitizerNotFound = kFALSE ;
644     } 
645     
646     if(digitizerNotFound || phosNotFound){
647       cout << "AliPHOSIndexToObject error: " << endl ;
648       cout << "       Can't find Branch with Digits or Digitizer "<< endl ; ;
649       return kFALSE ;
650     }
651     
652     digitsBranch->SetAddress(&fDigits) ;
653     digitizerBranch->SetAddress(&fDigitizer) ;
654         
655   }
656
657   gAlice->TreeD()->GetEvent(0) ;
658
659   return kTRUE ;
660 }
661 //____________________________________________________________________________ 
662 Bool_t AliPHOSIndexToObject::ReadPrimaries(){
663   //read specific branches of primaries
664
665 //   //Check, is it necessary to open new files
666 //   TArrayI* events = fDigitizer->GetCurrentEvents() ; 
667 //   TClonesArray * filenames = fDigitizer->GetHeadersFiles() ;
668 //   Int_t input ;
669 //   for(input = 0; input < filenames->GetEntriesFast(); input++){
670
671 //     TObjString * filename = (TObjString *) filenames->At(input) ;
672
673 //     //Test, if this file already open
674 //     TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ;
675 //     if(file == 0)
676 //       file = new TFile( filename->GetString()) ;
677 //     file->cd() ;
678     
679 //     // Get Kine Tree from file
680 // //     char treeName[20];
681 // //     sprintf(treeName,"TreeK%d",events->At(input));
682 // //     TTree * treeK = (TTree*)gDirectory->Get(treeName);
683 // //     if (treeK) 
684 // //       treeK->SetBranchAddress("Particles", &fParticleBuffer);
685 // //     else    
686 // //       cout << "AliPHOSIndexToObject: cannot find Kine Tree for event:" << events->At(input) << endl;
687
688 // //     // Create the particle stack
689 // //     if(!fParticles) fParticles = new TClonesArray("TParticle",1000);
690 // //     // Build the pointer list
691 // //     if(fParticleMap) {     <----
692 // //       fParticleMap->Clear();
693 // //       fParticleMap->Expand(treeK->GetEntries());
694 // //     } else
695 // //       fParticleMap = new TObjArray(treeK->GetEntries());
696     
697 //     // From gAlice->Particle(i) 
698
699
700 // //   if(!(*fParticleMap)[i]) {
701 // //     Int_t nentries = fParticles->GetEntries();
702     
703 // //     // algorithmic way of getting entry index
704 // //     // (primary particles are filled after secondaries)
705 // //     Int_t entry;
706 // //     if (i<fHeader.GetNprimary())
707 // //       entry = i+fHeader.GetNsecondary();
708 // //     else 
709 // //       entry = i-fHeader.GetNprimary();
710       
711 // //     // only check the algorithmic way and give
712 // //     // the fatal error if it is wrong
713 // //     if (entry != fParticleFileMap[i]) {
714 // //       Fatal("Particle",
715 // //         "!!!! The algorithmic way is WRONG: !!!\n entry: %d map: %d",
716 // //   entry, fParticleFileMap[i]); 
717 // //     }  
718       
719 // //     fTreeK->GetEntry(fParticleFileMap[i]);
720 // //     new ((*fParticles)[nentries]) TParticle(*fParticleBuffer);
721 // //     fParticleMap->AddAt((*fParticles)[nentries],i);
722 // //   }
723 // //   return (TParticle *) (*fParticleMap)[i];
724
725    
726     
727 //   }
728
729
730 //   //scan over opened files and read corresponding TreeK##
731
732   return kTRUE ;
733 }
734 //____________________________________________________________________________ 
735 void AliPHOSIndexToObject::GetEvent(Int_t event){
736   if(event == fEvent) // do nothing
737     return ;
738     
739   if(event > fMaxEvent)
740     return ;
741
742   fEvent = event ;
743   gAlice->GetEvent(fEvent) ;
744   
745   ReadRecParticles(fPID->GetRecParticlesBranch()) ;
746   ReadTS(fTSMaker->GetTrackSegmentsBranch()) ;
747   ReadRecPoints(fClusterizer->GetRecPointsBranch()) ;
748   ReadDigits(fDigitizer->GetDigitsBranch()) ;
749   ReadPrimaries() ;
750 }
751