92ecb814de042109a7308b0ae7d09ee67297c49a
[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 "AliPHOSSDigitizer.h"
55 #include "AliPHOSClusterizer.h"
56 #include "AliPHOSClusterizerv1.h"
57 #include "AliPHOSTrackSegmentMaker.h"
58 #include "AliPHOSTrackSegmentMakerv1.h"
59 #include "AliPHOSTrackSegment.h"
60 #include "AliPHOSPID.h" 
61 #include "AliPHOSPIDv1.h" 
62
63 ClassImp(AliPHOSIndexToObject)
64   
65   AliPHOSIndexToObject * AliPHOSIndexToObject::fgObjGetter = 0 ; 
66
67 //____________________________________________________________________________ 
68 AliPHOSIndexToObject::AliPHOSIndexToObject(const char* headerFile,const char* branch,const char* branchTitle )
69 {
70   //Initiate all lists
71   fEvent = 0 ;
72
73   fSDigits = new TClonesArray("AliPHOSDigit",100) ;
74   fDigits  = new TClonesArray("AliPHOSDigit",100) ;
75   fEmcRecPoints = new TObjArray(100) ;
76   fCpvRecPoints = new TObjArray(100) ;
77   fTS = new TClonesArray("AliPHOSTrackSegment",100) ;
78   fRecParticles = new TClonesArray("AliPHOSRecParticle",100) ;
79   fPrimaries = new TObjArray(1) ;
80
81   fSDigitizer = 0 ;
82   fDigitizer = 0 ;
83   fClusterizer = 0 ;
84   fTSMaker = 0 ;
85   fPID = 0 ;
86
87   //open headers file
88   fHeaderFile = headerFile ;
89   TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ;
90
91   if(file == 0){
92     if(fHeaderFile.Contains("rfio")) // if we read file using HPSS
93       file =    TFile::Open(fHeaderFile.Data(),"update") ;
94     else
95       file = new TFile(fHeaderFile.Data(),"update") ;
96     gAlice = (AliRun *) file->Get("gAlice") ;
97   }
98
99   fMaxEvent = (Int_t) gAlice->TreeE()->GetEntries() ;
100
101   DefineBranchTitles(branch,branchTitle) ;
102
103   //Now read all data from trees
104   fEvent = -1 ;
105   GetEvent(0) ;
106
107 }
108 //____________________________________________________________________________ 
109 void AliPHOSIndexToObject:: DefineBranchTitles(const char* startBranch,const char* branchTitle){
110
111   gAlice->GetEvent(0) ;
112   //Read all reconstruction classes to extract titles of 
113   //branches, constituing "reconstruction branch"
114   AliPHOSPID * pids[50];  // here AliPHOSPID's will be stored
115   Int_t ipids = 0 ;
116   AliPHOSTrackSegmentMaker * tsms[50] ; 
117   Int_t itsms = 0 ;
118   AliPHOSClusterizer * clus[50] ;   
119   Int_t iclus = 0 ;
120   AliPHOSDigitizer * digs[50]; 
121   Int_t idigs = 0 ;
122   AliPHOSSDigitizer * sdigs[50];
123   Int_t isdigs = 0 ;
124   
125   //read TreeR
126   TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
127   Int_t ibranch;
128   TBranch * branch ;
129   for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
130     branch=(TBranch *) branches->At(ibranch) ;
131     if( (strcmp(branch->GetName(),"AliPHOSPID") == 0) ){
132       pids[ipids] =  new  AliPHOSPIDv1() ;
133       branch->SetAddress(& (pids[ipids])) ;
134       ipids++ ;
135     }
136     if( (strcmp(branch->GetName(),"AliPHOSTrackSegmentMaker") == 0) ){
137       tsms[itsms] = new  AliPHOSTrackSegmentMakerv1() ;
138       branch->SetAddress(&(tsms[itsms])) ;
139       itsms++ ;
140     }
141     if( (strcmp(branch->GetName(),"AliPHOSClusterizer") == 0) ){
142       clus[iclus] = new  AliPHOSClusterizerv1() ;
143       branch->SetAddress(&(clus[iclus])) ;
144       iclus++ ;
145     }
146   }
147   gAlice->TreeR()->GetEvent(0) ;
148
149
150   //read TreeD
151   branches = gAlice->TreeD()->GetListOfBranches() ;
152   for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
153     branch=(TBranch *) branches->At(ibranch) ;
154     if( (strcmp(branch->GetName(),"AliPHOSDigitizer") == 0) ){
155       digs[idigs] = new  AliPHOSDigitizer() ;
156       branch->SetAddress(&(digs[idigs])) ;
157       idigs++ ;
158     }
159   }
160   gAlice->TreeD()->GetEvent(0) ;
161
162   //read TreeS
163   branches = gAlice->TreeS()->GetListOfBranches() ;
164   for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
165     branch=(TBranch *) branches->At(ibranch) ;
166     if( (strcmp(branch->GetName(),"AliPHOSSDigitizer") == 0) ){
167       sdigs[isdigs] = new  AliPHOSSDigitizer() ;
168       branch->SetAddress(&(sdigs[isdigs])) ;
169       isdigs++ ;
170     }
171   }
172   gAlice->TreeS()->GetEvent(0) ;
173
174   //now choose among read Reconstruction classes those,
175   //which constituite "reconstruction branch"
176   Bool_t pidDefined = kFALSE ;
177   Bool_t tsmDefined = kFALSE ;
178   Bool_t cluDefined = kFALSE ;
179   Bool_t digDefined = kFALSE ;
180   Bool_t sdigDefined = kFALSE ;
181
182   Int_t index ;
183   //First, go from the end (RecParticles) to the beginning(SDigits)
184   if((strcmp(startBranch,"PHOSRP") == 0)||(strcmp(startBranch,"AliPHOSPID") == 0)){
185     fRPTitle = branchTitle ;
186     for(index = 0; index < ipids ; index++){
187       if(fRPTitle.CompareTo(((AliPHOSPID*)pids[index])->GetRecParticlesBranch())== 0){
188         pidDefined = kTRUE ;
189         fTSTitle =((AliPHOSPID*)pids[index])->GetTrackSegmentsBranch() ; 
190       }
191     }
192   }
193   if((strcmp(startBranch,"PHOSTS") == 0)||(strcmp(startBranch,"AliPHOSTrackSegmentMaker") == 0)|| pidDefined ) {
194     if(!pidDefined)
195       fTSTitle = branchTitle ;
196     for(index = 0; index < itsms ; index++)
197       if(fTSTitle.CompareTo(((AliPHOSTrackSegmentMaker*)tsms[index])->GetTrackSegmentsBranch())== 0){
198         tsmDefined = kTRUE ;
199         fRecPointsTitle =((AliPHOSTrackSegmentMaker*)tsms[index])->GetRecPointsBranch() ;
200       }
201   }
202   if((strcmp(startBranch,"PHOSEmcRP") == 0) || 
203      (strcmp(startBranch,"PHOSCpvRP") == 0) ||
204      (strcmp(startBranch,"AliPHOSClusterizer") == 0)  || tsmDefined ) {
205     if(!tsmDefined)
206       fRecPointsTitle = branchTitle ;
207     for(index = 0; index < iclus ; index++)
208       if(fRecPointsTitle.CompareTo(((AliPHOSClusterizer*)clus[index])->GetRecPointsBranch())== 0){
209         cluDefined = kTRUE ;
210         fDigitsTitle =((AliPHOSClusterizer*)clus[index])->GetDigitsBranch() ;
211       }
212   }
213   if((strcmp(startBranch,"PHOS") == 0) || (strcmp(startBranch,"AliPHOSDigitizer") == 0) ||cluDefined ) {
214     if(!cluDefined)
215       fDigitsTitle = branchTitle ; 
216     for(index = 0; index < idigs ; index++)
217       if(fDigitsTitle.CompareTo(((AliPHOSDigitizer*)digs[index])->GetDigitsBranch())== 0){
218         digDefined = kTRUE ;
219         fSDigitsTitle =((AliPHOSDigitizer*)digs[index])->GetSDigitsBranch() ;
220       }
221   }
222   for(index = 0; index < idigs ; index++)
223     if(fSDigitsTitle.CompareTo(((AliPHOSSDigitizer*)sdigs[index])->GetSDigitsBranch())== 0)
224       sdigDefined = kTRUE ;
225   
226   if(!sdigDefined){
227     cout << "Can not define titles of branches " << endl ;
228     cout << endl ;
229   }
230
231   //Now we go in the inverse direction: from sdigits to recparticles - for the 
232   //case, if we started decending not from RecParticles, but e.g. from digits
233
234   if( !cluDefined ) {
235     for(index = 0; index < iclus ; index++)
236       if(fDigitsTitle.CompareTo(((AliPHOSClusterizer*)clus[index])->GetDigitsBranch())== 0){
237         cluDefined = kTRUE ;
238         fRecPointsTitle =((AliPHOSClusterizer*)clus[index])->GetRecPointsBranch() ;
239       }
240   }
241   if(! tsmDefined ) {
242     for(index = 0; index < itsms ; index++)
243       if(fRecPointsTitle.CompareTo(((AliPHOSTrackSegmentMaker*)tsms[index])->GetRecPointsBranch())== 0){
244         tsmDefined = kTRUE ;
245         fTSTitle =((AliPHOSTrackSegmentMaker*)tsms[index])->GetTrackSegmentsBranch() ;
246       }
247   }
248   if(!pidDefined){
249     for(index = 0; index < ipids ; index++)
250       if(fTSTitle.CompareTo(((AliPHOSPID*)pids[index])->GetTrackSegmentsBranch())== 0){
251         pidDefined = kTRUE ;
252         fRPTitle = ((AliPHOSPID*)pids[index])->GetRecParticlesBranch() ;
253       }
254   }
255   
256   //delete created objects
257   for(index = 0; index < ipids ; index++)
258     delete pids[index] ;
259   for(index = 0; index < itsms ; index++)
260     delete tsms[index] ;
261   for(index = 0; index < iclus ; index++)
262     delete clus[index] ;
263   for(index = 0; index < idigs ; index++) 
264     delete digs[index] ;
265   for(index = 0; index < isdigs ; index++) 
266     delete sdigs[index] ;
267   
268 }
269 //____________________________________________________________________________ 
270 AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance()
271 {
272   // Returns the pointer of the unique instance already defined
273   
274   AliPHOSIndexToObject * rv = 0 ;
275   if ( fgObjGetter )
276     rv = fgObjGetter ;
277   else
278     cout << "AliPHOSIndexToObject::GetInstance ERROR: not yet initialized" << endl ;
279
280   return rv ;
281 }
282
283 //____________________________________________________________________________ 
284 AliPHOSIndexToObject * AliPHOSIndexToObject::GetInstance(const char* headerFile,
285                                                          const char* branch,
286                                                          const char* branchTitle)
287 {
288   // Creates and returns the pointer of the unique instance
289   // Must be called only when the environment has changed 
290
291   if(strcmp(branch,"PHOSRP") && strcmp(branch,"AliPHOSPID") &&
292      strcmp(branch,"PHOSTS") && strcmp(branch,"AliPHOSTrackSegmentMaker") && 
293      strcmp(branch,"PHOSEmcRP") && strcmp(branch,"PHOSCpvRP") && strcmp(branch,"AliPHOSClusterizer") &&
294      strcmp(branch,"PHOS") && strcmp(branch,"AliPHOSDigitizer") ){
295     
296     cout << "AliPHOSIndexToObject: wrong branch name specified: " << branch << endl ;
297     cout << "   avalilable names are `PHOSRP', `AliPHOSPID'"<<endl ;
298     cout << "                        `PHOSTS', `AliPHOSTrackSegmentMaker'"<<endl ;
299     cout << "                        `PHOSEmcRP', `PHOSCpvRP', `AliPHOSClusterizer'"<< endl ;
300     cout << "                        `PHOS' and `AliPHOSDigitizer'"<< endl ;
301     return 0 ;
302   }
303
304
305   if ( fgObjGetter )      // delete it if already exists
306     delete fgObjGetter ; 
307
308   fgObjGetter = new AliPHOSIndexToObject(headerFile,branch,branchTitle) ; 
309   
310   return fgObjGetter ; 
311   
312 }
313
314 //____________________________________________________________________________ 
315 TParticle * AliPHOSIndexToObject::GimePrimary(Int_t index)
316 {
317   
318   if(index < 0) 
319     return 0 ;
320   
321   Int_t primaryIndex = index % 10000000 ; 
322   Int_t primaryList = (Int_t ) ((index-primaryIndex)/10000000.)  ;
323   
324   if ( primaryList > 0  ) {
325     cout << " IndexToObject does not support currently Mixing of primary " << endl ;
326     cout << "   can not return primary: " << index<< " (list "<< primaryList<< " primary # " << primaryIndex << " )"<<endl ;
327     return 0;
328   }
329   
330   return gAlice->Particle(primaryIndex) ;
331   
332 }
333
334 //____________________________________________________________________________ 
335 void AliPHOSIndexToObject::ReadTreeD(){
336   
337   if(gAlice->TreeD()== 0){
338     cout << "AliPHOSIndexToObject : can not read TreeD " << endl;
339     return ;
340   }
341   
342   TBranch * digitsBranch = 0;
343   TBranch * digitizerBranch = 0;
344   
345   TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ;
346   Int_t ibranch;
347   Bool_t phosNotFound = kTRUE ;
348   Bool_t digitizerNotFound = kTRUE ;
349   
350   for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
351     
352     if(phosNotFound){
353       digitsBranch=(TBranch *) branches->At(ibranch) ;
354       if( (strcmp(digitsBranch->GetTitle(),fDigitsTitle)==0 ) &&
355           (strcmp(digitsBranch->GetName(),"PHOS") == 0) )
356         phosNotFound = kFALSE ;
357     }
358     if(digitizerNotFound){
359       digitizerBranch = (TBranch *) branches->At(ibranch) ;
360       if( (strcmp(digitizerBranch->GetTitle(),fDigitsTitle) == 0) && 
361           (strcmp(digitizerBranch->GetName(),"AliPHOSDigitizer") == 0) )
362         digitizerNotFound = kFALSE ;
363     } 
364   }
365     
366   if(digitizerNotFound || phosNotFound){
367     cout << "AliPHOSIndexToObject error: " << endl ;
368     cout << "       Can't find Branch with Digits or Digitizer "<< endl ; ;
369     return  ;
370   }
371   
372   digitsBranch->SetAddress(&fDigits) ;
373   digitizerBranch->SetAddress(&fDigitizer) ;
374   
375   gAlice->TreeD()->GetEvent(0) ;
376   
377 }
378 //____________________________________________________________________________ 
379 void AliPHOSIndexToObject::ReadTreeS(){
380   
381   if(gAlice->TreeS()== 0){
382     cout <<   "AliPHOSIndexToObject: can not read TreeS " << endl ;
383     return ;
384   }
385   
386   TBranch * sdigitsBranch = 0;
387   TBranch * sdigitizerBranch = 0;
388   
389   TObjArray * branches = gAlice->TreeS()->GetListOfBranches() ;
390   Int_t ibranch;
391   Bool_t phosNotFound = kTRUE ;
392   Bool_t sdigitizerNotFound = kTRUE ;
393   
394   for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
395     
396     if(phosNotFound){
397       sdigitsBranch=(TBranch *) branches->At(ibranch) ;
398       if( (strcmp(sdigitsBranch->GetTitle(),fSDigitsTitle)==0 ) &&
399           (strcmp(sdigitsBranch->GetName(),"PHOS") == 0) )
400         phosNotFound = kFALSE ;
401     }
402     if(sdigitizerNotFound){
403       sdigitizerBranch = (TBranch *) branches->At(ibranch) ;
404       if( (strcmp(sdigitizerBranch->GetTitle(),fSDigitsTitle) == 0) && 
405           (strcmp(sdigitizerBranch->GetName(),"AliPHOSSDigitizer") == 0) )
406         sdigitizerNotFound = kFALSE ;
407     } 
408   }
409   
410   if(sdigitizerNotFound || phosNotFound){
411     cout << "AliPHOSIndexToObject error: " << endl ;
412     cout << "       Can't find Branch with SDigits or SDigitizer "<< endl ; ;
413     return ;
414   }
415   
416   sdigitsBranch->SetAddress(&fSDigits) ;
417   sdigitizerBranch->SetAddress(&fSDigitizer) ;
418   
419   gAlice->TreeS()->GetEvent(0) ;
420   
421 }
422 //____________________________________________________________________________ 
423 void AliPHOSIndexToObject::ReadTreeR(){
424   
425   if(gAlice->TreeR()== 0){
426     cout <<   "AliPHOSIndexToObject: can not read TreeR " << endl ;
427     return ;
428   }
429
430   TBranch * pidBranch = 0;
431   TBranch * rpBranch = 0;
432   TBranch * tsMakerBranch = 0;
433   TBranch * tsBranch = 0;
434   TBranch * emcBranch = 0;
435   TBranch * cpvBranch = 0;
436   TBranch * clusterizerBranch = 0;
437   
438   TObjArray * branches = gAlice->TreeR()->GetListOfBranches() ;
439   Int_t ibranch;
440   Bool_t pidNotFound = kTRUE ;
441   Bool_t rpNotFound = kTRUE ;
442   Bool_t tsMakerNotFound = kTRUE ;
443   Bool_t tsNotFound = kTRUE ;
444   Bool_t emcNotFound = kTRUE ;
445   Bool_t cpvNotFound = kTRUE ;  
446   Bool_t clusterizerNotFound = kTRUE ;
447   
448   for(ibranch = 0;ibranch <branches->GetEntries();ibranch++){
449     
450     if(pidNotFound){
451       pidBranch=(TBranch *) branches->At(ibranch) ;
452       if( (fRPTitle.CompareTo(pidBranch->GetTitle())==0 ) &&
453           (strcmp(pidBranch->GetName(),"AliPHOSPID") == 0) )
454         pidNotFound = kFALSE ;
455     }
456     if(rpNotFound){
457       rpBranch=(TBranch *) branches->At(ibranch) ;
458       if( (fRPTitle.CompareTo(rpBranch->GetTitle())==0 ) &&
459           (strcmp(rpBranch->GetName(),"PHOSRP") == 0) )
460         rpNotFound = kFALSE ;
461     }
462     if(tsMakerNotFound){
463       tsMakerBranch=(TBranch *) branches->At(ibranch) ;
464       if( fTSTitle.CompareTo(tsMakerBranch->GetTitle())==0 )
465         if( strcmp(tsMakerBranch->GetName(),"AliPHOSTrackSegmentMaker") == 0) 
466           tsMakerNotFound = kFALSE ;
467     }
468     if(tsNotFound){
469       tsBranch=(TBranch *) branches->At(ibranch) ;
470       if( fTSTitle.CompareTo(tsBranch->GetTitle())==0 )
471         if( strcmp(tsBranch->GetName(),"PHOSTS") == 0) 
472           tsNotFound = kFALSE ;
473     }  
474     if(emcNotFound){
475       emcBranch=(TBranch *) branches->At(ibranch) ;
476       if( (fRecPointsTitle.CompareTo(emcBranch->GetTitle()) == 0) && 
477           (strcmp(emcBranch->GetName(),"PHOSEmcRP") == 0) )
478         emcNotFound = kFALSE ;
479     }
480     if(cpvNotFound){
481       cpvBranch=(TBranch *) branches->At(ibranch) ;
482       if( (fRecPointsTitle.CompareTo(cpvBranch->GetTitle()) == 0) &&
483           (strcmp(cpvBranch->GetName(),"PHOSCpvRP") == 0) )
484         cpvNotFound = kFALSE ;
485     }
486     if(clusterizerNotFound){
487       clusterizerBranch = (TBranch *) branches->At(ibranch) ;
488       if( (fRecPointsTitle.CompareTo(clusterizerBranch->GetTitle()) == 0) &&
489           (strcmp(clusterizerBranch->GetName(),"AliPHOSClusterizer") == 0) )
490         clusterizerNotFound = kFALSE ;
491     }
492   }
493
494   if(pidNotFound ||rpNotFound ){
495     cout << "AliPHOSIndexToObject error" << endl ;
496     cout << "     Can't find Branch with PID and RecParticles " ;
497     return  ;
498   }
499   if(tsMakerNotFound ||tsNotFound ){
500     cout << "AliPHOSIndexToObject error" << endl ;
501     cout << "       Can't find Branch with TrackSegmentMaker and TrackSegments " ;
502     cout << "       Do nothing" <<endl  ;
503     return ;
504   }
505   if(clusterizerNotFound || emcNotFound || cpvNotFound){
506     cout << "AliPHOSIndexToObject error" << endl ;
507     cout << "       Can't find Branch with RecPoints or Clusterizer " << endl ;
508     return ;
509   }
510
511   emcBranch->SetAddress(&fEmcRecPoints) ;
512   cpvBranch->SetAddress(&fCpvRecPoints) ;
513   clusterizerBranch->SetAddress(&fClusterizer) ;
514   
515   tsMakerBranch->SetAddress(&fTSMaker) ;
516   tsBranch->SetAddress(&fTS) ;
517     
518   pidBranch->SetAddress(&fPID) ;
519   rpBranch->SetAddress(&fRecParticles) ;
520   
521   gAlice->TreeR()->GetEvent(0) ;    
522
523 }
524 //____________________________________________________________________________ 
525 void AliPHOSIndexToObject::ReadPrimaries(){
526   //read specific branches of primaries
527   
528   fNPrimaries = gAlice->GetNtrack();
529   
530   //   //Check, is it necessary to open new files
531   //   TArrayI* events = fDigitizer->GetCurrentEvents() ; 
532   //   TClonesArray * filenames = fDigitizer->GetHeadersFiles() ;
533 //   Int_t input ;
534 //   for(input = 0; input < filenames->GetEntriesFast(); input++){
535
536 //     TObjString * filename = (TObjString *) filenames->At(input) ;
537
538 //     //Test, if this file already open
539 //     TFile *file = (TFile*) gROOT->GetFile( filename->GetString() ) ;
540 //     if(file == 0)
541 //       file = new TFile( filename->GetString()) ;
542 //     file->cd() ;
543     
544 //     // Get Kine Tree from file
545 // //     char treeName[20];
546 // //     sprintf(treeName,"TreeK%d",events->At(input));
547 // //     TTree * treeK = (TTree*)gDirectory->Get(treeName);
548 // //     if (treeK) 
549 // //       treeK->SetBranchAddress("Particles", &fParticleBuffer);
550 // //     else    
551 // //       cout << "AliPHOSIndexToObject: cannot find Kine Tree for event:" << events->At(input) << endl;
552
553 // //     // Create the particle stack
554 // //     if(!fParticles) fParticles = new TClonesArray("TParticle",1000);
555 // //     // Build the pointer list
556 // //     if(fParticleMap) {     <----
557 // //       fParticleMap->Clear();
558 // //       fParticleMap->Expand(treeK->GetEntries());
559 // //     } else
560 // //       fParticleMap = new TObjArray(treeK->GetEntries());
561     
562 //     // From gAlice->Particle(i) 
563
564
565 // //   if(!(*fParticleMap)[i]) {
566 // //     Int_t nentries = fParticles->GetEntries();
567     
568 // //     // algorithmic way of getting entry index
569 // //     // (primary particles are filled after secondaries)
570 // //     Int_t entry;
571 // //     if (i<fHeader.GetNprimary())
572 // //       entry = i+fHeader.GetNsecondary();
573 // //     else 
574 // //       entry = i-fHeader.GetNprimary();
575       
576 // //     // only check the algorithmic way and give
577 // //     // the fatal error if it is wrong
578 // //     if (entry != fParticleFileMap[i]) {
579 // //       Fatal("Particle",
580 // //         "!!!! The algorithmic way is WRONG: !!!\n entry: %d map: %d",
581 // //   entry, fParticleFileMap[i]); 
582 // //     }  
583       
584 // //     fTreeK->GetEntry(fParticleFileMap[i]);
585 // //     new ((*fParticles)[nentries]) TParticle(*fParticleBuffer);
586 // //     fParticleMap->AddAt((*fParticles)[nentries],i);
587 // //   }
588 // //   return (TParticle *) (*fParticleMap)[i];
589
590    
591     
592 //   }
593
594
595 //   //scan over opened files and read corresponding TreeK##
596
597   return ;
598 }
599 //____________________________________________________________________________ 
600 void AliPHOSIndexToObject::GetEvent(Int_t event){
601   if(event == fEvent) // do nothing
602     return ;
603     
604   if(event > fMaxEvent){
605     cout << "There is no such event " << event << " total # of events " << fMaxEvent << endl ;
606     return ;
607   }
608
609   fEvent = event ;
610   gAlice->GetEvent(fEvent) ;
611   
612   ReadTreeS() ;
613   ReadTreeD() ;
614   ReadTreeR() ;
615   ReadPrimaries() ;
616
617   
618
619 }
620