Pi0 identification added
[u/mrichter/AliRoot.git] / PHOS / AliPHOSGetter.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 /* $Log:
19    29.05.2001 Yuri Kharlov:
20               Everywhere reading the treese TTree->GetEvent(i)
21               is replaced by reading the branches TBranch->GetEntry(0)
22 */
23 /* $Log:
24    08.2002 Dmitri Peressounko:
25
26 */
27
28 //_________________________________________________________________________
29 //  A singleton. This class should be used in the analysis stage to get 
30 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
31 //  instead of directly reading them from galice.root file. This container 
32 //  ensures, that one reads Digits, made of these particular digits, RecPoints, 
33 //  made of these particular RecPoints, TrackSegments and RecParticles. 
34 //  This becomes non trivial if there are several identical branches, produced with
35 //  different set of parameters. 
36 //
37 //  An example of how to use (see also class AliPHOSAnalyser):
38 //  AliPHOSGetter * gime = AliPHOSGetter::GetInstance("galice.root","test") ;
39 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
40 //     AliPHOSRecParticle * part = gime->RecParticle(1) ;
41 //     ................
42 //  gime->Event(event) ;    // reads new event from galice.root
43 //                  
44 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
45 //*--         Completely redesigned by Dmitri Peressounko March 2001  
46 //
47 //*-- YS June 2001 : renamed the original AliPHOSIndexToObject and make
48 //*--         systematic usage of TFolders without changing the interface        
49 //////////////////////////////////////////////////////////////////////////////
50
51 // --- ROOT system ---
52 #include "TFile.h"
53 #include "TTree.h"
54 #include "TROOT.h"
55 #include "TObjString.h"
56 #include "TFolder.h"
57 #include "TParticle.h"
58
59 // --- Standard library ---
60
61 // --- AliRoot header files ---
62 #include "AliRun.h"
63 #include "AliConfig.h"
64 #include "AliPHOSGetter.h"
65 #include "AliPHOS.h"
66 #include "AliPHOSDigitizer.h"
67 #include "AliPHOSSDigitizer.h"
68 #include "AliPHOSClusterizerv1.h"
69 #include "AliPHOSTrackSegmentMakerv1.h"
70 #include "AliPHOSTrackSegment.h"
71 #include "AliPHOSPIDv1.h" 
72 #include "AliPHOSGeometry.h"
73 #include "AliPHOSRaw2Digits.h"
74 #include "AliPHOSCalibrationDB.h"
75 ClassImp(AliPHOSGetter)
76   
77   AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ; 
78   TFile * AliPHOSGetter::fFile = 0 ; 
79
80 //____________________________________________________________________________ 
81 AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle, const Bool_t toSplit )
82 {
83   // This is the ctor called by GetInstance and the only one that can be used 
84
85   if( fHeaderFile.Contains("_") ) {
86     Fatal("AliPHOSGetter", "Invalid file name (_ not allowed) %s", fHeaderFile.Data() ) ;
87   }
88
89   //Initialize  all data
90
91   fFailed = kFALSE ;   
92   fDebug  = 0 ; 
93   fAlice  = 0 ; 
94
95   fToSplit    = toSplit ;
96   fHeaderFile = headerFile ; 
97
98   fPrimaries = new TObjArray(1) ;
99
100   fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules")); 
101   fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data")); 
102   fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits")); 
103   fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits")); 
104   fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data")); 
105   fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData")); 
106   fQAFolder        = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA")); 
107   fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ; 
108
109   //Set titles to branches and create PHOS specific folders
110   SetTitle(branchTitle) ;
111   
112   if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
113     //open headers file
114     fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
115     
116     if(!fFile) {    //if file was not opened yet, read gAlice
117       fFile = TFile::Open(fHeaderFile.Data(),"update") ; 
118       if (!fFile->IsOpen()) {
119         Error("AliPHOSGetter", "Cannot open %s", fHeaderFile.Data() ) ; 
120         fFailed = kTRUE ;
121         return ;  
122       }
123       gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
124     }       
125   }
126   
127   if (!gAlice) {
128     Error("AliPHOSGetter", "Cannot find gAlice in %s", fHeaderFile.Data() ) ; 
129     fFailed = kTRUE ;
130     return ; 
131   }
132   if (!PHOS()) {
133     if (fDebug)
134       Info("AliPHOSGetter", "-> Posting PHOS to Folders") ; 
135     if (gAlice->GetDetector("PHOS")) {
136       AliConfig * conf = AliConfig::Instance() ; 
137       conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("PHOS"))) ; 
138       conf->Add(static_cast<AliModule*>(gAlice->GetDetector("PHOS"))) ; 
139     }
140     else 
141       Error("AliPHOSGetter", "detector PHOS not found") ;    
142   }
143
144   fDebug=0;
145 }
146
147 //____________________________________________________________________________ 
148 AliPHOSGetter::~AliPHOSGetter(){
149
150   if (fPrimaries) {
151     fPrimaries->Delete() ; 
152     delete fPrimaries ; 
153   }
154
155   TFolder * phosF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
156   TCollection * folderslist = phosF->GetListOfFolders() ; 
157   TIter next(folderslist) ; 
158   TFolder * folder = 0 ; 
159   while ( (folder = static_cast<TFolder*>(next())) ) 
160     phosF->Remove(folder) ; 
161   
162   if (fFile) { 
163     fFile->Close() ;  
164     delete fFile ;
165     fFile = 0 ;
166   }
167   fgObjGetter = 0 ; 
168   
169 }
170
171 //____________________________________________________________________________ 
172 void AliPHOSGetter::CloseFile()
173 {
174   delete gAlice ;  
175   gAlice = 0 ; 
176   delete fAlice ; 
177   fAlice = 0 ; 
178 }
179
180 //____________________________________________________________________________ 
181 const TFolder * AliPHOSGetter::Folder(const TString what) const {
182
183   // returns the PHOS folder required by what
184   // what = hits, sdigits, digits
185
186   if ( what == "hits" ) 
187     return dynamic_cast<const TFolder *>(fHitsFolder->FindObject("PHOS")) ; 
188   else if ( what == "sdigits" ) 
189     return  dynamic_cast<const TFolder *>(fSDigitsFolder->FindObject("PHOS")) ; 
190   else if ( what == "digits" ) 
191     return  dynamic_cast<const TFolder *>(fDigitsFolder->FindObject("PHOS")) ; 
192   else {
193     Error("GetFolder", " %s illegal option (hits, sdigits, digits)", what.Data() ) ; 
194     return 0 ; 
195   }
196 }
197
198 //____________________________________________________________________________ 
199 AliPHOSGetter * AliPHOSGetter::GetInstance()
200 {
201   // Returns the pointer of the unique instance already defined
202   
203   if ( fgObjGetter ) {
204     return fgObjGetter ;
205   }
206   else {
207     //Warning("GetInstance", "not yet initialized") ;
208     return 0 ; 
209   }
210 }
211
212 //____________________________________________________________________________ 
213 AliPHOSGetter * AliPHOSGetter::GetInstance(const char* headerFile,
214                                            const char* branchTitle,
215                                            const Bool_t toSplit)
216 {
217   // Creates and returns the pointer of the unique instance
218   // Must be called only when the environment has changed
219
220   if(!fgObjGetter){
221     fgObjGetter = new AliPHOSGetter(headerFile,branchTitle,toSplit) ;
222     if(fgObjGetter->fFailed)
223       return 0;
224     else
225       return fgObjGetter ;
226   }
227
228   //First checks, if header file already opened
229   if(!fgObjGetter->fFile){
230      fgObjGetter = new AliPHOSGetter(headerFile,branchTitle,toSplit) ;
231     if(fgObjGetter->fFailed)
232       return 0;
233     else
234       return fgObjGetter ;
235   }
236
237   if(fgObjGetter->fHeaderFile.CompareTo(headerFile)==0){ //Opened the same header file
238     if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0)&&   //Open the same branch title
239        (toSplit==fgObjGetter->fToSplit)){                          //Nothing should be cleaned
240     }
241     else{ //Clean all data and AliPHOS...zers
242       if(fgObjGetter->fToSplit)
243         fgObjGetter->CloseSplitFiles() ;
244       fgObjGetter->CleanWhiteBoard() ;
245       fgObjGetter->fToSplit = toSplit ;
246       fgObjGetter->SetTitle(branchTitle) ;
247     }
248   }
249   else{  //Close already opened files, clean memory and open new header file
250     if(gAlice)
251       delete gAlice ;
252     gAlice= 0;
253     if(fgObjGetter->fFile){
254       fgObjGetter->fFile->Close() ;
255       fgObjGetter->fFile=0;
256     }
257     if(fgObjGetter->fToSplit)
258       fgObjGetter->CloseSplitFiles() ;
259     fgObjGetter->CleanWhiteBoard() ;    
260     fgObjGetter = new AliPHOSGetter(headerFile,branchTitle,toSplit) ;
261   }
262   return fgObjGetter ; 
263   
264 }
265
266 //____________________________________________________________________________ 
267 const Bool_t AliPHOSGetter::BranchExists(const TString recName) const
268 {
269   //Looks in the tree Tree"name" if branch with current name olready exists
270
271   TString filename("") ;
272   TString name, dataname, zername ;
273   if(recName == "SDigits"){
274     filename=fSDigitsFileName ;
275     name = "TreeS0" ;
276     dataname = "PHOS" ;
277     zername = "AliPHOSSDigitizer" ;
278   }
279   else
280     if(recName == "Digits"){
281       filename=fDigitsFileName ;
282       name = "TreeD0" ;
283       dataname = "PHOS" ;
284       zername = "AliPHOSDigitizer" ;
285     }
286     else
287       if(recName == "RecPoints"){
288         filename=fRecPointsFileName ;
289         name = "TreeR0" ;
290         dataname = "PHOSEmcRP" ;
291         zername = "AliPHOSClusterizer" ;
292       }
293       else
294         if(recName == "TrackSegments"){
295           filename=fTrackSegmentsFileName ;
296           name = "TreeR0" ;
297           dataname = "PHOSTS" ;
298           zername = "AliPHOSTrackSegmentMaker" ;
299         }        
300         else
301           if(recName == "RecParticles"){
302             filename= fRecParticlesFileName ;
303             name = "TreeR0" ;
304             dataname = "PHOSRP" ;
305             zername = "AliPHOSPID" ;
306           }
307           else
308             return kFALSE ;
309
310   TFile * file ;
311   TTree * tree ;
312   if(fToSplit){
313     file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
314     if(!file)
315       file = TFile::Open(fSDigitsFileName.Data(),"update");
316   }
317   else
318     file = fFile ;
319
320   tree = (TTree *)file->Get(name.Data()) ;
321   
322   if(!tree ) 
323     return kFALSE ;
324
325   TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
326   TIter next(lob) ; 
327   TBranch * branch = 0 ;  
328   TString titleName(fBranchTitle);
329   titleName+=":";
330   while ((branch = (static_cast<TBranch*>(next())))) {
331     TString branchName(branch->GetName() ) ; 
332     TString branchTitle(branch->GetTitle() ) ;  
333     if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
334       Warning("BranchExists", "branch %s with title %s already exists in %s", dataname.Data(), fBranchTitle.Data(), name.Data() ) ;
335       return kTRUE ;
336     }
337     if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
338       Warning("BranchExists", "branch AliPHOS... with title %s already exists in %s", branch->GetTitle(), name.Data() ) ;     
339       return kTRUE ; 
340     }
341   }
342   //We can't delete three if gAlice points to it... To be redisigned somehow???!!!
343   if(!fToSplit){
344     if(name.Contains("TreeS"))
345       if(tree!=gAlice->TreeS())
346         tree->Delete();
347     if(name.Contains("TreeD"))
348       if(tree!=gAlice->TreeD())
349         tree->Delete();
350     if(name.Contains("TreeR"))
351       if(tree!=gAlice->TreeR())
352         tree->Delete();    
353   }
354   return kFALSE ;
355   
356 }
357
358 //____________________________________________________________________________ 
359 void AliPHOSGetter::ListBranches(Int_t event) const  
360 {
361   
362   TBranch * branch = 0 ; 
363   if (gAlice->GetEvent(event) == -1)
364     return ; 
365   
366   TTree * t =  gAlice->TreeH() ; 
367   if(t){
368     Info("ListBranches", "-> ****** Hits    : ") ; 
369     TObjArray * lob = t->GetListOfBranches() ;
370     TIter next(lob) ; 
371     while ( (branch = static_cast<TBranch*>(next())) )
372       Info("ListBranches", "             %s", branch->GetName()) ; 
373   } else
374     Warning("ListBranches", "TreeH not found for event %d", event ) ;  
375   
376   t = gAlice->TreeS() ;
377   if(t){
378     Info("ListBranches", "-> ****** SDigits : ") ; 
379     TObjArray * lob = t->GetListOfBranches() ;
380     TIter next(lob) ; 
381     while ( (branch = static_cast<TBranch*>(next())) )
382       Info("ListBranches", "             %s %s", branch->GetName(), branch->GetTitle()) ; 
383   } else 
384     Warning("ListBranches", "TreeS not found for event %d", event)  ;  
385   
386   
387   t = gAlice->TreeD() ;
388   if(t){
389     Info("ListBranches", "-> ****** Digits  : ") ; 
390     TObjArray * lob = t->GetListOfBranches() ;
391     TIter next(lob) ; 
392     while ( (branch = static_cast<TBranch*>(next())) )
393       Info("ListBranches", "             %s %s", branch->GetName(), branch->GetTitle()) ; 
394   } else 
395     Warning("ListBranches", "TreeD not found for event %d", event) ;  
396   
397
398   t = gAlice->TreeR() ;
399   if(t){
400     Info("ListBranches", "-> ****** Recon   : ") ; 
401     TObjArray * lob = t->GetListOfBranches() ;
402     TIter next(lob) ; 
403     while ( (branch = static_cast<TBranch*>(next())) )
404      Info("ListBranches", "             %s %s", branch->GetName(), branch->GetTitle()) ; 
405   } else 
406     Warning("ListBranches", "TreeR not found for event %d", event) ;  
407   
408 }
409
410 //____________________________________________________________________________ 
411 void AliPHOSGetter::NewBranch(TString name, Int_t event)  
412 {
413   fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle =  name ; 
414   Event(event) ; 
415 }
416
417 //____________________________________________________________________________ 
418 Bool_t AliPHOSGetter::NewFile(TString name)  
419 {
420   fHeaderFile = name ; 
421   fFile->Close() ; 
422   fFailed = kFALSE; 
423
424   fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
425   if(!fFile) {    //if file was not opened yet, read gAlice
426     fFile = TFile::Open(fHeaderFile.Data(),"update") ;
427     if (!fFile->IsOpen()) {
428       Error("NewFile", "Cannot open %s", fHeaderFile.Data() ) ; 
429       fFailed = kTRUE ;
430       return fFailed ;  
431     }
432     gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
433   } 
434   
435   if (!gAlice) {
436     Error("AliPHOSGetter", "Cannot find gAlice in %s", fHeaderFile.Data() ) ; 
437     fFailed = kTRUE ;
438     return fFailed ; 
439   }
440   return fFailed ; 
441 }
442
443 //____________________________________________________________________________ 
444 const AliPHOS * AliPHOSGetter::PHOS() 
445 {
446   // returns the PHOS object 
447   AliPHOS * phos = dynamic_cast<AliPHOS*>(fModuleFolder->FindObject("PHOS")) ;  
448   if (!phos) 
449     if (fDebug)
450       Warning("PHOS", "-> PHOS module not found in Folders") ; 
451   return phos ; 
452 }  
453
454 //____________________________________________________________________________ 
455 const AliPHOSGeometry * AliPHOSGetter::PHOSGeometry() 
456 {
457   AliPHOSGeometry * rv = 0 ; 
458   if (PHOS() )
459     rv =  PHOS()->GetGeometry() ;
460   return rv ; 
461
462
463 //____________________________________________________________________________ 
464 const Bool_t AliPHOSGetter::PostPrimaries(void) const 
465 {  //------- Primaries ----------------------
466
467   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
468   
469   TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ; 
470   if ( !primariesFolder ) {
471     if (fDebug) {
472       Warning("PostPrimaries", "-> Folder //%s/Primaries/ not found!", fPrimariesFolder->GetName()) ;
473       Info("PostPrimaries", "-> Adding Folder //%s/Primaries", fPrimariesFolder->GetName()) ;
474     }
475     primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ; 
476   }    
477   TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
478   primaries->SetName("Primaries") ;
479   primariesFolder->Add(primaries) ; 
480   
481   return kTRUE;
482
483
484 //____________________________________________________________________________ 
485 TObject** AliPHOSGetter::PrimariesRef(void) const 
486 {  //------- Primaries ----------------------
487
488   
489   // the hierarchy is //Folders/RunMC/Event/Data/Primaries
490   if ( !fPrimariesFolder ) {
491     Fatal("PrimariesRef", "Folder //%s not found", fPrimariesFolder) ;
492   }    
493  
494   TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
495   if ( !primariesFolder ) {
496     Fatal("PrimariesRef", "Folder //%s/Primaries/ not found", fPrimariesFolder) ;  
497   }
498  
499   TObject * p = primariesFolder->FindObject("Primaries") ;
500   if(!p) {
501     Fatal("PrimariesRef","%s /Primaries not found !", primariesFolder->GetName() ) ; 
502   }
503
504   return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
505 }
506
507 //____________________________________________________________________________ 
508 const Bool_t AliPHOSGetter::PostHits(void) const 
509 {  //------- Hits ----------------------
510
511   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/Hits
512   
513   TFolder * phosFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ; 
514   if ( !phosFolder ) {
515     if (fDebug) {
516       Warning("PostHits", "-> Folder //%s/PHOS/ not found!", fHitsFolder) ;
517       Info("PostHits", "-> Adding Folder //%s/PHOS/", fHitsFolder) ;
518     }
519     phosFolder = fHitsFolder->AddFolder("PHOS", "Hits from PHOS") ; 
520   }    
521   TClonesArray *hits=  new TClonesArray("AliPHOSHit",1000) ;
522   hits->SetName("Hits") ;
523   phosFolder->Add(hits) ; 
524   
525   return kTRUE;
526
527
528 //____________________________________________________________________________ 
529 TObject** AliPHOSGetter::HitsRef(void) const 
530 {  //------- Hits ----------------------
531
532   
533   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/Hits
534   if ( !fHitsFolder ) {
535     Fatal("HitsRef", "Folder //%s not found !", fHitsFolder) ;
536   }    
537  
538   TFolder * phosFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("PHOS")) ;
539   if ( !phosFolder ) {
540     Fatal("HitsRef", "Folder //%s/PHOS/ not found !", fHitsFolder) ;  
541   }
542  
543   TObject * h = phosFolder->FindObject("Hits") ;
544   if(!h) {
545     Fatal("HitsRef", "%s/Hits not fount !", phosFolder->GetName() ) ; 
546   }
547
548   return phosFolder->GetListOfFolders()->GetObjectRef(h) ;
549 }
550
551 //____________________________________________________________________________ 
552 const Bool_t AliPHOSGetter::PostSDigits(const char * name, const char * headerFile) const 
553 {  //---------- SDigits -------------------------
554
555   
556   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/SDigits/headerFile/sdigitsname
557   // because you can have sdigits from several hit files for mixing
558   
559   TFolder * phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
560   if ( !phosFolder ) {
561     if (fDebug) {
562       Warning("PostSDigits", "-> Folder //%s/PHOS/ not found!", fSDigitsFolder) ;
563       Info("PostSDigits", "-> Adding Folder //%s/PHOS/", fHitsFolder) ;
564     }
565     phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
566   }    
567
568   TString subdir(headerFile) ;
569   subdir.ReplaceAll("/","_") ; 
570   TFolder * phosSubFolder = dynamic_cast<TFolder*>(phosFolder->FindObject(subdir)) ; 
571   if ( !phosSubFolder ) 
572     phosSubFolder = phosFolder->AddFolder(subdir, ""); 
573   
574
575   TObject * sd  = phosSubFolder->FindObject(name); 
576   if ( !sd ) {
577     TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1) ;
578     sdigits->SetName(name) ;
579     phosSubFolder->Add(sdigits) ;
580   }
581   
582   return kTRUE;
583
584 //____________________________________________________________________________ 
585 TObject** AliPHOSGetter::SDigitsRef(const char * name, const char * file) const 
586 {  //------- SDigits ----------------------
587   
588   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/SDigits/filename/SDigits
589
590   if ( !fSDigitsFolder ) {
591     Fatal("SDigitsRef", "Folder //%s not found !", fSDigitsFolder) ;
592   }    
593  
594   TFolder * phosFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
595   if ( !phosFolder ) {
596     Fatal("SDigitsRef", "Folder //%s/PHOS not found !", fSDigitsFolder) ;
597   }
598
599   TFolder * phosSubFolder = 0 ;
600   if(file)
601     phosSubFolder = dynamic_cast<TFolder *>(phosFolder->FindObject(file)) ;
602   else
603     phosSubFolder = dynamic_cast<TFolder *>(phosFolder->FindObject(fHeaderFile)) ;
604   
605   if(!phosSubFolder) {
606     Fatal("SDigitsRef", "Folder //Folders/RunMC/Event/Data/PHOS/%s not found !", file) ;
607   }
608
609   TObject * dis = phosSubFolder->FindObject(name) ;
610   if(!dis){
611     Fatal("SDigitsRef", "object %s not found !", name) ; 
612   }
613
614   return phosSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
615
616 }
617
618 //____________________________________________________________________________ 
619 const Bool_t AliPHOSGetter::PostSDigitizer(AliPHOSSDigitizer * sdigitizer) const 
620 {  //---------- SDigitizer -------------------------
621     
622   // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
623
624
625   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
626
627   if ( !sd ) {
628     Error("PostDigitizer", "Task //%s/SDigitizer not found !", fTasksFolder) ;
629     return kFALSE ;
630   }        
631   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
632   if ( !phos )  {
633     if (fDebug) {
634       Warning("PostSDigitizer", "->//%s/SDigitizer/PHOS/ not found!", fTasksFolder) ;  
635       Info("PostSDigitizer", "-> Adding //%s/SDigitizer/PHOS/", fTasksFolder) ;
636     }
637     phos = new TTask("PHOS", "") ; 
638     sd->Add(phos) ; 
639   } 
640   AliPHOSSDigitizer * phossd  = dynamic_cast<AliPHOSSDigitizer *>(phos->GetListOfTasks()->FindObject( sdigitizer->GetName() )); 
641   if (phossd) { 
642     if (fDebug)
643       Info("PostSDigitizer", "-> Task %s already exists", sdigitizer->GetName()) ; 
644     phos->GetListOfTasks()->Remove(phossd) ;
645   }
646   phos->Add(sdigitizer) ;       
647   return kTRUE; 
648   
649 }
650
651 //____________________________________________________________________________ 
652 TObject** AliPHOSGetter::SDigitizerRef(const char * name) const 
653 {  
654
655   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
656   if ( !sd ) {
657     Fatal("SDigitizerRef", "Task //%s/SDigitizer not found !", fTasksFolder) ;
658   }        
659
660   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
661   if ( !phos )  {
662     Fatal("SDigitizerRef", "//%s/SDigitizer/PHOS not found !", fTasksFolder) ;
663   }        
664
665   TTask * task = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(name)) ; 
666
667   return phos->GetListOfTasks()->GetObjectRef(task) ;
668
669 }
670
671 //____________________________________________________________________________ 
672 const Bool_t AliPHOSGetter::PostSDigitizer(const char * name, const char * file) const 
673 {  //---------- SDigitizer -------------------------
674   
675  // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
676
677   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
678   if ( !sd ) {
679     Error("PostSDigitizer", "Task //%s/SDigitizer not found !", fTasksFolder) ;
680     return kFALSE ;
681   }        
682
683   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
684   if ( !phos )  {
685     if (fDebug) {
686       Error("PostSDigitizer", "->  //%s/SDigitizer/PHOS/ not found!", fTasksFolder) ;
687       Info("PostSDigitizer", "-> Adding  //%s/SDigitizer/PHOS", fTasksFolder) ;
688     }
689     phos = new TTask("PHOS", "") ; 
690     sd->Add(phos) ; 
691   } 
692
693   TString sdname(name) ;
694   sdname.Append(":") ;
695   sdname.Append(file);
696   sdname.ReplaceAll("/","_") ; 
697   AliPHOSSDigitizer * phossd  = dynamic_cast<AliPHOSSDigitizer *>(phos->GetListOfTasks()->FindObject( sdname )); 
698   if (!phossd) {
699     phossd = new AliPHOSSDigitizer() ;  
700     //Note, we can not call constructor with parameters: it will call Getter and scew up everething
701     phossd->SetName(sdname) ;
702     phossd->SetTitle(file) ;
703     phos->Add(phossd) ; 
704   }
705   return kTRUE; 
706   
707 }
708
709 //____________________________________________________________________________ 
710 const Bool_t AliPHOSGetter::PostDigits(const char * name) const 
711 {  //---------- Digits -------------------------
712
713   // the hierarchy is //Folders/Run/Event/Data/PHOS/SDigits/name
714
715   TFolder * phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
716
717   if ( !phosFolder ) {
718     if (fDebug) {
719       Warning("PostDigitizer", "-> Folder //%s/PHOS/ not found!", fDigitsFolder) ;
720       Info("PostDigitizer", "-> Adding Folder //%s/PHOS/", fDigitsFolder) ;
721     }
722     phosFolder = fDigitsFolder->AddFolder("PHOS", "Digits from PHOS") ;  
723   }    
724  
725   TObject*  dig = phosFolder->FindObject( name ) ;
726   if ( !dig ) {
727     TClonesArray * digits = new TClonesArray("AliPHOSDigit",1000) ;
728     digits->SetName(name) ;
729     phosFolder->Add(digits) ;  
730   }
731   return kTRUE; 
732 }
733
734 //____________________________________________________________________________ 
735 TObject** AliPHOSGetter::DigitsRef(const char * name) const 
736 { //------- Digits ----------------------
737   
738   // the hierarchy is //Folders/Run/Event/Data/PHOS/Digits/name
739
740   if ( !fDigitsFolder ) {
741     Fatal("DigitsRef", "Folder //%s not found !", fDigitsFolder) ;
742   }    
743   
744   TFolder * phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ; 
745   if ( !phosFolder ) {
746     Fatal("DigitsRef", "Folder //%s/PHOS/ not found !", fDigitsFolder) ;
747   }    
748
749   TObject * d = phosFolder->FindObject(name) ;
750   if(!d) {
751     Fatal("DigitsRef", "object %s not found !", name) ; 
752   }
753
754   return phosFolder->GetListOfFolders()->GetObjectRef(d) ;
755
756 }
757
758 //____________________________________________________________________________ 
759 const Bool_t AliPHOSGetter::PostDigitizer(AliPHOSDigitizer * digitizer) const 
760 {  //---------- Digitizer -------------------------
761   
762   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
763
764   if ( !sd ) {
765     Error("PostDigitizer", "Task //%s/Digitizer not found !", fTasksFolder) ;
766     return kFALSE ;
767   }        
768   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
769   if ( !phos )  {
770     if (fDebug) {
771       Error("PostDigitizer", "//%s/Digitizer/PHOS not found!", fTasksFolder) ;
772       Info("PostDigitizer", "Adding //%s/Digitizer/PHOS", fTasksFolder) ; 
773     }
774     phos = new TTask("PHOS", "") ; 
775     sd->Add(phos) ; 
776   } 
777
778     AliPHOSDigitizer * phosd = dynamic_cast<AliPHOSDigitizer*>(phos->GetListOfTasks()->FindObject(digitizer->GetName())) ; 
779     if (phosd) { 
780       phosd->Delete() ;
781       phos->GetListOfTasks()->Remove(phosd) ;
782     }
783     phos->Add(digitizer) ; 
784     return kTRUE; 
785 }  
786
787 //____________________________________________________________________________ 
788 const Bool_t AliPHOSGetter::PostDigitizer(const char * name) const 
789 {  //---------- Digitizer -------------------------
790   
791  // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
792
793   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
794   if ( !d ) {
795     Error("PostDigitizer", "Task //%s/Digitizer not found !", fTasksFolder) ;
796     return kFALSE ;
797   }        
798
799   TTask * phos = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("PHOS")) ; 
800   if ( !phos )  {
801     if (fDebug) {
802       Warning("PostDigitizer", "//%s/Digitizer/PHOS not found!", fTasksFolder) ; 
803       Info("PostDigitizer", "Adding //%s/Digitizer/PHOS", fTasksFolder) ;
804     }
805     phos = new TTask("PHOS", "") ; 
806     d->Add(phos) ; 
807
808
809   TTask * phosd = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(fDigitsTitle)) ; 
810   if (!phosd) { 
811     if(strcmp(name, "Digitizer")==0){
812       phosd = new AliPHOSDigitizer() ;
813       phosd->SetName(fDigitsTitle) ;
814       phosd->SetTitle(fHeaderFile) ;
815       phos->Add(phosd) ;
816     } 
817     else{
818       phosd = new AliPHOSRaw2Digits() ;
819       phosd->SetName(fDigitsTitle) ;
820       phosd->SetTitle(fHeaderFile) ;
821       phos->Add(phosd) ;
822     }      
823   }
824   return kTRUE;  
825 }
826
827 //____________________________________________________________________________ 
828 TObject** AliPHOSGetter::DigitizerRef(const char * name) const 
829 {  
830   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
831   if ( !sd ) {
832     Fatal("DigitizerRef", "Task //%s/Digitizer not found !", fTasksFolder) ;
833   }        
834
835   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
836   if ( !phos )  {
837     Fatal("DigitizerRef", "//%s/Digitizer/PHOS", fTasksFolder) ;
838   }        
839
840   TTask * task = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(name)) ; 
841
842   return phos->GetListOfTasks()->GetObjectRef(task) ;
843
844 }
845  
846 //____________________________________________________________________________ 
847 const Bool_t AliPHOSGetter::PostRecPoints(const char * name) const 
848 { // -------------- RecPoints -------------------------------------------
849   
850   // the hierarchy is //Folders/Run/Event/RecData/PHOS/EMCARecPoints/name
851   // the hierarchy is //Folders/Run/Event/RecData/PHOS/CPVRecPoints/name
852
853   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
854   
855   if ( !phosFolder ) {
856     if (fDebug) {
857       Warning("PostRecPoints", "-> Folder //%s/PHOS/ not found!", fRecoFolder->GetName()) ;
858       Info("PostRecPoints", "-> Adding Folder //%s/PHOS/", fRecoFolder->GetName()) ;
859     }
860     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
861   }    
862   
863   // EMCA RecPoints 
864   TFolder * phosRPoEMCAFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("EMCARecPoints")) ;
865   if ( !phosRPoEMCAFolder ) {
866     if (fDebug) {
867       Warning("PostRecPoints", "-> Folder //%s/PHOS/EMCARecPoints/ not found!", fRecoFolder->GetName()) ;
868       Info("PostRecPoints", "-> Adding Folder //%s/PHOS/EMCARecPoints", fRecoFolder->GetName()) ;
869     }
870     phosRPoEMCAFolder = phosFolder->AddFolder("EMCARecPoints", "EMCA RecPoints from PHOS") ;  
871   }    
872   
873   TObject * erp = phosFolder->FindObject( name ) ;
874   if ( !erp )   {
875     TObjArray * emcrp = new TObjArray(100) ;
876     emcrp->SetName(name) ;
877     phosRPoEMCAFolder->Add(emcrp) ;  
878   }
879
880   // CPV RecPoints 
881   TFolder * phosRPoCPVFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("CPVRecPoints")) ;
882   if ( !phosRPoCPVFolder ) {
883     if (fDebug) {
884       Warning("PostRecPoints", "-> Folder //%s/PHOS/CPVRecPoints/ not found!", fRecoFolder->GetName()) ;
885       Info("PostRecPoints", "-> Adding Folder //%s/PHOS/CPVRecPoints/", fRecoFolder->GetName()) ;
886     }
887     phosRPoCPVFolder = phosFolder->AddFolder("CPVRecPoints", "CPV RecPoints from PHOS") ;  
888   }    
889   
890   TObject * crp =  phosRPoCPVFolder->FindObject( name ) ;
891   if ( !crp )   {
892     TObjArray * cpvrp = new TObjArray(100) ;
893     cpvrp->SetName(name) ;
894     phosRPoCPVFolder->Add(cpvrp) ;  
895   }
896   return kTRUE; 
897 }
898
899 //____________________________________________________________________________ 
900 TObject** AliPHOSGetter::EmcRecPointsRef(const char * name) const 
901 { // -------------- RecPoints -------------------------------------------
902   
903   // the hierarchy is //Folders/Run/Event/RecData/PHOS/EMCARecPoints/name
904    
905   if ( !fRecoFolder ) {
906     Fatal("EmcRecPointsRef", "Folder //%s not found !", fRecoFolder->GetName() ) ;
907   }    
908
909   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ; 
910   if ( !phosFolder ) {
911      Fatal("EmcRecPointsRef", "Folder //%s/PHOS/EMCARecPoints/ not found !", fRecoFolder->GetName() ) ;
912   }    
913
914
915   TObject * erp = phosFolder->FindObject(name ) ;
916   if ( !erp )   {
917     Fatal("EmcRecPointsRef", "object %s not found !", name) ; 
918   }
919   return phosFolder->GetListOfFolders()->GetObjectRef(erp) ;
920   
921
922
923 //____________________________________________________________________________ 
924 TObject** AliPHOSGetter::CpvRecPointsRef(const char * name) const 
925 { // -------------- RecPoints -------------------------------------------
926   
927   // the hierarchy is //Folders/Run/Event/RecData/PHOS/CPVRecPoints/name
928    
929   if ( !fRecoFolder ) {
930     Fatal("CpvRecPointsRef", "Folder //%s not found !", fRecoFolder->GetName() ) ;
931   }    
932
933   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ; 
934   if ( !phosFolder ) {
935     Fatal("CpvRecPointsRef", "Folder //%s/PHOS/CPVRecPoints/ not found !", fRecoFolder->GetName() ) ;
936   }    
937
938   TObject * crp = phosFolder->FindObject(name ) ;
939   if ( !crp )   {
940     Fatal("CpvRecPointsRef", "object %s nott found", name ) ; 
941   }
942   return phosFolder->GetListOfFolders()->GetObjectRef(crp) ;
943   
944
945
946 //____________________________________________________________________________ 
947 const Bool_t AliPHOSGetter::PostClusterizer(AliPHOSClusterizer * clu) const 
948 { // ------------------ AliPHOSClusterizer ------------------------
949   
950   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
951
952   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
953
954   if ( !tasks ) {
955     Error("PostClusterizer", "Task //%s/Reconstructioner not found !", fTasksFolder) ;
956     return kFALSE ;
957   }        
958         
959   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
960   if ( !phos )  {
961     if (fDebug) {
962       Warning("PostClusterizer", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ; 
963       Info("PostClusterizer", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ; 
964     }
965     phos = new TTask("PHOS", "") ; 
966     tasks->Add(phos) ; 
967   } 
968
969   AliPHOSClusterizer * phoscl = dynamic_cast<AliPHOSClusterizer*>(phos->GetListOfTasks()->FindObject(clu->GetName())) ; 
970   if (phoscl) { 
971     if (fDebug)
972       Info("PostClusterizer", "Task %s already exists", clu->GetName()) ; 
973     phoscl->Delete() ; 
974     phos->GetListOfTasks()->Remove(phoscl) ;
975   }
976   phos->Add(clu) ;      
977   return kTRUE; 
978
979
980 //____________________________________________________________________________ 
981 TObject** AliPHOSGetter::ClusterizerRef(const char * name) const 
982 { // ------------------ AliPHOSClusterizer ------------------------
983   
984   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
985
986   if ( !tasks ) {
987     Fatal("ClusterizerRef", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
988   }        
989         
990   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
991   if ( !phos )  {
992     Fatal("ClusterizerRef", " //%s/Reconstructioner/PHOS not founf !", fTasksFolder->GetName() ) ; 
993   }   
994
995   TList * l = phos->GetListOfTasks() ; 
996   TIter it(l) ;
997   TTask * task ;
998   TTask * clu = 0 ;
999   TString cluname(name) ;
1000   cluname+=":clu" ;
1001   while((task = static_cast<TTask *>(it.Next()) )){
1002     TString taskname(task->GetName()) ;
1003     if(taskname.BeginsWith(cluname)){
1004       clu = task ;
1005       break ;
1006     }
1007   }
1008
1009   if(!clu) {
1010     Fatal("ClusterizerRef", "Task //%s/Reconstructioner/clusterizer/%s not found", fTasksFolder->GetName(), name) ;
1011   }
1012
1013   return l->GetObjectRef(clu) ;
1014
1015 }
1016
1017 //____________________________________________________________________________ 
1018 const Bool_t AliPHOSGetter::PostClusterizer(const char * name) const 
1019 { // ------------------ AliPHOSClusterizer ------------------------
1020
1021   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1022   
1023   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1024
1025   if ( !tasks ) {
1026     Error("PostClusterizer", "Task//%s/Reconstructioner not found !", fTasksFolder) ; 
1027     return kFALSE ;
1028   }        
1029   
1030   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1031   if ( !phos )  {
1032     if (fDebug) {
1033       Warning("PostClusterizer", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ;
1034       Info("PostClusterizer", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ;
1035     }
1036     phos = new TTask("PHOS", "") ; 
1037     tasks->Add(phos) ; 
1038   } 
1039
1040   TList * l = phos->GetListOfTasks() ;   
1041   TIter it(l) ;
1042   TString clun(name) ;
1043   clun+=":clu" ; 
1044   TTask * task ;
1045   while((task = static_cast<TTask *>(it.Next()) )){
1046     TString taskname(task->GetName()) ;
1047     if(taskname.BeginsWith(clun))
1048       return kTRUE ;
1049   }
1050
1051   AliPHOSClusterizerv1 * phoscl = new AliPHOSClusterizerv1() ;
1052   clun+="-v1" ; 
1053   phoscl->SetName(clun) ;
1054   phoscl->SetTitle(fHeaderFile) ;
1055   phos->Add(phoscl) ;
1056   return kTRUE; 
1057   
1058 }
1059
1060 //____________________________________________________________________________ 
1061 const Bool_t AliPHOSGetter::PostTrackSegments(const char * name) const 
1062 { // ---------------TrackSegments -----------------------------------
1063   
1064   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1065
1066   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
1067   
1068   if ( !phosFolder ) {
1069     if (fDebug) {
1070       Warning("PostTrackSegments", "-> Folder //%s/PHOS/ not found", fRecoFolder->GetName()) ;
1071       Info("PostTrackSegments", "-> Adding Folder //%s/PHOS", fRecoFolder->GetName()) ;
1072     }
1073     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
1074   }    
1075
1076   TFolder * phosTSFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("TrackSegments")) ;
1077   if ( !phosTSFolder ) {
1078     if (fDebug) {
1079       Warning("PostTrackSegments", "-> Folder //%s/PHOS/TrackSegments/ not found!", fRecoFolder->GetName() ) ; 
1080       Info("PostTrackSegments", "-> Adding Folder //%s/PHOS/TrackSegments/", fRecoFolder->GetName()) ; 
1081     }
1082     phosTSFolder = phosFolder->AddFolder("TrackSegments", "TrackSegments from PHOS") ;  
1083   }    
1084   
1085   TObject * tss =  phosTSFolder->FindObject( name ) ;
1086   if (!tss) {
1087     TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
1088     ts->SetName(name) ;
1089     phosTSFolder->Add(ts) ;  
1090   }
1091   return kTRUE; 
1092
1093
1094 //____________________________________________________________________________ 
1095 TObject** AliPHOSGetter::TrackSegmentsRef(const char * name) const 
1096 { // ---------------TrackSegments -----------------------------------
1097   
1098   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1099
1100  if ( !fRecoFolder ) {
1101     Fatal("TrackSegmentsRef", "Folder //%s not found !", fRecoFolder->GetName() ) ;
1102   }    
1103
1104   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ; 
1105   if ( !phosFolder ) {
1106     Fatal("TrackSegmentsRef", "Folder //%s/PHOS/TrackSegments/ not found !", fRecoFolder->GetName() ) ;
1107   }    
1108   
1109   TObject * tss =  phosFolder->FindObject(name) ;
1110   if (!tss) {
1111     Fatal("TrackSegmentsRef", "object %s not found !", name) ;  
1112   }
1113   return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
1114
1115
1116 //____________________________________________________________________________ 
1117 const Bool_t AliPHOSGetter::PostTrackSegmentMaker(AliPHOSTrackSegmentMaker * tsmaker) const 
1118 { //------------Track Segment Maker ------------------------------
1119   
1120   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1121
1122   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1123
1124   if ( !tasks ) {
1125     Error("PostTrackSegmentMaker", "Task //%s/Reconstructioner not found !", fTasksFolder) ;
1126     return kFALSE ;
1127   }        
1128         
1129   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1130   if ( !phos )  {
1131     if (fDebug) {
1132       Warning("PostTrackSegmentMaker", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ; 
1133       Info("PostTrackSegmentMaker", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ;
1134     }
1135     phos = new TTask("PHOS", "") ; 
1136     tasks->Add(phos) ; 
1137   } 
1138
1139   AliPHOSTrackSegmentMaker * phosts = 
1140     dynamic_cast<AliPHOSTrackSegmentMaker*>(phos->GetListOfTasks()->FindObject(tsmaker->GetName())) ; 
1141   if (phosts) { 
1142     phosts->Delete() ;
1143     phos->GetListOfTasks()->Remove(phosts) ;
1144   }
1145   phos->Add(tsmaker) ;      
1146   return kTRUE; 
1147   
1148
1149 //____________________________________________________________________________ 
1150 const Bool_t AliPHOSGetter::PostTrackSegmentMaker(const char * name) const 
1151 { //------------Track Segment Maker ------------------------------
1152   
1153   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1154   
1155   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1156   
1157   if ( !tasks ) {
1158     Error("PostTrackSegmentMaker", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1159     return kFALSE ;
1160   }        
1161   
1162   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1163   if ( !phos )  {
1164     if (fDebug) {
1165       Warning("PostTrackSegmentMaker", "//%s/Reconstructioner/PHOS not found!", fTasksFolder->GetName() ) ; 
1166       Info("PostTrackSegmentMaker", "Adding //%s/Reconstructioner/PHOS", fTasksFolder->GetName()) ;
1167     }
1168     phos = new TTask("PHOS", "") ; 
1169     tasks->Add(phos) ; 
1170   } 
1171
1172   TList * l = phos->GetListOfTasks() ;   
1173   TIter it(l) ;
1174   TString tsn(name);
1175   tsn+=":tsm" ; 
1176   TTask * task ;
1177   while((task = static_cast<TTask *>(it.Next()) )){
1178     TString taskname(task->GetName()) ;
1179     if(taskname.BeginsWith(tsn))
1180       return kTRUE ;
1181   }
1182   
1183   AliPHOSTrackSegmentMakerv1 * phosts = new AliPHOSTrackSegmentMakerv1() ;
1184   tsn+="-v1" ;
1185   phosts->SetName(tsn) ;
1186   phosts->SetTitle(fHeaderFile) ;
1187   phos->Add(phosts) ;      
1188   return kTRUE; 
1189   
1190
1191
1192 //____________________________________________________________________________ 
1193 TObject** AliPHOSGetter::TSMakerRef(const char * name) const 
1194 { //------------Track Segment Maker ------------------------------
1195   
1196   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1197
1198   if ( !tasks ) {
1199     Fatal("TSMakerRef", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1200   }        
1201         
1202   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1203   if ( !phos )  {
1204     Fatal("TSMakerRef", "//%s/Reconstructioner/PHOS not found !", fTasksFolder->GetName() ) ; 
1205   }   
1206
1207   TList * l = phos->GetListOfTasks() ; 
1208   TIter it(l) ;
1209   TTask * task ;
1210   TTask * tsm = 0 ;
1211   TString tsmname(name) ;
1212   tsmname+=":tsm" ;
1213   while((task = static_cast<TTask *>(it.Next()) )){
1214     TString taskname(task->GetName()) ;
1215     if(taskname.BeginsWith(tsmname)){
1216       tsm = task ;
1217       break ;
1218     }
1219   }
1220   
1221   if(!tsm) {
1222    Fatal("TSMakerRef", "Task //%s/Reconstructioner/PHOS/TrackSegmentMarker/%s not found !", fTasksFolder->GetName(),  name) ;
1223   }
1224  
1225   return l->GetObjectRef(tsm) ;
1226
1227
1228
1229 //____________________________________________________________________________ 
1230 const Bool_t AliPHOSGetter::PostRecParticles(const char * name) const 
1231 {  // -------------------- RecParticles ------------------------
1232   
1233   // the hierarchy is //Folders/Run/Event/RecData/PHOS/RecParticles/name
1234
1235   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
1236   
1237   if ( !phosFolder ) {
1238     if (fDebug) {
1239       Warning("PostRecParticles", "-> Folder //%s/PHOS/ not found!", fRecoFolder->GetName()) ;
1240       Info("PostRecParticles", "-> Adding Folder //%s/PHOS/", fRecoFolder->GetName()) ;
1241     }
1242     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
1243   }    
1244
1245  TFolder * phosRPaFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("RecParticles")) ;
1246   if ( !phosRPaFolder ) {
1247     if (fDebug) {
1248       Warning("PostRecParticles", "-> Folder //%s/PHOS/RecParticles/ not found!", fRecoFolder->GetName()) ;
1249       Info("PostRecParticles", "-> Adding Folder //%s/PHOS/RecParticles/", fRecoFolder->GetName()) ;
1250     }
1251     phosRPaFolder = phosFolder->AddFolder("RecParticles", "RecParticles from PHOS") ;  
1252   } 
1253
1254   TObject * rps = phosRPaFolder->FindObject( name )  ;
1255   if ( !rps ) {
1256     TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
1257     rp->SetName(name) ;    
1258     phosRPaFolder->Add(rp) ;  
1259   }
1260   return kTRUE; 
1261
1262
1263 //____________________________________________________________________________ 
1264 TObject** AliPHOSGetter::RecParticlesRef(const char * name) const 
1265 { // ---------------RecParticles -----------------------------------
1266   
1267   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1268
1269  if ( !fRecoFolder ) {
1270     Fatal("RecParticlesRef", "Folder//%s not found !", fRecoFolder->GetName() ) ; 
1271   }    
1272
1273   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ; 
1274   if ( !phosFolder ) {
1275     Fatal("RecParticlesRef", "Folder //%s/PHOS/RecParticles/ not found !", fRecoFolder->GetName() ) ;
1276   }    
1277
1278   TObject * tss =  phosFolder->FindObject(name  ) ;
1279   if (!tss) {
1280     Fatal("RecParticlesRef", "object %s not found !", name) ; 
1281   }
1282   return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
1283 }
1284
1285 //____________________________________________________________________________ 
1286 const Bool_t AliPHOSGetter::PostPID(AliPHOSPID * pid) const 
1287 {      // ------------AliPHOS PID -----------------------------
1288
1289   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1290
1291   if ( !tasks ) {
1292     Error("PostPID", "Task //%s/Reconstructioner not found !", fTasksFolder) ;
1293     return kFALSE ;
1294   }        
1295   
1296   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1297   if ( !phos )  {
1298     if (fDebug) {
1299       Warning("PostPID", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ; 
1300       Info("PostPID", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ;
1301     }
1302     phos = new TTask("PHOS", "") ; 
1303     tasks->Add(phos) ; 
1304   } 
1305
1306   AliPHOSPID * phospid = dynamic_cast<AliPHOSPID*>(phos->GetListOfTasks()->FindObject(pid->GetName())) ; 
1307   if (phospid) { 
1308     if (fDebug)
1309       Info("PostPID", "-> Task %s qlready exists", pid->GetName()) ; 
1310     phos->GetListOfTasks()->Remove(phospid) ;
1311   }
1312   
1313   phos->Add(pid) ;      
1314   return kTRUE; 
1315
1316
1317 //____________________________________________________________________________ 
1318 const Bool_t AliPHOSGetter::PostPID(const char * name) const 
1319 {     
1320   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1321   
1322   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1323
1324   if ( !tasks ) {
1325     Error("PostPID", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1326     return kFALSE ;
1327   }        
1328   
1329   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1330   if ( !phos )  {
1331     if (fDebug) {
1332       Warning("PostPID", "//%s/Reconstructioner/PHOS not found!", fTasksFolder->GetName()) ; 
1333       Info("PostPID", "Adding //%s/Reconstructioner/PHOS", fTasksFolder->GetName()) ;
1334     }
1335     phos = new TTask("PHOS", "") ; 
1336     tasks->Add(phos) ; 
1337   } 
1338
1339   TList * l = phos->GetListOfTasks() ;   
1340   TIter it(l) ;
1341   TString pidname(name) ;
1342   pidname+=":pid" ;
1343   TTask * task ;
1344   while((task = static_cast<TTask *>(it.Next()) )){
1345     TString taskname(task->GetName()) ;
1346     if(taskname.BeginsWith(pidname))
1347       return kTRUE ;
1348   }
1349  
1350   AliPHOSPIDv1 * phospid = new AliPHOSPIDv1() ;
1351   pidname+="-v1" ;
1352   phospid->SetName(pidname) ; 
1353   phospid->SetTitle(fHeaderFile) ;
1354   phos->Add(phospid) ;      
1355   
1356   return kTRUE; 
1357
1358
1359 //____________________________________________________________________________ 
1360 TObject** AliPHOSGetter::PIDRef(const char * name) const 
1361 { //------------PID ------------------------------
1362
1363   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1364
1365   if ( !tasks ) {
1366     Fatal("PIDRef", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1367   }        
1368         
1369   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1370   if ( !phos )  {
1371     Fatal("PIDRef", "//%s/Reconstructioner/PHOS not found !", fTasksFolder->GetName() ) ; 
1372   }   
1373   
1374   TList * l = phos->GetListOfTasks() ; 
1375   TIter it(l) ;
1376   TTask * task ;
1377   TTask * pid = 0 ;
1378   TString pidname(name) ;
1379   pidname+=":pid" ;
1380   while((task = static_cast<TTask *>(it.Next()) )){
1381     TString taskname(task->GetName()) ;
1382     if(taskname.BeginsWith(pidname)){
1383       pid = task ;
1384       break ;
1385     }
1386   }
1387   
1388   if(!pid) {
1389     Fatal("PIDRef", "Task //%s/Reconstructioner/PHOS/PID/%s not found !", fTasksFolder->GetName(), name) ;
1390   }
1391   
1392     return l->GetObjectRef(pid) ;
1393
1394
1395 //____________________________________________________________________________ 
1396 const Bool_t AliPHOSGetter::PostQA(void) const 
1397 { // ------------------ QA ---------------------------------
1398
1399   // the hierarchy is //Folders/Run/Conditions/QA/PHOS/alarmsName
1400
1401   TFolder * phosFolder = dynamic_cast<TFolder*>(fQAFolder->FindObject("PHOS")) ; 
1402   if ( !phosFolder ) {
1403     if (fDebug) {
1404       Warning("PostQA", "-> Folder //%s/PHOS/ not found!", fQAFolder) ;
1405       Info("PostQA", "-> Adding Folder //%s/PHOS", fQAFolder) ;
1406     }
1407     phosFolder = fQAFolder->AddFolder("PHOS", "QA from PHOS") ; 
1408   }      
1409
1410   return kTRUE;
1411 }
1412
1413 //____________________________________________________________________________ 
1414 TObject** AliPHOSGetter::AlarmsRef(void) const 
1415 {  //------- Alarms ----------------------
1416
1417   
1418   // the hierarchy is //Folders/Run/Conditions/QA/PHOS
1419   if ( !fQAFolder ) {
1420     Fatal("AlarmsRef", "Folder //%s not found !", fQAFolder) ;
1421   }    
1422  
1423   TFolder * phosFolder = dynamic_cast<TFolder *>(fQAFolder->FindObject("PHOS")) ;
1424   if ( !phosFolder ) {
1425     Fatal("AlarmsRef", "Folder //%s/PHOS/ not found !", fQAFolder) ;
1426   }
1427    
1428   return fQAFolder->GetListOfFolders()->GetObjectRef(phosFolder) ;
1429 }
1430
1431
1432 //____________________________________________________________________________ 
1433 TTree * AliPHOSGetter::TreeK(TString filename)  
1434 {
1435
1436   // returns TreeK from file filename
1437   // usefull in case of split file
1438
1439   if ( filename.IsNull() ) 
1440     filename = fHeaderFile ; 
1441
1442   TFile * file = 0 ; 
1443   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1444   if (file && (filename != fHeaderFile) ) {  // file already open 
1445     file->Close() ; 
1446     delete fAlice ; 
1447   }    
1448   file = TFile::Open(filename.Data(), "read") ; 
1449   fAlice = static_cast<AliRun *>(file->Get("gAlice")) ; 
1450   TString treeName("TreeK") ; 
1451   treeName += EventNumber()  ; 
1452   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1453   if (!tree && fDebug)  
1454     Warning("TreeK", "-> %s not found in %s", treeName.Data(), filename.Data()) ; 
1455   
1456   return tree ;                       
1457 }
1458
1459 //____________________________________________________________________________ 
1460 TTree * AliPHOSGetter::TreeH(TString filename)  
1461 {
1462
1463   // returns TreeH from file filename
1464   // usefull in case of split file
1465
1466   if ( filename.IsNull() ) 
1467     filename = fHeaderFile ; 
1468
1469   TFile * file = 0 ; 
1470   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1471   if (!file) { // file not open yet
1472     file = TFile::Open(filename.Data(), "read") ; 
1473   }
1474   TString treeName("TreeH") ; 
1475   treeName += EventNumber()  ; 
1476   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1477   if (!tree && fDebug)  
1478     Warning("TreeH", "-> %s not found in %s", treeName.Data(), filename.Data()) ; 
1479   
1480   return tree ;                       
1481 }
1482
1483 //____________________________________________________________________________ 
1484 TTree * AliPHOSGetter::TreeS(TString filename)  
1485 {
1486
1487   // returns TreeS from file filename
1488   // usefull in case of split file
1489
1490   if ( filename.IsNull() ) 
1491     filename = fHeaderFile ; 
1492
1493   TFile * file = 0 ; 
1494   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1495   if (!file) { // file not open yet
1496     file = TFile::Open(filename.Data(), "read") ; 
1497   }
1498   TString treeName("TreeS") ; 
1499   treeName += EventNumber()  ; 
1500   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1501   if (!tree && fDebug)  
1502     Warning("TreeS", "-> %s not found in %s", treeName.Data(), filename.Data() ); 
1503   
1504   return tree ;                       
1505 }
1506
1507 //____________________________________________________________________________ 
1508 TTree * AliPHOSGetter::TreeD(TString filename)  
1509 {
1510
1511   // returns TreeD from file filename
1512   // usefull in case of split file
1513
1514   if ( filename.IsNull() ) 
1515     filename = fHeaderFile ; 
1516
1517   TFile * file = 0 ; 
1518   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1519   if (!file) { // file not open yet
1520     file = TFile::Open(filename.Data(), "read") ; 
1521   }
1522   TString treeName("TreeD") ; 
1523   treeName += EventNumber()  ; 
1524   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1525   if (!tree && fDebug)  
1526     Warning("TreeD", "-> %s not found in %s", treeName.Data(), filename.Data()) ; 
1527   
1528   return tree ;                       
1529 }
1530
1531 //____________________________________________________________________________ 
1532 const TParticle * AliPHOSGetter::Primary(Int_t index) const 
1533 {
1534   // Return primary particle numbered by <index>
1535
1536   if(index < 0) 
1537     return 0 ;
1538   TParticle *  p = 0 ;
1539   if (fAlice) 
1540     p = fAlice->Particle(index) ; 
1541   else 
1542     p = gAlice->Particle(index) ; 
1543   
1544   return p ; 
1545     
1546 }
1547
1548 //____________________________________________________________________________ 
1549 const TParticle * AliPHOSGetter::Secondary(TParticle* p, Int_t index) const
1550 {
1551   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
1552
1553   if(index <= 0) 
1554     return 0 ;
1555   if(index > 2)
1556     return 0 ;
1557
1558   if(p) {
1559   Int_t daughterIndex = p->GetDaughter(index-1) ; 
1560   return  gAlice->Particle(daughterIndex) ; 
1561   }
1562   else
1563     return 0 ;
1564 }
1565
1566 //____________________________________________________________________________ 
1567 Int_t AliPHOSGetter::ReadTreeD(const Int_t event)
1568 {
1569   // Read the digit tree gAlice->TreeD()  
1570   
1571   TTree * treeD ;
1572   if(fToSplit){
1573     TFile * file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName)); 
1574     if(!file) 
1575       file = TFile::Open(fDigitsFileName) ;      
1576     // Get Digits Tree header from file
1577     TString treeName("TreeD") ;
1578     treeName += event ; 
1579     treeD = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1580     if(!treeD){ // TreeD not found in header file
1581       if (fDebug)
1582         Warning("ReadTreeD", "-> Cannot find TreeD in %s", fDigitsFileName.Data()) ;
1583       return 1;
1584     }
1585   }
1586   else
1587     treeD = gAlice->TreeD() ;
1588   
1589   TObjArray * lob = static_cast<TObjArray*>(treeD->GetListOfBranches()) ;
1590   TIter next(lob) ; 
1591   TBranch * branch = 0 ; 
1592   TBranch * digitsbranch = 0 ; 
1593   TBranch * digitizerbranch = 0 ; 
1594   Bool_t phosfound = kFALSE, digitizerfound = kFALSE ; 
1595   
1596   while ( (branch = static_cast<TBranch*>(next())) && (!phosfound || !digitizerfound) ) {
1597     if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1598       digitsbranch = branch ; 
1599       phosfound = kTRUE ;
1600     }
1601     else if ( ((strcmp(branch->GetName(), "AliPHOSDigitizer")==0)||
1602                (strcmp(branch->GetName(), "AliPHOSRaw2Digits")==0)) &&
1603               (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1604       digitizerbranch = branch ; 
1605       digitizerfound = kTRUE ; 
1606     }
1607   }
1608   
1609   if ( !phosfound || !digitizerfound ) {
1610     if (fDebug)
1611       Warning("ReadTreeD", "-> Cannot find Digits and/or Digitizer with name %s", fDigitsTitle.Data()) ;
1612     return 2; 
1613   }   
1614   
1615   //read digits
1616   if(!Digits(fDigitsTitle) ) 
1617     PostDigits(fDigitsTitle);
1618   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
1619   digitsbranch->GetEntry(0) ;
1620   
1621   
1622   // read  the Digitizer
1623   if(Digitizer()){
1624     if(strcmp(Digitizer()->IsA()->GetName(),digitizerbranch->GetName())!=0){
1625       RemoveTask("D", fDigitsTitle) ;
1626       if(strcmp(digitizerbranch->GetName(), "AliPHOSDigitizer")==0)
1627         PostDigitizer("Digitizer") ;
1628       else
1629         PostDigitizer("Raw2Digits") ;
1630     }
1631   }
1632   else{
1633     if(strcmp(digitizerbranch->GetName(), "AliPHOSDigitizer")==0)
1634       PostDigitizer("Digitizer") ;
1635     else
1636       PostDigitizer("Raw2Digits") ;
1637   }
1638     
1639
1640   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
1641   digitizerbranch->GetEntry(0) ;
1642   
1643
1644   if((!fcdb)&&(strcmp(digitizerbranch->GetName(), "AliPHOSRaw2Digits")==0))
1645     ReadCalibrationDB("Primordial","beamtest.root") ;
1646   
1647   if(gAlice->TreeD()!=treeD)
1648     treeD->Delete();
1649
1650   return 0 ; 
1651 }
1652 //____________________________________________________________________________ 
1653 void AliPHOSGetter::ReadCalibrationDB(const char * database,const char * filename){
1654
1655   if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
1656     return ;
1657
1658   TFile * file = gROOT->GetFile(filename) ;
1659   if(!file)
1660     file = TFile::Open(filename);
1661   if(!file){
1662     Error ("ReadCalibrationDB", "Cannot open file %s", filename) ;
1663     return ;
1664   }
1665   if(fcdb)
1666     fcdb->Delete() ;
1667   fcdb = dynamic_cast<AliPHOSCalibrationDB *>(file->Get("AliPHOSCalibrationDB")) ;
1668   if(!fcdb)
1669     Error ("ReadCalibrationDB", "No database %s in file %s", database, filename) ;
1670 }
1671
1672 //____________________________________________________________________________ 
1673 Int_t AliPHOSGetter::ReadTreeH()
1674 {
1675   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1676   
1677   TTree * treeH = gAlice->TreeH() ;
1678
1679   if(!treeH) {// TreeH not found in header file
1680  
1681     if (fDebug) 
1682       Warning("ReadTreeH", "-> Cannot find TreeH in %s", fHeaderFile.Data() ) ;
1683     
1684     TString searchFileName("PHOS.Hits") ; 
1685     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
1686       searchFileName+="." ;
1687       searchFileName += fBranchTitle ;
1688     }
1689     searchFileName+=".root" ;
1690     
1691     if ( (treeH = TreeH(searchFileName)) ) { //found TreeH in the file which contains the hits
1692       if (fDebug) 
1693         Info("ReadTreeH", "-> TreeH found in %s", searchFileName.Data()) ; 
1694       
1695     } else {
1696       Error("ReadTreeH", "TreeH not found") ; 
1697       return 1;
1698     }  
1699   }
1700   
1701   TBranch * hitsbranch = static_cast<TBranch*>(treeH->GetBranch("PHOS")) ;
1702   if ( !hitsbranch ) {
1703     if (fDebug)
1704       Warning("ReadTreeH", "-> Cannot find branch PHOS") ; 
1705     return 2;
1706   }
1707   if(!Hits())
1708     PostHits() ;
1709
1710   if (hitsbranch->GetEntries() > 1 ) {
1711     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1712     TClonesArray * tempo =  new TClonesArray("AliPHOSHit",1000) ;
1713     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ; 
1714     hitsbranch->SetAddress(&tempo) ;
1715     Int_t index = 0 ; 
1716     Int_t i = 0 ;
1717     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
1718       hitsbranch->GetEntry(i) ;
1719       Int_t j = 0 ; 
1720       for ( j = 0 ; j < tempo->GetEntries() ; j++) { 
1721         const AliPHOSHit * hit = static_cast<const AliPHOSHit *>(tempo->At(j)) ; 
1722         new((*hits)[index]) AliPHOSHit( *hit ) ;
1723         index++ ; 
1724       }
1725     }
1726     delete tempo ; 
1727   }
1728   else {
1729     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1730     hitsbranch->SetAddress(HitsRef()) ;
1731     hitsbranch->GetEntry(0) ;
1732   }
1733   return 0 ; 
1734 }
1735
1736 //____________________________________________________________________________ 
1737 void AliPHOSGetter::Track(const Int_t itrack) 
1738 {
1739   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1740
1741   if(gAlice->TreeH()== 0){
1742     Error("Track", "Cannot read TreeH") ;
1743     return ;
1744   }
1745   
1746   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS")) ;
1747   if ( !hitsbranch ) {
1748     if (fDebug)
1749       Warning("Track", "Cannot find branch PHOS") ; 
1750     return ;
1751   }  
1752   if(!Hits())
1753     PostHits() ;
1754
1755   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1756   hitsbranch->SetAddress(HitsRef()) ;
1757   hitsbranch->GetEntry(itrack) ;
1758
1759 }
1760
1761 //____________________________________________________________________________ 
1762 void AliPHOSGetter::ReadTreeQA()
1763 {
1764   // Read the digit tree gAlice->TreeQA()
1765   // so far only PHOS knows about this Tree  
1766
1767   if(PHOS()->TreeQA()== 0){
1768     Error("ReadTreeQA", "Cannot read TreeQA") ;
1769     return ;
1770   }
1771   
1772   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ; 
1773   if (!qabranch) { 
1774     if (fDebug)
1775       Warning("ReadTreeQA", "Cannot find QA Alarms for PHOS");
1776     return ; 
1777   }   
1778   
1779   if(!Alarms())
1780     PostQA() ; 
1781
1782   qabranch->SetAddress(AlarmsRef()) ;
1783
1784   qabranch->GetEntry(0) ;
1785  
1786 //   PostQA("PHOS") ; 
1787 //   TFolder * alarmsF = Alarms() ; 
1788 //   alarmsF->Clear() ; 
1789 //   qabranch->SetAddress(&alarmsF) ;
1790 //   qabranch->GetEntry(0) ;
1791   
1792 }
1793
1794 //____________________________________________________________________________ 
1795 Int_t AliPHOSGetter::ReadTreeR(const Int_t event)
1796 {
1797   // Read the reconstrunction tree gAlice->TreeR()
1798   // A particularity has been introduced here :
1799   //  if gime->Event(ievent,"R") is called branches with the current title are read, the current title
1800   //   being for example give in AliPHOSPID(fileName, title)
1801   //  if gime(Event(ievent, "RA") is called the title of the branches is not checked anymore, "A" stands for any
1802   // This is a feature needed by PID to be able to reconstruct several times particles (each time a ther title is given)
1803   // from a given set of TrackSegments (with a given name)
1804   // This is why any is NOT used to read the branch of RecParticles
1805   // any migh have become obsolete : to be checked
1806   // See AliPHOSPIDv1    
1807
1808   TTree * treeR ;
1809   if(fToSplit){
1810     TFile * file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName)); 
1811     if(!file) 
1812       file = TFile::Open(fRecPointsFileName) ;      
1813     // Get Digits Tree header from file
1814     TString treeName("TreeR") ;
1815     treeName += event ; 
1816     treeR = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1817     if(!treeR){ // TreeR not found in header file
1818       if (fDebug)
1819         Warning("ReadTreeD", "-> Cannot find TreeR in %s", fRecPointsFileName.Data()) ;
1820       return 1;
1821     }
1822   }
1823   else
1824     treeR = gAlice->TreeR() ;
1825   
1826   // RecPoints 
1827   TObjArray * lob = static_cast<TObjArray*>(treeR->GetListOfBranches()) ;
1828   TIter next(lob) ; 
1829   TBranch * branch = 0 ; 
1830   TBranch * emcbranch = 0 ; 
1831   TBranch * cpvbranch = 0 ; 
1832   TBranch * clusterizerbranch = 0 ; 
1833   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ; 
1834
1835   
1836   while ( (branch = static_cast<TBranch*>(next())) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) ) {
1837     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0 ) {
1838       if ( strcmp(branch->GetName(), "PHOSEmcRP")==0) {
1839         emcbranch = branch ; 
1840         phosemcrpfound = kTRUE ;
1841       }
1842       else if ( strcmp(branch->GetName(), "PHOSCpvRP")==0) {
1843         cpvbranch = branch ; 
1844         phoscpvrpfound = kTRUE ;
1845       }
1846       else if(strcmp(branch->GetName(), "AliPHOSClusterizer")==0){
1847         clusterizerbranch = branch ; 
1848         clusterizerfound = kTRUE ; 
1849       }
1850     }
1851   }
1852
1853   if ( !phosemcrpfound || !phoscpvrpfound || !clusterizerfound) {
1854     if (fDebug)
1855       Warning("ReadTreeR", "-> Cannot find RecPoints and/or Clusterizer with name %s", fRecPointsTitle.Data() ) ;
1856  
1857   } else { 
1858     if(!EmcRecPoints(fRecPointsTitle) ) 
1859       PostRecPoints(fRecPointsTitle) ;
1860     
1861     emcbranch->SetAddress(EmcRecPointsRef(fRecPointsTitle)) ;
1862     emcbranch->GetEntry(0) ;
1863
1864     cpvbranch->SetAddress(CpvRecPointsRef(fRecPointsTitle)) ; 
1865     cpvbranch->GetEntry(0) ;  
1866     
1867     if(!Clusterizer(fRecPointsTitle) )
1868       PostClusterizer(fRecPointsTitle) ;
1869     
1870     clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
1871     clusterizerbranch->GetEntry(0) ;
1872   }
1873   
1874   //------------------- TrackSegments ---------------------
1875   next.Reset() ; 
1876   TBranch * tsbranch = 0 ; 
1877   TBranch * tsmakerbranch = 0 ; 
1878   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ; 
1879   while ( (branch = static_cast<TBranch*>(next())) && (!phostsfound || !tsmakerfound) ) {
1880     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0 )  {
1881       if ( strcmp(branch->GetName(), "PHOSTS")==0){
1882         tsbranch = branch ; 
1883         phostsfound = kTRUE ;
1884       }
1885       else if(strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) {
1886         tsmakerbranch = branch ; 
1887         tsmakerfound  = kTRUE ; 
1888       }
1889     }
1890   }
1891
1892   if ( !phostsfound || !tsmakerfound ) {
1893     if (fDebug)
1894       Warning("ReadTreeR", "-> Cannot find TrackSegments and/or TrackSegmentMaker with name %s", fTrackSegmentsTitle.Data() ) ;
1895   } else { 
1896     // Read and Post the TrackSegments
1897     if(!TrackSegments(fTrackSegmentsTitle))
1898       PostTrackSegments(fTrackSegmentsTitle) ;
1899     tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
1900     tsbranch->GetEntry(0) ;
1901
1902     // Read and Post the TrackSegment Maker
1903     if(!TrackSegmentMaker(fTrackSegmentsTitle))
1904       PostTrackSegmentMaker(fTrackSegmentsTitle) ;
1905     tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
1906     tsmakerbranch->GetEntry(0) ;
1907  }
1908   
1909   
1910   //------------ RecParticles ----------------------------
1911   next.Reset() ; 
1912   TBranch * rpabranch = 0 ; 
1913   TBranch * pidbranch = 0 ; 
1914   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ; 
1915   
1916   while ( (branch = static_cast<TBranch*>(next())) && (!phosrpafound || !pidfound) ) 
1917     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {   
1918       if ( strcmp(branch->GetName(), "PHOSRP")==0) {   
1919         rpabranch = branch ; 
1920         phosrpafound = kTRUE ;
1921       }
1922       else if (strcmp(branch->GetName(), "AliPHOSPID")==0) {
1923         pidbranch = branch ; 
1924         pidfound  = kTRUE ; 
1925       }
1926     }
1927   
1928   if ( !phosrpafound || !pidfound ) {
1929     if (fDebug)
1930       Warning("ReadTreeR", "-> Cannot find RecParticles and/or PID with name %s", fRecParticlesTitle.Data() ) ; 
1931   } else { 
1932     // Read and Post the RecParticles
1933     if(!RecParticles(fRecParticlesTitle)) 
1934       PostRecParticles(fRecParticlesTitle) ;
1935     rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
1936     rpabranch->GetEntry(0) ;
1937     // Read and Post the PID
1938     if(!PID(fRecParticlesTitle))
1939       PostPID(fRecParticlesTitle) ;
1940     pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
1941     pidbranch->GetEntry(0) ;
1942   }
1943
1944   if(gAlice->TreeR()!=treeR)
1945     treeR->Delete();
1946   return 0 ; 
1947 }
1948
1949 //____________________________________________________________________________ 
1950 Int_t AliPHOSGetter::ReadTreeS(const Int_t event)
1951 {
1952   // Reads the SDigits treeS from all files  
1953   // Files, which should be opened are listed in phosF
1954   // So, first get list of files
1955   TFolder * phosF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
1956   if (!phosF) 
1957     phosF = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
1958   TCollection * folderslist = phosF->GetListOfFolders() ; 
1959   
1960   // Now iterate over the list of files and read TreeS into Whiteboard
1961   TIter next(folderslist) ; 
1962   TFolder * folder = 0 ; 
1963   TFile * file; 
1964   TTree * treeS = 0;
1965   while ( (folder = static_cast<TFolder*>(next())) ) {
1966     TString fileName("") ;
1967     if(fToSplit)
1968       fileName = folder->GetTitle() ;
1969     else
1970       fileName = folder->GetName() ; 
1971     fileName.ReplaceAll("_","/") ; 
1972     file = static_cast<TFile*>(gROOT->GetFile(fileName)); 
1973     if(!file) 
1974       file = TFile::Open(fileName) ;      
1975     // Get SDigits Tree header from file
1976     TString treeName("TreeS") ;
1977     treeName += event ; 
1978     treeS = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1979
1980     if(!treeS){ // TreeS not found in header file
1981       if (fDebug)
1982         Warning("ReadTreeS", "-> Cannot find TreeS in %s", fileName.Data()) ;
1983       return 1;
1984     }
1985     
1986     //set address of the SDigits and SDigitizer
1987     TBranch   * sdigitsBranch    = 0;
1988     TBranch   * sdigitizerBranch = 0;
1989     TBranch   * branch           = 0 ;  
1990     TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
1991     TIter next(lob) ; 
1992     Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
1993
1994     while ( (branch = static_cast<TBranch*>(next())) && (!phosfound || !sdigitizerfound) ) {
1995       if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
1996         phosfound = kTRUE ;
1997         sdigitsBranch = branch ; 
1998       }
1999       
2000       else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && 
2001                 (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
2002         sdigitizerfound = kTRUE ; 
2003         sdigitizerBranch = branch ;
2004       }
2005     }
2006     if ( !phosfound || !sdigitizerfound ) {
2007       if (fDebug)
2008         Warning("ReadSDigits", "-> Digits and/or Digitizer branch with name %s not found", GetName()) ;
2009       return 2; 
2010     }   
2011     
2012     if ( !folder->FindObject(fSDigitsTitle) )  
2013       PostSDigits(fSDigitsTitle,folder->GetName()) ;
2014
2015     ((TClonesArray*) (*SDigitsRef(fSDigitsTitle,folder->GetName())))->Clear() ;
2016     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
2017     sdigitsBranch->GetEntry(0) ;
2018     
2019     TString sdname(fSDigitsTitle) ;
2020     sdname+=":" ;
2021     sdname+=folder->GetName() ;
2022     if(!SDigitizer(sdname) ) 
2023       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
2024     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
2025     sdigitizerBranch->GetEntry(0) ; 
2026     if(gAlice->TreeS()!=treeS)
2027       treeS->Delete();
2028   }    
2029   return 0 ; 
2030 }
2031
2032 //____________________________________________________________________________ 
2033 void AliPHOSGetter::ReadTreeS(TTree * treeS, Int_t input)
2034
2035 {  // Read the summable digits fron treeS()  
2036
2037
2038   TString filename("mergefile") ;
2039   filename+= input ;
2040
2041   TFolder * phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ; 
2042   if ( !phosFolder ) { 
2043    phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
2044   } 
2045   TFolder * folder=(TFolder*)phosFolder->FindObject(filename) ;
2046   //set address of the SDigits and SDigitizer
2047   TBranch   * sdigitsBranch    = 0;
2048   TBranch   * sdigitizerBranch = 0;
2049   TBranch   * branch           = 0 ;  
2050   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
2051   TIter next(lob) ; 
2052   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
2053   
2054   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
2055     if ( strcmp(branch->GetName(), "PHOS")==0) {
2056       phosfound = kTRUE ;
2057       sdigitsBranch = branch ; 
2058     }
2059     
2060     else if ( strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) {
2061       sdigitizerfound = kTRUE ; 
2062       sdigitizerBranch = branch ;
2063     }
2064   }
2065   if ( !phosfound || !sdigitizerfound ) {
2066     if (fDebug)
2067       Warning("ReadTreeS", "-> Digits and/or Digitizer branch not found") ;
2068     return ; 
2069   }   
2070   
2071   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
2072     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
2073
2074   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
2075   sdigitsBranch->GetEntry(0) ;
2076   
2077   TString sdname(sdigitsBranch->GetTitle()) ;
2078   sdname+=":" ;
2079   sdname+=filename ;
2080   
2081   if(!SDigitizer(sdigitsBranch->GetTitle()) )
2082     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
2083   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
2084   sdigitizerBranch->GetEntry(0) ;
2085   if(gAlice->TreeS()!=treeS)
2086     treeS->Delete();
2087 }    
2088
2089
2090 //____________________________________________________________________________ 
2091 void AliPHOSGetter::ReadPrimaries()
2092 {
2093   // a lot simplified.... if 2 files are opened then we have a problem
2094
2095   TClonesArray * ar = 0  ; 
2096   if(! (ar = Primaries()) ) { 
2097     PostPrimaries() ;
2098     ar = Primaries() ; 
2099   }
2100   ar->Delete() ; 
2101   
2102   if (TreeK(fHeaderFile)) { // treeK found in header file
2103     if (fDebug) 
2104       Info("ReadPrimaries", "-> TreeK found in %s", fHeaderFile.Data() ); 
2105     fNPrimaries = gAlice->GetNtrack() ; 
2106     fAlice = 0 ; 
2107   
2108   } else { // treeK not found in header file
2109     
2110     Error("ReadPrimaries", "TreeK not found") ; 
2111     return ;
2112     
2113   }
2114   Int_t index = 0 ; 
2115   for (index = 0 ; index < fNPrimaries; index++) { 
2116     new ((*ar)[index]) TParticle(*(Primary(index)));
2117   }
2118 }
2119
2120 //____________________________________________________________________________ 
2121 void AliPHOSGetter::Event(const Int_t event, const char* opt)  
2122 {
2123   // Reads the content of all Tree's S, D and R
2124
2125   if (event >= gAlice->TreeE()->GetEntries() ) {
2126     Error("Event", "%d not found in TreeE !", event) ; 
2127     return ; 
2128   }
2129
2130   Bool_t any = kFALSE ; 
2131   if (strstr(opt,"A") ) // do not check the title of the branches
2132     any = kTRUE; 
2133
2134   gAlice->GetEvent(event) ; 
2135
2136   if( strstr(opt,"R") )
2137     ReadTreeR(event) ;
2138
2139   if( strstr(opt,"D") )
2140     ReadTreeD(event) ;
2141
2142   if(strstr(opt,"S") )
2143     ReadTreeS(event) ;
2144
2145   if(strstr(opt,"H") )
2146     ReadTreeH() ;
2147    
2148   if( strstr(opt,"Q") )
2149     ReadTreeQA() ;
2150  
2151   if( strstr(opt,"P") || (strcmp(opt,"")==0) )
2152     ReadPrimaries() ;
2153   
2154 }
2155
2156 //____________________________________________________________________________ 
2157 TObject * AliPHOSGetter::ReturnO(TString what, TString name, TString file) const 
2158 {
2159   // get the object named "what" from the folder
2160   // folders are named like //Folders
2161
2162   if ( file.IsNull() ) 
2163     file = fHeaderFile ; 
2164
2165   TFolder * folder = 0 ;
2166   TObject * phosO  = 0 ; 
2167
2168   if ( what.CompareTo("Primaries") == 0 ) {
2169     folder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ; 
2170     if (folder) 
2171       phosO  = dynamic_cast<TObject *>(folder->FindObject("Primaries")) ;  
2172     else 
2173       return 0 ; 
2174   }
2175   else if ( what.CompareTo("Hits") == 0 ) {
2176     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("PHOS")) ; 
2177     if (folder) 
2178       phosO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;  
2179   }
2180   else if ( what.CompareTo("SDigits") == 0 ) {
2181     file.ReplaceAll("/","_") ; 
2182     TString path = "PHOS/" + file  ;
2183     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ; 
2184     if (folder) { 
2185       if (name.IsNull())
2186         name = fSDigitsTitle ; 
2187       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2188     }
2189   }
2190   else if ( what.CompareTo("Digits") == 0 ){
2191     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("PHOS")) ; 
2192     if (folder) { 
2193       if (name.IsNull())
2194         name = fDigitsTitle ; 
2195       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2196     } 
2197   }
2198   else if ( what.CompareTo("EmcRecPoints") == 0 ) {
2199     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ; 
2200     if (folder) { 
2201       if (name.IsNull())
2202         name = fRecPointsTitle ; 
2203       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
2204     } 
2205   }
2206   else if ( what.CompareTo("CpvRecPoints") == 0 ) {
2207     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ; 
2208     if (folder) { 
2209       if (name.IsNull())
2210         name = fRecPointsTitle ; 
2211       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2212     }   
2213   }
2214   else if ( what.CompareTo("TrackSegments") == 0 ) {
2215     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/TrackSegments")) ; 
2216     if (folder) { 
2217       if (name.IsNull())
2218         name = fTrackSegmentsTitle ; 
2219       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2220     }   
2221   }
2222   else if ( what.CompareTo("RecParticles") == 0 ) {
2223     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/RecParticles")) ; 
2224    if (folder) { 
2225       if (name.IsNull())
2226         name = fRecParticlesTitle ; 
2227       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
2228     }   
2229  }
2230   else if ( what.CompareTo("Alarms") == 0 ){ 
2231     if (name.IsNull() ) 
2232       phosO = dynamic_cast<TObject *>(fQAFolder->FindObject("PHOS")) ;  
2233     else {
2234       folder = dynamic_cast<TFolder *>(fQAFolder->FindObject("PHOS")) ; 
2235       if (!folder) 
2236         phosO = 0 ; 
2237       else 
2238         phosO = dynamic_cast<TObject *>(folder->FindObject(name)) ;  
2239     }
2240   }
2241   if (!phosO) {
2242     if(fDebug)
2243       Warning("ReturnO", "Object %s not found in PHOS", what.Data() ) ; 
2244     return 0 ;
2245   }
2246
2247   return phosO ;
2248 }
2249   
2250 //____________________________________________________________________________ 
2251 const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const 
2252 {
2253   // get the TTask named "what" from the folder
2254   // folders are named like //Folders/Tasks/what/PHOS/name
2255
2256   TString search(what) ; 
2257   if ( what.CompareTo("Clusterizer") == 0 ) 
2258     search = "Reconstructioner" ; 
2259   else if ( what.CompareTo("TrackSegmentMaker") == 0 ) 
2260     search = "Reconstructioner" ; 
2261   else if ( what.CompareTo("PID") == 0 ) 
2262     search = "Reconstructioner" ; 
2263   else if ( what.CompareTo("QATasks") == 0 ) 
2264     search = "QA" ; 
2265
2266   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ; 
2267
2268   if (!tasks) {
2269     Error("ReturnT", "Task %s not found !", what.Data() ) ;  
2270     return 0 ; 
2271   }
2272
2273   TTask * phosT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
2274   if (!phosT) { 
2275      Error("ReturnT", "Task %s/PHOS not found !", what.Data() ) ;  
2276     return 0 ; 
2277   }
2278   
2279   TList * list = phosT->GetListOfTasks() ; 
2280  
2281   if (what.CompareTo("SDigitizer") == 0) {  
2282     if ( name.IsNull() )
2283       name =  fSDigitsTitle ; 
2284   } else  if (what.CompareTo("Digitizer") == 0){ 
2285     if ( name.IsNull() )
2286       name =  fDigitsTitle ;
2287   } else  if (what.CompareTo("Clusterizer") == 0){ 
2288     if ( name.IsNull() )
2289       name =  fRecPointsTitle ;
2290     name.Append(":clu") ;
2291   }
2292   else  if (what.CompareTo("TrackSegmentMaker") == 0){ 
2293     if ( name.IsNull() )
2294       name =  fTrackSegmentsTitle ;
2295     name.Append(":tsm") ;
2296   }
2297   else  if (what.CompareTo("PID") == 0){ 
2298     if ( name.IsNull() )
2299       name =  fRecParticlesTitle ;
2300     name.Append(":pid") ;
2301   }
2302   else  if (what.CompareTo("QATasks") == 0){ 
2303     if ( name.IsNull() )
2304       return phosT ;
2305   }
2306   
2307   TIter it(list) ;
2308   TTask * task = 0 ; 
2309   while((task = static_cast<TTask *>(it.Next()) )){
2310     TString taskname(task->GetName()) ;
2311     if(taskname.BeginsWith(name))
2312       return task ;
2313   }
2314   
2315   if(fDebug)
2316     Warning("ReturnT", "-> Task %s/PHOS/%s not found", search.Data(), name.Data() ) ; 
2317   return 0 ;
2318 }
2319
2320 //____________________________________________________________________________ 
2321 void AliPHOSGetter::RemoveTask(TString opt, TString name) const 
2322 {
2323   // remove a task from the folder
2324   // path is fTasksFolder/SDigitizer/PHOS/name
2325   
2326   TTask * task = 0 ; 
2327   TTask * phos = 0 ; 
2328   TList * lofTasks = 0 ; 
2329
2330   if (opt == "S") { // SDigitizer
2331     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
2332     if (!task) 
2333       return ; 
2334   }
2335   else if (opt == "D") { // Digitizer
2336     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
2337     if (!task) 
2338       return ; 
2339   }
2340   else if (opt == "C" || opt == "T" || opt == "P"  ) { // Clusterizer, TrackSegmentMaker, PID
2341     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
2342     if (!task) 
2343       return ; 
2344   }
2345   else {
2346     Warning("RemoveTask", "Unknown option %s", opt.Data() ); 
2347     return ; 
2348   }
2349   phos =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2350   if (!phos)
2351     return ; 
2352   lofTasks = phos->GetListOfTasks() ;
2353   if (!lofTasks) 
2354     return ; 
2355   TObject * obj = lofTasks->FindObject(name) ; 
2356   if (obj) 
2357     lofTasks->Remove(obj) ;
2358    
2359 }
2360
2361 //____________________________________________________________________________ 
2362 void AliPHOSGetter::RemoveObjects(TString opt, TString name) const 
2363 {
2364   // remove SDigits from the folder
2365   // path is fSDigitsFolder/fHeaderFileName/name
2366
2367   TFolder * phos     = 0 ; 
2368   TFolder * phosmain = 0 ; 
2369
2370   if (opt == "H") { // Hits
2371     phos = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ;
2372     if (!phos) 
2373       return ;
2374     name = "Hits" ; 
2375   }
2376
2377   else if ( opt == "S") { // SDigits
2378     phosmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2379     if (!phosmain) 
2380       return ;
2381     phos = dynamic_cast<TFolder*>(phosmain->FindObject(fHeaderFile)) ;
2382     if (!phos) 
2383       return ;
2384   }
2385   
2386   else if (opt == "D") { // Digits
2387     phos = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
2388     if (!phos) 
2389       return ;
2390   }
2391
2392   else if (opt == "RE") { // EMCARecPoints
2393     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ;
2394     if (!phos) 
2395       return ;
2396   }
2397
2398   else if (opt == "RC") { // CPVRecPoints
2399     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ;
2400     if (!phos) 
2401       return ;
2402   }  
2403
2404   else if (opt == "T") { // TrackSegments
2405     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ;
2406     if (!phos) 
2407       return ;
2408   }
2409
2410   else if (opt == "P") { // RecParticles
2411     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ;
2412     if (!phos) 
2413       return ;
2414   }
2415   
2416   else {
2417     Warning("RemoveObjects", "Unknown option %s", opt.Data() ) ; 
2418     return ; 
2419   }
2420   
2421   TObjArray * ar  = dynamic_cast<TObjArray*>(phos->FindObject(name)) ; 
2422   if (ar) { 
2423     phos->Remove(ar) ;
2424     ar->Delete() ; 
2425     delete ar ; 
2426   }
2427
2428   if (opt == "S") 
2429     phosmain->Remove(phos) ; 
2430   
2431 }
2432
2433 //____________________________________________________________________________ 
2434 void AliPHOSGetter::RemoveSDigits() const 
2435 {
2436   TFolder * phos= dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2437   if (!phos) 
2438     return ;
2439   
2440   phos->SetOwner() ; 
2441   phos->Clear() ; 
2442 }
2443
2444 //____________________________________________________________________________ 
2445 void AliPHOSGetter::CleanWhiteBoard(void){
2446
2447   TFolder * phosmain = 0 ; 
2448   TFolder * phos ;
2449   TObjArray * ar ;
2450   TList * lofTasks = 0 ; 
2451   TTask * task = 0 ; 
2452   TTask * phost = 0 ; 
2453   
2454   // Hits  
2455   phos = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ;
2456   if (phos){  
2457     TObjArray * ar  = dynamic_cast<TObjArray*>(phos->FindObject("Hits")) ; 
2458     if (ar) { 
2459       phos->Remove(ar) ;
2460       ar->Delete() ; 
2461       delete ar ; 
2462     }
2463   }
2464   
2465   // SDigits
2466   phosmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2467   if (phosmain){ 
2468     phos = dynamic_cast<TFolder*>(phosmain->FindObject(fHeaderFile)) ;
2469     if (phos) {
2470       ar  = dynamic_cast<TObjArray*>(phos->FindObject(fSDigitsTitle)) ; 
2471       if (ar) { 
2472         phos->Remove(ar) ;
2473         ar->Delete() ; 
2474         delete ar ; 
2475       }
2476     }
2477     phosmain->Remove(phos) ; 
2478   }
2479
2480   
2481   // Digits
2482   phos = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
2483   if (phos){ 
2484     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fDigitsTitle)) ; 
2485     if (ar) { 
2486       phos->Remove(ar) ;
2487       ar->Delete() ; 
2488       delete ar ; 
2489     }
2490   }
2491
2492
2493   // EMCARecPoints
2494   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ;
2495   if (phos){ 
2496     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fRecPointsTitle)) ; 
2497     if (ar) { 
2498       phos->Remove(ar) ;
2499       ar->Delete() ; 
2500       delete ar ; 
2501     }
2502   }
2503
2504   
2505   // CPVRecPoints
2506   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ;
2507   if (phos){ 
2508     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fRecPointsTitle)) ; 
2509     if (ar) { 
2510       phos->Remove(ar) ;
2511       ar->Delete() ; 
2512       delete ar ; 
2513     }
2514   }  
2515
2516   
2517   // TrackSegments
2518   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ;
2519   if (phos) { 
2520     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fTrackSegmentsTitle)) ; 
2521     if (ar) { 
2522       phos->Remove(ar) ;
2523       ar->Delete() ; 
2524       delete ar ; 
2525     }
2526   }
2527   
2528
2529
2530   // RecParticles
2531   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ;
2532   if (phos){ 
2533     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fRecParticlesTitle)) ; 
2534     if (ar) { 
2535       phos->Remove(ar) ;
2536       ar->Delete() ; 
2537       delete ar ; 
2538     }
2539   }
2540
2541
2542   //---- Now Tasks ----------- 
2543
2544   TObject * obj ;
2545   TString sdname(fSDigitsTitle);
2546   
2547   // Digitizer
2548   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
2549   if (task){ 
2550     phost =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2551     if (phost){
2552       lofTasks = phost->GetListOfTasks() ;
2553       if (lofTasks){ 
2554         obj = lofTasks->FindObject(sdname.Data()) ; 
2555         if (obj) 
2556           lofTasks->Remove(obj) ;
2557       }
2558     }      
2559   }
2560   
2561
2562   sdname.Append(":") ;
2563   // Clusterizer, TrackSegmentMaker, PID
2564   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
2565   if (task){ 
2566     phost =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2567     if (phost){
2568       lofTasks = phost->GetListOfTasks() ;
2569       TIter next(lofTasks);
2570       while((obj=next())){ 
2571         TString oname(obj->GetName()) ;
2572         if (oname.BeginsWith(sdname)){ 
2573           lofTasks->Remove(obj) ;
2574         }
2575       }
2576     }  
2577   }
2578
2579
2580   // SDigitizer
2581   sdname.Append(fHeaderFile) ;
2582   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
2583   if (task) {
2584     phost =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2585     if (phost){
2586       lofTasks = phost->GetListOfTasks() ;
2587       if (lofTasks){ 
2588         obj = lofTasks->FindObject(sdname.Data()) ; 
2589         if (obj) 
2590           lofTasks->Remove(obj) ;
2591       }
2592     }
2593   }  
2594
2595 }
2596 //____________________________________________________________________________ 
2597 void AliPHOSGetter::SetTitle(const char * branchTitle ) 
2598 {
2599   fBranchTitle        = branchTitle ;
2600   fSDigitsTitle       = branchTitle ; 
2601   fDigitsTitle        = branchTitle ; 
2602   fRecPointsTitle     = branchTitle ; 
2603   fRecParticlesTitle  = branchTitle ; 
2604   fTrackSegmentsTitle = branchTitle ; 
2605   if(fToSplit){
2606     //First - extract full path if necessary
2607     TString sFileName(fHeaderFile) ;
2608     Ssiz_t islash = sFileName.Last('/') ;
2609     if(islash<sFileName.Length())
2610       sFileName.Remove(islash+1,sFileName.Length()) ;
2611     else
2612       sFileName="" ;
2613     //Now construct file names
2614     fSDigitsFileName       = sFileName ;
2615     fDigitsFileName        = sFileName ; 
2616     fRecPointsFileName     = sFileName ; 
2617     fRecParticlesFileName  = sFileName ; 
2618     fTrackSegmentsFileName = sFileName ; 
2619     fSDigitsFileName      += "PHOS.SDigits." ;
2620     fDigitsFileName       += "PHOS.Digits." ; 
2621     fRecPointsFileName    += "PHOS.RecData." ; 
2622     fTrackSegmentsFileName+= "PHOS.RecData." ; 
2623     fRecParticlesFileName += "PHOS.RecData." ; 
2624     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
2625       fSDigitsFileName      += fBranchTitle ;
2626       fSDigitsFileName      += "." ;
2627       fDigitsFileName       += fBranchTitle ; 
2628       fDigitsFileName       += "." ; 
2629       fRecPointsFileName    += fBranchTitle ; 
2630       fRecPointsFileName    += "." ; 
2631       fRecParticlesFileName += fBranchTitle ; 
2632       fRecParticlesFileName += "." ; 
2633       fTrackSegmentsFileName+= fBranchTitle ; 
2634       fTrackSegmentsFileName+= "." ; 
2635     }
2636     fSDigitsFileName      += "root" ;
2637     fDigitsFileName       += "root" ; 
2638     fRecPointsFileName    += "root" ; 
2639     fRecParticlesFileName += "root" ; 
2640     fTrackSegmentsFileName+= "root" ; 
2641   }else{
2642     fSDigitsFileName       = "" ; 
2643     fDigitsFileName        = "" ; 
2644     fRecPointsFileName     = "" ; 
2645     fRecParticlesFileName  = "" ; 
2646     fTrackSegmentsFileName = "" ; 
2647   }
2648   TFolder * phosFolder ; 
2649   phosFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ; 
2650   if ( !phosFolder ) 
2651     phosFolder = fHitsFolder->AddFolder("PHOS", "Hits from PHOS") ; 
2652
2653   phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2654   if ( !phosFolder ) 
2655     phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
2656   
2657   //Make folder for SDigits
2658   TString subdir(fHeaderFile) ;
2659   subdir.ReplaceAll("/","_") ;
2660   phosFolder->AddFolder(subdir, fSDigitsFileName.Data());
2661
2662
2663   phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
2664   if ( !phosFolder ) 
2665     phosFolder = fDigitsFolder->AddFolder("PHOS", "Digits from PHOS") ;  
2666
2667   phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
2668   if ( !phosFolder )
2669     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
2670   
2671
2672 }
2673 //____________________________________________________________________________ 
2674 void AliPHOSGetter::CloseSplitFiles(void){
2675   TFile * file ;
2676   file = static_cast<TFile*>(gROOT->GetFile(fSDigitsFileName.Data() ) ) ;
2677   if(file)
2678     file->Close() ;
2679   file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName.Data() ) ) ;
2680   if(file)
2681     file->Close() ;
2682   file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName.Data() ) ) ;
2683   if(file)
2684     file->Close() ;
2685   file = static_cast<TFile*>(gROOT->GetFile(fTrackSegmentsFileName.Data() ) ) ;
2686   if(file)
2687     file->Close() ;
2688   file = static_cast<TFile*>(gROOT->GetFile(fRecParticlesFileName.Data() ) ) ;
2689   if(file)
2690     file->Close() ;
2691
2692 }