Possibility to merge signal and background in split mode
[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   
569   TString subdir(headerFile) ;
570   if(fToSplit){
571     subdir.Remove(subdir.Last('/')+1,subdir.Length()) ;
572     subdir.ReplaceAll("/","_") ; 
573     subdir+="PHOS.SDigits." ;
574     if(name && (strcmp(name,"Default")!=0)){
575       subdir+=name ;
576       subdir+="." ;
577     }
578     subdir+="root" ;
579   }
580     
581   TFolder * phosSubFolder = dynamic_cast<TFolder*>(phosFolder->FindObject(subdir)) ; 
582   if ( !phosSubFolder ) 
583     phosSubFolder = phosFolder->AddFolder(subdir, ""); 
584   
585
586   TObject * sd  = phosSubFolder->FindObject(name); 
587   if ( !sd ) {
588     TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1) ;
589     sdigits->SetName(name) ;
590     phosSubFolder->Add(sdigits) ;
591   }
592   
593   return kTRUE;
594
595 //____________________________________________________________________________ 
596 TObject** AliPHOSGetter::SDigitsRef(const char * name, const char * foldername) const 
597 {  //------- SDigits ----------------------
598   
599   // the hierarchy is //Folders/RunMC/Event/Data/PHOS/SDigits/filename/SDigits
600
601   if ( !fSDigitsFolder ) {
602     Fatal("SDigitsRef", "Folder //%s not found !", fSDigitsFolder) ;
603   }    
604  
605   TFolder * phosFolder = static_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
606   if ( !phosFolder ) {
607     Fatal("SDigitsRef", "Folder //%s/PHOS not found !", fSDigitsFolder) ;
608   }
609
610   TFolder * phosSubFolder = 0 ;
611
612   phosSubFolder = dynamic_cast<TFolder *>(phosFolder->FindObject(foldername)) ;
613   
614   if(!phosSubFolder) {
615     Fatal("SDigitsRef", "Folder //Folders/RunMC/Event/Data/PHOS/%s not found !", foldername) ;
616   }
617
618   TObject * dis = phosSubFolder->FindObject(name) ;
619   if(!dis){
620     Fatal("SDigitsRef", "object %s not found !", name) ; 
621   }
622
623   return phosSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
624
625 }
626
627 //____________________________________________________________________________ 
628 const Bool_t AliPHOSGetter::PostSDigitizer(AliPHOSSDigitizer * sdigitizer) const 
629 {  //---------- SDigitizer -------------------------
630     
631   // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
632
633
634   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
635
636   if ( !sd ) {
637     Error("PostDigitizer", "Task //%s/SDigitizer not found !", fTasksFolder) ;
638     return kFALSE ;
639   }        
640   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
641   if ( !phos )  {
642     if (fDebug) {
643       Warning("PostSDigitizer", "->//%s/SDigitizer/PHOS/ not found!", fTasksFolder) ;  
644       Info("PostSDigitizer", "-> Adding //%s/SDigitizer/PHOS/", fTasksFolder) ;
645     }
646     phos = new TTask("PHOS", "") ; 
647     sd->Add(phos) ; 
648   } 
649   AliPHOSSDigitizer * phossd  = dynamic_cast<AliPHOSSDigitizer *>(phos->GetListOfTasks()->FindObject( sdigitizer->GetName() )); 
650   if (phossd) { 
651     if (fDebug)
652       Info("PostSDigitizer", "-> Task %s already exists", sdigitizer->GetName()) ; 
653     phos->GetListOfTasks()->Remove(phossd) ;
654   }
655   phos->Add(sdigitizer) ;       
656   return kTRUE; 
657   
658 }
659
660 //____________________________________________________________________________ 
661 TObject** AliPHOSGetter::SDigitizerRef(const char * name) const 
662 {  
663
664   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
665   if ( !sd ) {
666     Fatal("SDigitizerRef", "Task //%s/SDigitizer not found !", fTasksFolder) ;
667   }        
668
669   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
670   if ( !phos )  {
671     Fatal("SDigitizerRef", "//%s/SDigitizer/PHOS not found !", fTasksFolder) ;
672   }        
673
674   TTask * task = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(name)) ; 
675
676   return phos->GetListOfTasks()->GetObjectRef(task) ;
677
678 }
679
680 //____________________________________________________________________________ 
681 const Bool_t AliPHOSGetter::PostSDigitizer(const char * name, const char * file) const 
682 {  //---------- SDigitizer -------------------------
683   
684  // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
685
686   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
687   if ( !sd ) {
688     Error("PostSDigitizer", "Task //%s/SDigitizer not found !", fTasksFolder) ;
689     return kFALSE ;
690   }        
691
692   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
693   if ( !phos )  {
694     if (fDebug) {
695       Error("PostSDigitizer", "->  //%s/SDigitizer/PHOS/ not found!", fTasksFolder) ;
696       Info("PostSDigitizer", "-> Adding  //%s/SDigitizer/PHOS", fTasksFolder) ;
697     }
698     phos = new TTask("PHOS", "") ; 
699     sd->Add(phos) ; 
700   } 
701
702   TString sdname(name) ;
703   sdname.Append(":") ;
704   sdname.Append(file);
705   sdname.ReplaceAll("/","_") ; 
706   AliPHOSSDigitizer * phossd  = dynamic_cast<AliPHOSSDigitizer *>(phos->GetListOfTasks()->FindObject( sdname )); 
707   if (!phossd) {
708     phossd = new AliPHOSSDigitizer() ;  
709     //Note, we can not call constructor with parameters: it will call Getter and scew up everething
710     phossd->SetName(sdname) ;
711     phossd->SetTitle(file) ;
712     phos->Add(phossd) ; 
713   }
714   return kTRUE; 
715   
716 }
717
718 //____________________________________________________________________________ 
719 const Bool_t AliPHOSGetter::PostDigits(const char * name) const 
720 {  //---------- Digits -------------------------
721
722   // the hierarchy is //Folders/Run/Event/Data/PHOS/SDigits/name
723
724   TFolder * phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
725
726   if ( !phosFolder ) {
727     if (fDebug) {
728       Warning("PostDigitizer", "-> Folder //%s/PHOS/ not found!", fDigitsFolder) ;
729       Info("PostDigitizer", "-> Adding Folder //%s/PHOS/", fDigitsFolder) ;
730     }
731     phosFolder = fDigitsFolder->AddFolder("PHOS", "Digits from PHOS") ;  
732   }    
733  
734   TObject*  dig = phosFolder->FindObject( name ) ;
735   if ( !dig ) {
736     TClonesArray * digits = new TClonesArray("AliPHOSDigit",1000) ;
737     digits->SetName(name) ;
738     phosFolder->Add(digits) ;  
739   }
740   return kTRUE; 
741 }
742
743 //____________________________________________________________________________ 
744 TObject** AliPHOSGetter::DigitsRef(const char * name) const 
745 { //------- Digits ----------------------
746   
747   // the hierarchy is //Folders/Run/Event/Data/PHOS/Digits/name
748
749   if ( !fDigitsFolder ) {
750     Fatal("DigitsRef", "Folder //%s not found !", fDigitsFolder) ;
751   }    
752   
753   TFolder * phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ; 
754   if ( !phosFolder ) {
755     Fatal("DigitsRef", "Folder //%s/PHOS/ not found !", fDigitsFolder) ;
756   }    
757
758   TObject * d = phosFolder->FindObject(name) ;
759   if(!d) {
760     Fatal("DigitsRef", "object %s not found !", name) ; 
761   }
762
763   return phosFolder->GetListOfFolders()->GetObjectRef(d) ;
764
765 }
766
767 //____________________________________________________________________________ 
768 const Bool_t AliPHOSGetter::PostDigitizer(AliPHOSDigitizer * digitizer) const 
769 {  //---------- Digitizer -------------------------
770   
771   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
772
773   if ( !sd ) {
774     Error("PostDigitizer", "Task //%s/Digitizer not found !", fTasksFolder) ;
775     return kFALSE ;
776   }        
777   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
778   if ( !phos )  {
779     if (fDebug) {
780       Error("PostDigitizer", "//%s/Digitizer/PHOS not found!", fTasksFolder) ;
781       Info("PostDigitizer", "Adding //%s/Digitizer/PHOS", fTasksFolder) ; 
782     }
783     phos = new TTask("PHOS", "") ; 
784     sd->Add(phos) ; 
785   } 
786
787     AliPHOSDigitizer * phosd = dynamic_cast<AliPHOSDigitizer*>(phos->GetListOfTasks()->FindObject(digitizer->GetName())) ; 
788     if (phosd) { 
789       phosd->Delete() ;
790       phos->GetListOfTasks()->Remove(phosd) ;
791     }
792     phos->Add(digitizer) ; 
793     return kTRUE; 
794 }  
795
796 //____________________________________________________________________________ 
797 const Bool_t AliPHOSGetter::PostDigitizer(const char * name) const 
798 {  //---------- Digitizer -------------------------
799   
800  // the hierarchy is //Folders/Tasks/SDigitizer/PHOS/sdigitsname
801
802   TTask * d  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
803   if ( !d ) {
804     Error("PostDigitizer", "Task //%s/Digitizer not found !", fTasksFolder) ;
805     return kFALSE ;
806   }        
807
808   TTask * phos = dynamic_cast<TTask*>(d->GetListOfTasks()->FindObject("PHOS")) ; 
809   if ( !phos )  {
810     if (fDebug) {
811       Warning("PostDigitizer", "//%s/Digitizer/PHOS not found!", fTasksFolder) ; 
812       Info("PostDigitizer", "Adding //%s/Digitizer/PHOS", fTasksFolder) ;
813     }
814     phos = new TTask("PHOS", "") ; 
815     d->Add(phos) ; 
816
817
818   TTask * phosd = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(fDigitsTitle)) ; 
819   if (!phosd) { 
820     if(strcmp(name, "Digitizer")==0){
821       phosd = new AliPHOSDigitizer() ;
822       phosd->SetName(fDigitsTitle) ;
823       phosd->SetTitle(fHeaderFile) ;
824       phos->Add(phosd) ;
825     } 
826     else{
827       phosd = new AliPHOSRaw2Digits() ;
828       phosd->SetName(fDigitsTitle) ;
829       phosd->SetTitle(fHeaderFile) ;
830       phos->Add(phosd) ;
831     }      
832   }
833   return kTRUE;  
834 }
835
836 //____________________________________________________________________________ 
837 TObject** AliPHOSGetter::DigitizerRef(const char * name) const 
838 {  
839   TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ; 
840   if ( !sd ) {
841     Fatal("DigitizerRef", "Task //%s/Digitizer not found !", fTasksFolder) ;
842   }        
843
844   TTask * phos = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("PHOS")) ; 
845   if ( !phos )  {
846     Fatal("DigitizerRef", "//%s/Digitizer/PHOS", fTasksFolder) ;
847   }        
848
849   TTask * task = dynamic_cast<TTask*>(phos->GetListOfTasks()->FindObject(name)) ; 
850
851   return phos->GetListOfTasks()->GetObjectRef(task) ;
852
853 }
854  
855 //____________________________________________________________________________ 
856 const Bool_t AliPHOSGetter::PostRecPoints(const char * name) const 
857 { // -------------- RecPoints -------------------------------------------
858   
859   // the hierarchy is //Folders/Run/Event/RecData/PHOS/EMCARecPoints/name
860   // the hierarchy is //Folders/Run/Event/RecData/PHOS/CPVRecPoints/name
861
862   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
863   
864   if ( !phosFolder ) {
865     if (fDebug) {
866       Warning("PostRecPoints", "-> Folder //%s/PHOS/ not found!", fRecoFolder->GetName()) ;
867       Info("PostRecPoints", "-> Adding Folder //%s/PHOS/", fRecoFolder->GetName()) ;
868     }
869     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
870   }    
871   
872   // EMCA RecPoints 
873   TFolder * phosRPoEMCAFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("EMCARecPoints")) ;
874   if ( !phosRPoEMCAFolder ) {
875     if (fDebug) {
876       Warning("PostRecPoints", "-> Folder //%s/PHOS/EMCARecPoints/ not found!", fRecoFolder->GetName()) ;
877       Info("PostRecPoints", "-> Adding Folder //%s/PHOS/EMCARecPoints", fRecoFolder->GetName()) ;
878     }
879     phosRPoEMCAFolder = phosFolder->AddFolder("EMCARecPoints", "EMCA RecPoints from PHOS") ;  
880   }    
881   
882   TObject * erp = phosFolder->FindObject( name ) ;
883   if ( !erp )   {
884     TObjArray * emcrp = new TObjArray(100) ;
885     emcrp->SetName(name) ;
886     phosRPoEMCAFolder->Add(emcrp) ;  
887   }
888
889   // CPV RecPoints 
890   TFolder * phosRPoCPVFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("CPVRecPoints")) ;
891   if ( !phosRPoCPVFolder ) {
892     if (fDebug) {
893       Warning("PostRecPoints", "-> Folder //%s/PHOS/CPVRecPoints/ not found!", fRecoFolder->GetName()) ;
894       Info("PostRecPoints", "-> Adding Folder //%s/PHOS/CPVRecPoints/", fRecoFolder->GetName()) ;
895     }
896     phosRPoCPVFolder = phosFolder->AddFolder("CPVRecPoints", "CPV RecPoints from PHOS") ;  
897   }    
898   
899   TObject * crp =  phosRPoCPVFolder->FindObject( name ) ;
900   if ( !crp )   {
901     TObjArray * cpvrp = new TObjArray(100) ;
902     cpvrp->SetName(name) ;
903     phosRPoCPVFolder->Add(cpvrp) ;  
904   }
905   return kTRUE; 
906 }
907
908 //____________________________________________________________________________ 
909 TObject** AliPHOSGetter::EmcRecPointsRef(const char * name) const 
910 { // -------------- RecPoints -------------------------------------------
911   
912   // the hierarchy is //Folders/Run/Event/RecData/PHOS/EMCARecPoints/name
913    
914   if ( !fRecoFolder ) {
915     Fatal("EmcRecPointsRef", "Folder //%s not found !", fRecoFolder->GetName() ) ;
916   }    
917
918   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ; 
919   if ( !phosFolder ) {
920      Fatal("EmcRecPointsRef", "Folder //%s/PHOS/EMCARecPoints/ not found !", fRecoFolder->GetName() ) ;
921   }    
922
923
924   TObject * erp = phosFolder->FindObject(name ) ;
925   if ( !erp )   {
926     Fatal("EmcRecPointsRef", "object %s not found !", name) ; 
927   }
928   return phosFolder->GetListOfFolders()->GetObjectRef(erp) ;
929   
930
931
932 //____________________________________________________________________________ 
933 TObject** AliPHOSGetter::CpvRecPointsRef(const char * name) const 
934 { // -------------- RecPoints -------------------------------------------
935   
936   // the hierarchy is //Folders/Run/Event/RecData/PHOS/CPVRecPoints/name
937    
938   if ( !fRecoFolder ) {
939     Fatal("CpvRecPointsRef", "Folder //%s not found !", fRecoFolder->GetName() ) ;
940   }    
941
942   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ; 
943   if ( !phosFolder ) {
944     Fatal("CpvRecPointsRef", "Folder //%s/PHOS/CPVRecPoints/ not found !", fRecoFolder->GetName() ) ;
945   }    
946
947   TObject * crp = phosFolder->FindObject(name ) ;
948   if ( !crp )   {
949     Fatal("CpvRecPointsRef", "object %s nott found", name ) ; 
950   }
951   return phosFolder->GetListOfFolders()->GetObjectRef(crp) ;
952   
953
954
955 //____________________________________________________________________________ 
956 const Bool_t AliPHOSGetter::PostClusterizer(AliPHOSClusterizer * clu) const 
957 { // ------------------ AliPHOSClusterizer ------------------------
958   
959   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
960
961   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
962
963   if ( !tasks ) {
964     Error("PostClusterizer", "Task //%s/Reconstructioner not found !", fTasksFolder) ;
965     return kFALSE ;
966   }        
967         
968   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
969   if ( !phos )  {
970     if (fDebug) {
971       Warning("PostClusterizer", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ; 
972       Info("PostClusterizer", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ; 
973     }
974     phos = new TTask("PHOS", "") ; 
975     tasks->Add(phos) ; 
976   } 
977
978   AliPHOSClusterizer * phoscl = dynamic_cast<AliPHOSClusterizer*>(phos->GetListOfTasks()->FindObject(clu->GetName())) ; 
979   if (phoscl) { 
980     if (fDebug)
981       Info("PostClusterizer", "Task %s already exists", clu->GetName()) ; 
982     phoscl->Delete() ; 
983     phos->GetListOfTasks()->Remove(phoscl) ;
984   }
985   phos->Add(clu) ;      
986   return kTRUE; 
987
988
989 //____________________________________________________________________________ 
990 TObject** AliPHOSGetter::ClusterizerRef(const char * name) const 
991 { // ------------------ AliPHOSClusterizer ------------------------
992   
993   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
994
995   if ( !tasks ) {
996     Fatal("ClusterizerRef", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
997   }        
998         
999   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1000   if ( !phos )  {
1001     Fatal("ClusterizerRef", " //%s/Reconstructioner/PHOS not founf !", fTasksFolder->GetName() ) ; 
1002   }   
1003
1004   TList * l = phos->GetListOfTasks() ; 
1005   TIter it(l) ;
1006   TTask * task ;
1007   TTask * clu = 0 ;
1008   TString cluname(name) ;
1009   cluname+=":clu" ;
1010   while((task = static_cast<TTask *>(it.Next()) )){
1011     TString taskname(task->GetName()) ;
1012     if(taskname.BeginsWith(cluname)){
1013       clu = task ;
1014       break ;
1015     }
1016   }
1017
1018   if(!clu) {
1019     Fatal("ClusterizerRef", "Task //%s/Reconstructioner/clusterizer/%s not found", fTasksFolder->GetName(), name) ;
1020   }
1021
1022   return l->GetObjectRef(clu) ;
1023
1024 }
1025
1026 //____________________________________________________________________________ 
1027 const Bool_t AliPHOSGetter::PostClusterizer(const char * name) const 
1028 { // ------------------ AliPHOSClusterizer ------------------------
1029
1030   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1031   
1032   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1033
1034   if ( !tasks ) {
1035     Error("PostClusterizer", "Task//%s/Reconstructioner not found !", fTasksFolder) ; 
1036     return kFALSE ;
1037   }        
1038   
1039   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1040   if ( !phos )  {
1041     if (fDebug) {
1042       Warning("PostClusterizer", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ;
1043       Info("PostClusterizer", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ;
1044     }
1045     phos = new TTask("PHOS", "") ; 
1046     tasks->Add(phos) ; 
1047   } 
1048
1049   TList * l = phos->GetListOfTasks() ;   
1050   TIter it(l) ;
1051   TString clun(name) ;
1052   clun+=":clu" ; 
1053   TTask * task ;
1054   while((task = static_cast<TTask *>(it.Next()) )){
1055     TString taskname(task->GetName()) ;
1056     if(taskname.BeginsWith(clun))
1057       return kTRUE ;
1058   }
1059
1060   AliPHOSClusterizerv1 * phoscl = new AliPHOSClusterizerv1() ;
1061   clun+="-v1" ; 
1062   phoscl->SetName(clun) ;
1063   phoscl->SetTitle(fHeaderFile) ;
1064   phos->Add(phoscl) ;
1065   return kTRUE; 
1066   
1067 }
1068
1069 //____________________________________________________________________________ 
1070 const Bool_t AliPHOSGetter::PostTrackSegments(const char * name) const 
1071 { // ---------------TrackSegments -----------------------------------
1072   
1073   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1074
1075   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
1076   
1077   if ( !phosFolder ) {
1078     if (fDebug) {
1079       Warning("PostTrackSegments", "-> Folder //%s/PHOS/ not found", fRecoFolder->GetName()) ;
1080       Info("PostTrackSegments", "-> Adding Folder //%s/PHOS", fRecoFolder->GetName()) ;
1081     }
1082     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
1083   }    
1084
1085   TFolder * phosTSFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("TrackSegments")) ;
1086   if ( !phosTSFolder ) {
1087     if (fDebug) {
1088       Warning("PostTrackSegments", "-> Folder //%s/PHOS/TrackSegments/ not found!", fRecoFolder->GetName() ) ; 
1089       Info("PostTrackSegments", "-> Adding Folder //%s/PHOS/TrackSegments/", fRecoFolder->GetName()) ; 
1090     }
1091     phosTSFolder = phosFolder->AddFolder("TrackSegments", "TrackSegments from PHOS") ;  
1092   }    
1093   
1094   TObject * tss =  phosTSFolder->FindObject( name ) ;
1095   if (!tss) {
1096     TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
1097     ts->SetName(name) ;
1098     phosTSFolder->Add(ts) ;  
1099   }
1100   return kTRUE; 
1101
1102
1103 //____________________________________________________________________________ 
1104 TObject** AliPHOSGetter::TrackSegmentsRef(const char * name) const 
1105 { // ---------------TrackSegments -----------------------------------
1106   
1107   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1108
1109  if ( !fRecoFolder ) {
1110     Fatal("TrackSegmentsRef", "Folder //%s not found !", fRecoFolder->GetName() ) ;
1111   }    
1112
1113   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ; 
1114   if ( !phosFolder ) {
1115     Fatal("TrackSegmentsRef", "Folder //%s/PHOS/TrackSegments/ not found !", fRecoFolder->GetName() ) ;
1116   }    
1117   
1118   TObject * tss =  phosFolder->FindObject(name) ;
1119   if (!tss) {
1120     Fatal("TrackSegmentsRef", "object %s not found !", name) ;  
1121   }
1122   return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
1123
1124
1125 //____________________________________________________________________________ 
1126 const Bool_t AliPHOSGetter::PostTrackSegmentMaker(AliPHOSTrackSegmentMaker * tsmaker) const 
1127 { //------------Track Segment Maker ------------------------------
1128   
1129   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1130
1131   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1132
1133   if ( !tasks ) {
1134     Error("PostTrackSegmentMaker", "Task //%s/Reconstructioner not found !", fTasksFolder) ;
1135     return kFALSE ;
1136   }        
1137         
1138   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1139   if ( !phos )  {
1140     if (fDebug) {
1141       Warning("PostTrackSegmentMaker", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ; 
1142       Info("PostTrackSegmentMaker", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ;
1143     }
1144     phos = new TTask("PHOS", "") ; 
1145     tasks->Add(phos) ; 
1146   } 
1147
1148   AliPHOSTrackSegmentMaker * phosts = 
1149     dynamic_cast<AliPHOSTrackSegmentMaker*>(phos->GetListOfTasks()->FindObject(tsmaker->GetName())) ; 
1150   if (phosts) { 
1151     phosts->Delete() ;
1152     phos->GetListOfTasks()->Remove(phosts) ;
1153   }
1154   phos->Add(tsmaker) ;      
1155   return kTRUE; 
1156   
1157
1158 //____________________________________________________________________________ 
1159 const Bool_t AliPHOSGetter::PostTrackSegmentMaker(const char * name) const 
1160 { //------------Track Segment Maker ------------------------------
1161   
1162   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1163   
1164   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1165   
1166   if ( !tasks ) {
1167     Error("PostTrackSegmentMaker", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1168     return kFALSE ;
1169   }        
1170   
1171   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1172   if ( !phos )  {
1173     if (fDebug) {
1174       Warning("PostTrackSegmentMaker", "//%s/Reconstructioner/PHOS not found!", fTasksFolder->GetName() ) ; 
1175       Info("PostTrackSegmentMaker", "Adding //%s/Reconstructioner/PHOS", fTasksFolder->GetName()) ;
1176     }
1177     phos = new TTask("PHOS", "") ; 
1178     tasks->Add(phos) ; 
1179   } 
1180
1181   TList * l = phos->GetListOfTasks() ;   
1182   TIter it(l) ;
1183   TString tsn(name);
1184   tsn+=":tsm" ; 
1185   TTask * task ;
1186   while((task = static_cast<TTask *>(it.Next()) )){
1187     TString taskname(task->GetName()) ;
1188     if(taskname.BeginsWith(tsn))
1189       return kTRUE ;
1190   }
1191   
1192   AliPHOSTrackSegmentMakerv1 * phosts = new AliPHOSTrackSegmentMakerv1() ;
1193   tsn+="-v1" ;
1194   phosts->SetName(tsn) ;
1195   phosts->SetTitle(fHeaderFile) ;
1196   phos->Add(phosts) ;      
1197   return kTRUE; 
1198   
1199
1200
1201 //____________________________________________________________________________ 
1202 TObject** AliPHOSGetter::TSMakerRef(const char * name) const 
1203 { //------------Track Segment Maker ------------------------------
1204   
1205   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1206
1207   if ( !tasks ) {
1208     Fatal("TSMakerRef", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1209   }        
1210         
1211   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1212   if ( !phos )  {
1213     Fatal("TSMakerRef", "//%s/Reconstructioner/PHOS not found !", fTasksFolder->GetName() ) ; 
1214   }   
1215
1216   TList * l = phos->GetListOfTasks() ; 
1217   TIter it(l) ;
1218   TTask * task ;
1219   TTask * tsm = 0 ;
1220   TString tsmname(name) ;
1221   tsmname+=":tsm" ;
1222   while((task = static_cast<TTask *>(it.Next()) )){
1223     TString taskname(task->GetName()) ;
1224     if(taskname.BeginsWith(tsmname)){
1225       tsm = task ;
1226       break ;
1227     }
1228   }
1229   
1230   if(!tsm) {
1231    Fatal("TSMakerRef", "Task //%s/Reconstructioner/PHOS/TrackSegmentMarker/%s not found !", fTasksFolder->GetName(),  name) ;
1232   }
1233  
1234   return l->GetObjectRef(tsm) ;
1235
1236
1237
1238 //____________________________________________________________________________ 
1239 const Bool_t AliPHOSGetter::PostRecParticles(const char * name) const 
1240 {  // -------------------- RecParticles ------------------------
1241   
1242   // the hierarchy is //Folders/Run/Event/RecData/PHOS/RecParticles/name
1243
1244   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
1245   
1246   if ( !phosFolder ) {
1247     if (fDebug) {
1248       Warning("PostRecParticles", "-> Folder //%s/PHOS/ not found!", fRecoFolder->GetName()) ;
1249       Info("PostRecParticles", "-> Adding Folder //%s/PHOS/", fRecoFolder->GetName()) ;
1250     }
1251     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
1252   }    
1253
1254  TFolder * phosRPaFolder  = dynamic_cast<TFolder*>(phosFolder->FindObject("RecParticles")) ;
1255   if ( !phosRPaFolder ) {
1256     if (fDebug) {
1257       Warning("PostRecParticles", "-> Folder //%s/PHOS/RecParticles/ not found!", fRecoFolder->GetName()) ;
1258       Info("PostRecParticles", "-> Adding Folder //%s/PHOS/RecParticles/", fRecoFolder->GetName()) ;
1259     }
1260     phosRPaFolder = phosFolder->AddFolder("RecParticles", "RecParticles from PHOS") ;  
1261   } 
1262
1263   TObject * rps = phosRPaFolder->FindObject( name )  ;
1264   if ( !rps ) {
1265     TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
1266     rp->SetName(name) ;    
1267     phosRPaFolder->Add(rp) ;  
1268   }
1269   return kTRUE; 
1270
1271
1272 //____________________________________________________________________________ 
1273 TObject** AliPHOSGetter::RecParticlesRef(const char * name) const 
1274 { // ---------------RecParticles -----------------------------------
1275   
1276   // the hierarchy is //Folders/Run/Event/RecData/PHOS/TrackSegments/name
1277
1278  if ( !fRecoFolder ) {
1279     Fatal("RecParticlesRef", "Folder//%s not found !", fRecoFolder->GetName() ) ; 
1280   }    
1281
1282   TFolder * phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ; 
1283   if ( !phosFolder ) {
1284     Fatal("RecParticlesRef", "Folder //%s/PHOS/RecParticles/ not found !", fRecoFolder->GetName() ) ;
1285   }    
1286
1287   TObject * tss =  phosFolder->FindObject(name  ) ;
1288   if (!tss) {
1289     Fatal("RecParticlesRef", "object %s not found !", name) ; 
1290   }
1291   return phosFolder->GetListOfFolders()->GetObjectRef(tss) ;
1292 }
1293
1294 //____________________________________________________________________________ 
1295 const Bool_t AliPHOSGetter::PostPID(AliPHOSPID * pid) const 
1296 {      // ------------AliPHOS PID -----------------------------
1297
1298   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1299
1300   if ( !tasks ) {
1301     Error("PostPID", "Task //%s/Reconstructioner not found !", fTasksFolder) ;
1302     return kFALSE ;
1303   }        
1304   
1305   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1306   if ( !phos )  {
1307     if (fDebug) {
1308       Warning("PostPID", "//%s/Reconstructioner/PHOS not found!", fTasksFolder) ; 
1309       Info("PostPID", "Adding //%s/Reconstructioner/PHOS", fTasksFolder) ;
1310     }
1311     phos = new TTask("PHOS", "") ; 
1312     tasks->Add(phos) ; 
1313   } 
1314
1315   AliPHOSPID * phospid = dynamic_cast<AliPHOSPID*>(phos->GetListOfTasks()->FindObject(pid->GetName())) ; 
1316   if (phospid) { 
1317     if (fDebug)
1318       Info("PostPID", "-> Task %s qlready exists", pid->GetName()) ; 
1319     phos->GetListOfTasks()->Remove(phospid) ;
1320   }
1321   
1322   phos->Add(pid) ;      
1323   return kTRUE; 
1324
1325
1326 //____________________________________________________________________________ 
1327 const Bool_t AliPHOSGetter::PostPID(const char * name) const 
1328 {     
1329   // the hierarchy is //Folders/Tasks/Reconstructioner/PHOS/sdigitsname
1330   
1331   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1332
1333   if ( !tasks ) {
1334     Error("PostPID", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1335     return kFALSE ;
1336   }        
1337   
1338   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1339   if ( !phos )  {
1340     if (fDebug) {
1341       Warning("PostPID", "//%s/Reconstructioner/PHOS not found!", fTasksFolder->GetName()) ; 
1342       Info("PostPID", "Adding //%s/Reconstructioner/PHOS", fTasksFolder->GetName()) ;
1343     }
1344     phos = new TTask("PHOS", "") ; 
1345     tasks->Add(phos) ; 
1346   } 
1347
1348   TList * l = phos->GetListOfTasks() ;   
1349   TIter it(l) ;
1350   TString pidname(name) ;
1351   pidname+=":pid" ;
1352   TTask * task ;
1353   while((task = static_cast<TTask *>(it.Next()) )){
1354     TString taskname(task->GetName()) ;
1355     if(taskname.BeginsWith(pidname))
1356       return kTRUE ;
1357   }
1358  
1359   AliPHOSPIDv1 * phospid = new AliPHOSPIDv1() ;
1360   pidname+="-v1" ;
1361   phospid->SetName(pidname) ; 
1362   phospid->SetTitle(fHeaderFile) ;
1363   phos->Add(phospid) ;      
1364   
1365   return kTRUE; 
1366
1367
1368 //____________________________________________________________________________ 
1369 TObject** AliPHOSGetter::PIDRef(const char * name) const 
1370 { //------------PID ------------------------------
1371
1372   TTask * tasks  = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ; 
1373
1374   if ( !tasks ) {
1375     Fatal("PIDRef", "Task //%s/Reconstructioner not found !", fTasksFolder->GetName() ) ;
1376   }        
1377         
1378   TTask * phos = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
1379   if ( !phos )  {
1380     Fatal("PIDRef", "//%s/Reconstructioner/PHOS not found !", fTasksFolder->GetName() ) ; 
1381   }   
1382   
1383   TList * l = phos->GetListOfTasks() ; 
1384   TIter it(l) ;
1385   TTask * task ;
1386   TTask * pid = 0 ;
1387   TString pidname(name) ;
1388   pidname+=":pid" ;
1389   while((task = static_cast<TTask *>(it.Next()) )){
1390     TString taskname(task->GetName()) ;
1391     if(taskname.BeginsWith(pidname)){
1392       pid = task ;
1393       break ;
1394     }
1395   }
1396   
1397   if(!pid) {
1398     Fatal("PIDRef", "Task //%s/Reconstructioner/PHOS/PID/%s not found !", fTasksFolder->GetName(), name) ;
1399   }
1400   
1401     return l->GetObjectRef(pid) ;
1402
1403
1404 //____________________________________________________________________________ 
1405 const Bool_t AliPHOSGetter::PostQA(void) const 
1406 { // ------------------ QA ---------------------------------
1407
1408   // the hierarchy is //Folders/Run/Conditions/QA/PHOS/alarmsName
1409
1410   TFolder * phosFolder = dynamic_cast<TFolder*>(fQAFolder->FindObject("PHOS")) ; 
1411   if ( !phosFolder ) {
1412     if (fDebug) {
1413       Warning("PostQA", "-> Folder //%s/PHOS/ not found!", fQAFolder) ;
1414       Info("PostQA", "-> Adding Folder //%s/PHOS", fQAFolder) ;
1415     }
1416     phosFolder = fQAFolder->AddFolder("PHOS", "QA from PHOS") ; 
1417   }      
1418
1419   return kTRUE;
1420 }
1421
1422 //____________________________________________________________________________ 
1423 TObject** AliPHOSGetter::AlarmsRef(void) const 
1424 {  //------- Alarms ----------------------
1425
1426   
1427   // the hierarchy is //Folders/Run/Conditions/QA/PHOS
1428   if ( !fQAFolder ) {
1429     Fatal("AlarmsRef", "Folder //%s not found !", fQAFolder) ;
1430   }    
1431  
1432   TFolder * phosFolder = dynamic_cast<TFolder *>(fQAFolder->FindObject("PHOS")) ;
1433   if ( !phosFolder ) {
1434     Fatal("AlarmsRef", "Folder //%s/PHOS/ not found !", fQAFolder) ;
1435   }
1436    
1437   return fQAFolder->GetListOfFolders()->GetObjectRef(phosFolder) ;
1438 }
1439
1440
1441 //____________________________________________________________________________ 
1442 TTree * AliPHOSGetter::TreeK(TString filename)  
1443 {
1444
1445   // returns TreeK from file filename
1446   // usefull in case of split file
1447
1448   if ( filename.IsNull() ) 
1449     filename = fHeaderFile ; 
1450
1451   TFile * file = 0 ; 
1452   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1453   if (file && (filename != fHeaderFile) ) {  // file already open 
1454     file->Close() ; 
1455     delete fAlice ; 
1456   }    
1457   file = TFile::Open(filename.Data(), "read") ; 
1458   fAlice = static_cast<AliRun *>(file->Get("gAlice")) ; 
1459   TString treeName("TreeK") ; 
1460   treeName += EventNumber()  ; 
1461   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1462   if (!tree && fDebug)  
1463     Warning("TreeK", "-> %s not found in %s", treeName.Data(), filename.Data()) ; 
1464   
1465   return tree ;                       
1466 }
1467
1468 //____________________________________________________________________________ 
1469 TTree * AliPHOSGetter::TreeH(TString filename)  
1470 {
1471
1472   // returns TreeH from file filename
1473   // usefull in case of split file
1474
1475   if ( filename.IsNull() ) 
1476     filename = fHeaderFile ; 
1477
1478   TFile * file = 0 ; 
1479   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1480   if (!file) { // file not open yet
1481     file = TFile::Open(filename.Data(), "read") ; 
1482   }
1483   TString treeName("TreeH") ; 
1484   treeName += EventNumber()  ; 
1485   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1486   if (!tree && fDebug)  
1487     Warning("TreeH", "-> %s not found in %s", treeName.Data(), filename.Data()) ; 
1488   
1489   return tree ;                       
1490 }
1491
1492 //____________________________________________________________________________ 
1493 TTree * AliPHOSGetter::TreeS(TString filename)  
1494 {
1495
1496   // returns TreeS from file filename
1497   // usefull in case of split file
1498
1499   if ( filename.IsNull() ) 
1500     filename = fHeaderFile ; 
1501
1502   TFile * file = 0 ; 
1503   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1504   if (!file) { // file not open yet
1505     file = TFile::Open(filename.Data(), "read") ; 
1506   }
1507   TString treeName("TreeS") ; 
1508   treeName += EventNumber()  ; 
1509   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1510   if (!tree && fDebug)  
1511     Warning("TreeS", "-> %s not found in %s", treeName.Data(), filename.Data() ); 
1512   
1513   return tree ;                       
1514 }
1515
1516 //____________________________________________________________________________ 
1517 TTree * AliPHOSGetter::TreeD(TString filename)  
1518 {
1519
1520   // returns TreeD from file filename
1521   // usefull in case of split file
1522
1523   if ( filename.IsNull() ) 
1524     filename = fHeaderFile ; 
1525
1526   TFile * file = 0 ; 
1527   file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
1528   if (!file) { // file not open yet
1529     file = TFile::Open(filename.Data(), "read") ; 
1530   }
1531   TString treeName("TreeD") ; 
1532   treeName += EventNumber()  ; 
1533   TTree * tree = static_cast<TTree *>(file->Get(treeName.Data())) ;
1534   if (!tree && fDebug)  
1535     Warning("TreeD", "-> %s not found in %s", treeName.Data(), filename.Data()) ; 
1536   
1537   return tree ;                       
1538 }
1539
1540 //____________________________________________________________________________ 
1541 const TParticle * AliPHOSGetter::Primary(Int_t index) const 
1542 {
1543   // Return primary particle numbered by <index>
1544
1545   if(index < 0) 
1546     return 0 ;
1547   TParticle *  p = 0 ;
1548   if (fAlice) 
1549     p = fAlice->Particle(index) ; 
1550   else 
1551     p = gAlice->Particle(index) ; 
1552   
1553   return p ; 
1554     
1555 }
1556
1557 //____________________________________________________________________________ 
1558 const TParticle * AliPHOSGetter::Secondary(TParticle* p, Int_t index) const
1559 {
1560   // Return first (index=1) or second (index=2) secondary particle of primary particle p 
1561
1562   if(index <= 0) 
1563     return 0 ;
1564   if(index > 2)
1565     return 0 ;
1566
1567   if(p) {
1568   Int_t daughterIndex = p->GetDaughter(index-1) ; 
1569   return  gAlice->Particle(daughterIndex) ; 
1570   }
1571   else
1572     return 0 ;
1573 }
1574
1575 //____________________________________________________________________________ 
1576 Int_t AliPHOSGetter::ReadTreeD(const Int_t event)
1577 {
1578   // Read the digit tree gAlice->TreeD()  
1579   
1580   TTree * treeD ;
1581   if(fToSplit){
1582     TFile * file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName)); 
1583     if(!file) 
1584       file = TFile::Open(fDigitsFileName) ;      
1585     // Get Digits Tree header from file
1586     TString treeName("TreeD") ;
1587     treeName += event ; 
1588     treeD = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1589     if(!treeD){ // TreeD not found in header file
1590       if (fDebug)
1591         Warning("ReadTreeD", "-> Cannot find TreeD in %s", fDigitsFileName.Data()) ;
1592       return 1;
1593     }
1594   }
1595   else
1596     treeD = gAlice->TreeD() ;
1597   
1598   TObjArray * lob = static_cast<TObjArray*>(treeD->GetListOfBranches()) ;
1599   TIter next(lob) ; 
1600   TBranch * branch = 0 ; 
1601   TBranch * digitsbranch = 0 ; 
1602   TBranch * digitizerbranch = 0 ; 
1603   Bool_t phosfound = kFALSE, digitizerfound = kFALSE ; 
1604   
1605   while ( (branch = static_cast<TBranch*>(next())) && (!phosfound || !digitizerfound) ) {
1606     if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1607       digitsbranch = branch ; 
1608       phosfound = kTRUE ;
1609     }
1610     else if ( ((strcmp(branch->GetName(), "AliPHOSDigitizer")==0)||
1611                (strcmp(branch->GetName(), "AliPHOSRaw2Digits")==0)) &&
1612               (strcmp(branch->GetTitle(), fDigitsTitle)==0) ) {
1613       digitizerbranch = branch ; 
1614       digitizerfound = kTRUE ; 
1615     }
1616   }
1617   
1618   if ( !phosfound || !digitizerfound ) {
1619     if (fDebug)
1620       Warning("ReadTreeD", "-> Cannot find Digits and/or Digitizer with name %s", fDigitsTitle.Data()) ;
1621     return 2; 
1622   }   
1623   
1624   //read digits
1625   if(!Digits(fDigitsTitle) ) 
1626     PostDigits(fDigitsTitle);
1627   digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
1628   digitsbranch->GetEntry(0) ;
1629   
1630   
1631   // read  the Digitizer
1632   if(Digitizer()){
1633     if(strcmp(Digitizer()->IsA()->GetName(),digitizerbranch->GetName())!=0){
1634       RemoveTask("D", fDigitsTitle) ;
1635       if(strcmp(digitizerbranch->GetName(), "AliPHOSDigitizer")==0)
1636         PostDigitizer("Digitizer") ;
1637       else
1638         PostDigitizer("Raw2Digits") ;
1639     }
1640   }
1641   else{
1642     if(strcmp(digitizerbranch->GetName(), "AliPHOSDigitizer")==0)
1643       PostDigitizer("Digitizer") ;
1644     else
1645       PostDigitizer("Raw2Digits") ;
1646   }
1647     
1648
1649   digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
1650   digitizerbranch->GetEntry(0) ;
1651   
1652
1653   if((!fcdb)&&(strcmp(digitizerbranch->GetName(), "AliPHOSRaw2Digits")==0))
1654     ReadCalibrationDB("Primordial","beamtest.root") ;
1655   
1656   if(gAlice->TreeD()!=treeD)
1657     treeD->Delete();
1658
1659   return 0 ; 
1660 }
1661 //____________________________________________________________________________ 
1662 void AliPHOSGetter::ReadCalibrationDB(const char * database,const char * filename){
1663
1664   if(fcdb && (strcmp(database,fcdb->GetTitle())==0))
1665     return ;
1666
1667   TFile * file = gROOT->GetFile(filename) ;
1668   if(!file)
1669     file = TFile::Open(filename);
1670   if(!file){
1671     Error ("ReadCalibrationDB", "Cannot open file %s", filename) ;
1672     return ;
1673   }
1674   if(fcdb)
1675     fcdb->Delete() ;
1676   fcdb = dynamic_cast<AliPHOSCalibrationDB *>(file->Get("AliPHOSCalibrationDB")) ;
1677   if(!fcdb)
1678     Error ("ReadCalibrationDB", "No database %s in file %s", database, filename) ;
1679 }
1680
1681 //____________________________________________________________________________ 
1682 Int_t AliPHOSGetter::ReadTreeH()
1683 {
1684   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1685   
1686   TTree * treeH = gAlice->TreeH() ;
1687
1688   if(!treeH) {// TreeH not found in header file
1689  
1690     if (fDebug) 
1691       Warning("ReadTreeH", "-> Cannot find TreeH in %s", fHeaderFile.Data() ) ;
1692     
1693     TString searchFileName("PHOS.Hits") ; 
1694     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
1695       searchFileName+="." ;
1696       searchFileName += fBranchTitle ;
1697     }
1698     searchFileName+=".root" ;
1699     
1700     if ( (treeH = TreeH(searchFileName)) ) { //found TreeH in the file which contains the hits
1701       if (fDebug) 
1702         Info("ReadTreeH", "-> TreeH found in %s", searchFileName.Data()) ; 
1703       
1704     } else {
1705       Error("ReadTreeH", "TreeH not found") ; 
1706       return 1;
1707     }  
1708   }
1709   
1710   TBranch * hitsbranch = static_cast<TBranch*>(treeH->GetBranch("PHOS")) ;
1711   if ( !hitsbranch ) {
1712     if (fDebug)
1713       Warning("ReadTreeH", "-> Cannot find branch PHOS") ; 
1714     return 2;
1715   }
1716   if(!Hits())
1717     PostHits() ;
1718
1719   if (hitsbranch->GetEntries() > 1 ) {
1720     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1721     TClonesArray * tempo =  new TClonesArray("AliPHOSHit",1000) ;
1722     TClonesArray * hits = dynamic_cast<TClonesArray*>(*HitsRef()) ; 
1723     hitsbranch->SetAddress(&tempo) ;
1724     Int_t index = 0 ; 
1725     Int_t i = 0 ;
1726     for (i = 0 ; i < hitsbranch->GetEntries() ; i++) {
1727       hitsbranch->GetEntry(i) ;
1728       Int_t j = 0 ; 
1729       for ( j = 0 ; j < tempo->GetEntries() ; j++) { 
1730         const AliPHOSHit * hit = static_cast<const AliPHOSHit *>(tempo->At(j)) ; 
1731         new((*hits)[index]) AliPHOSHit( *hit ) ;
1732         index++ ; 
1733       }
1734     }
1735     delete tempo ; 
1736   }
1737   else {
1738     (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1739     hitsbranch->SetAddress(HitsRef()) ;
1740     hitsbranch->GetEntry(0) ;
1741   }
1742   return 0 ; 
1743 }
1744
1745 //____________________________________________________________________________ 
1746 void AliPHOSGetter::Track(const Int_t itrack) 
1747 {
1748   // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
1749
1750   if(gAlice->TreeH()== 0){
1751     Error("Track", "Cannot read TreeH") ;
1752     return ;
1753   }
1754   
1755   TBranch * hitsbranch = dynamic_cast<TBranch*>(gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS")) ;
1756   if ( !hitsbranch ) {
1757     if (fDebug)
1758       Warning("Track", "Cannot find branch PHOS") ; 
1759     return ;
1760   }  
1761   if(!Hits())
1762     PostHits() ;
1763
1764   (dynamic_cast<TClonesArray*> (*HitsRef()))->Clear() ;
1765   hitsbranch->SetAddress(HitsRef()) ;
1766   hitsbranch->GetEntry(itrack) ;
1767
1768 }
1769
1770 //____________________________________________________________________________ 
1771 void AliPHOSGetter::ReadTreeQA()
1772 {
1773   // Read the digit tree gAlice->TreeQA()
1774   // so far only PHOS knows about this Tree  
1775
1776   if(PHOS()->TreeQA()== 0){
1777     Error("ReadTreeQA", "Cannot read TreeQA") ;
1778     return ;
1779   }
1780   
1781   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ; 
1782   if (!qabranch) { 
1783     if (fDebug)
1784       Warning("ReadTreeQA", "Cannot find QA Alarms for PHOS");
1785     return ; 
1786   }   
1787   
1788   if(!Alarms())
1789     PostQA() ; 
1790
1791   qabranch->SetAddress(AlarmsRef()) ;
1792
1793   qabranch->GetEntry(0) ;
1794  
1795 //   PostQA("PHOS") ; 
1796 //   TFolder * alarmsF = Alarms() ; 
1797 //   alarmsF->Clear() ; 
1798 //   qabranch->SetAddress(&alarmsF) ;
1799 //   qabranch->GetEntry(0) ;
1800   
1801 }
1802
1803 //____________________________________________________________________________ 
1804 Int_t AliPHOSGetter::ReadTreeR(const Int_t event)
1805 {
1806   // Read the reconstrunction tree gAlice->TreeR()
1807   // A particularity has been introduced here :
1808   //  if gime->Event(ievent,"R") is called branches with the current title are read, the current title
1809   //   being for example give in AliPHOSPID(fileName, title)
1810   //  if gime(Event(ievent, "RA") is called the title of the branches is not checked anymore, "A" stands for any
1811   // This is a feature needed by PID to be able to reconstruct several times particles (each time a ther title is given)
1812   // from a given set of TrackSegments (with a given name)
1813   // This is why any is NOT used to read the branch of RecParticles
1814   // any migh have become obsolete : to be checked
1815   // See AliPHOSPIDv1    
1816
1817   TTree * treeR ;
1818   if(fToSplit){
1819     TFile * file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName)); 
1820     if(!file) 
1821       file = TFile::Open(fRecPointsFileName) ;      
1822     // Get Digits Tree header from file
1823     TString treeName("TreeR") ;
1824     treeName += event ; 
1825     treeR = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1826     if(!treeR){ // TreeR not found in header file
1827       if (fDebug)
1828         Warning("ReadTreeD", "-> Cannot find TreeR in %s", fRecPointsFileName.Data()) ;
1829       return 1;
1830     }
1831   }
1832   else
1833     treeR = gAlice->TreeR() ;
1834   
1835   // RecPoints 
1836   TObjArray * lob = static_cast<TObjArray*>(treeR->GetListOfBranches()) ;
1837   TIter next(lob) ; 
1838   TBranch * branch = 0 ; 
1839   TBranch * emcbranch = 0 ; 
1840   TBranch * cpvbranch = 0 ; 
1841   TBranch * clusterizerbranch = 0 ; 
1842   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ; 
1843
1844   
1845   while ( (branch = static_cast<TBranch*>(next())) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) ) {
1846     if(strcmp(branch->GetTitle(), fRecPointsTitle)==0 ) {
1847       if ( strcmp(branch->GetName(), "PHOSEmcRP")==0) {
1848         emcbranch = branch ; 
1849         phosemcrpfound = kTRUE ;
1850       }
1851       else if ( strcmp(branch->GetName(), "PHOSCpvRP")==0) {
1852         cpvbranch = branch ; 
1853         phoscpvrpfound = kTRUE ;
1854       }
1855       else if(strcmp(branch->GetName(), "AliPHOSClusterizer")==0){
1856         clusterizerbranch = branch ; 
1857         clusterizerfound = kTRUE ; 
1858       }
1859     }
1860   }
1861
1862   if ( !phosemcrpfound || !phoscpvrpfound || !clusterizerfound) {
1863     if (fDebug)
1864       Warning("ReadTreeR", "-> Cannot find RecPoints and/or Clusterizer with name %s", fRecPointsTitle.Data() ) ;
1865  
1866   } else { 
1867     if(!EmcRecPoints(fRecPointsTitle) ) 
1868       PostRecPoints(fRecPointsTitle) ;
1869     
1870     emcbranch->SetAddress(EmcRecPointsRef(fRecPointsTitle)) ;
1871     emcbranch->GetEntry(0) ;
1872
1873     cpvbranch->SetAddress(CpvRecPointsRef(fRecPointsTitle)) ; 
1874     cpvbranch->GetEntry(0) ;  
1875     
1876     if(!Clusterizer(fRecPointsTitle) )
1877       PostClusterizer(fRecPointsTitle) ;
1878     
1879     clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
1880     clusterizerbranch->GetEntry(0) ;
1881   }
1882   
1883   //------------------- TrackSegments ---------------------
1884   next.Reset() ; 
1885   TBranch * tsbranch = 0 ; 
1886   TBranch * tsmakerbranch = 0 ; 
1887   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ; 
1888   while ( (branch = static_cast<TBranch*>(next())) && (!phostsfound || !tsmakerfound) ) {
1889     if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0 )  {
1890       if ( strcmp(branch->GetName(), "PHOSTS")==0){
1891         tsbranch = branch ; 
1892         phostsfound = kTRUE ;
1893       }
1894       else if(strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) {
1895         tsmakerbranch = branch ; 
1896         tsmakerfound  = kTRUE ; 
1897       }
1898     }
1899   }
1900
1901   if ( !phostsfound || !tsmakerfound ) {
1902     if (fDebug)
1903       Warning("ReadTreeR", "-> Cannot find TrackSegments and/or TrackSegmentMaker with name %s", fTrackSegmentsTitle.Data() ) ;
1904   } else { 
1905     // Read and Post the TrackSegments
1906     if(!TrackSegments(fTrackSegmentsTitle))
1907       PostTrackSegments(fTrackSegmentsTitle) ;
1908     tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
1909     tsbranch->GetEntry(0) ;
1910
1911     // Read and Post the TrackSegment Maker
1912     if(!TrackSegmentMaker(fTrackSegmentsTitle))
1913       PostTrackSegmentMaker(fTrackSegmentsTitle) ;
1914     tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
1915     tsmakerbranch->GetEntry(0) ;
1916  }
1917   
1918   
1919   //------------ RecParticles ----------------------------
1920   next.Reset() ; 
1921   TBranch * rpabranch = 0 ; 
1922   TBranch * pidbranch = 0 ; 
1923   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ; 
1924   
1925   while ( (branch = static_cast<TBranch*>(next())) && (!phosrpafound || !pidfound) ) 
1926     if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {   
1927       if ( strcmp(branch->GetName(), "PHOSRP")==0) {   
1928         rpabranch = branch ; 
1929         phosrpafound = kTRUE ;
1930       }
1931       else if (strcmp(branch->GetName(), "AliPHOSPID")==0) {
1932         pidbranch = branch ; 
1933         pidfound  = kTRUE ; 
1934       }
1935     }
1936   
1937   if ( !phosrpafound || !pidfound ) {
1938     if (fDebug)
1939       Warning("ReadTreeR", "-> Cannot find RecParticles and/or PID with name %s", fRecParticlesTitle.Data() ) ; 
1940   } else { 
1941     // Read and Post the RecParticles
1942     if(!RecParticles(fRecParticlesTitle)) 
1943       PostRecParticles(fRecParticlesTitle) ;
1944     rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
1945     rpabranch->GetEntry(0) ;
1946     // Read and Post the PID
1947     if(!PID(fRecParticlesTitle))
1948       PostPID(fRecParticlesTitle) ;
1949     pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
1950     pidbranch->GetEntry(0) ;
1951   }
1952
1953   if(gAlice->TreeR()!=treeR)
1954     treeR->Delete();
1955   return 0 ; 
1956 }
1957
1958 //____________________________________________________________________________ 
1959 Int_t AliPHOSGetter::ReadTreeS(const Int_t event)
1960 {
1961   // Reads the SDigits treeS from all files  
1962   // Files, which should be opened are listed in phosF
1963   // So, first get list of files
1964   TFolder * phosF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("PHOS")) ;
1965   if (!phosF) 
1966     phosF = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
1967   TCollection * folderslist = phosF->GetListOfFolders() ; 
1968   
1969   // Now iterate over the list of files and read TreeS into Whiteboard
1970   TIter next(folderslist) ; 
1971   TFolder * folder = 0 ; 
1972   TFile * file; 
1973   TTree * treeS = 0;
1974   while ( (folder = static_cast<TFolder*>(next())) ) {
1975     TString fileName("") ;
1976     fileName = folder->GetName() ; 
1977     fileName.ReplaceAll("_","/") ; 
1978     file = static_cast<TFile*>(gROOT->GetFile(fileName)); 
1979     if(!file) 
1980       file = TFile::Open(fileName) ;      
1981     // Get SDigits Tree header from file
1982     TString treeName("TreeS") ;
1983     treeName += event ; 
1984     treeS = dynamic_cast<TTree*>(file->Get(treeName.Data()));
1985
1986     if(!treeS){ // TreeS not found in header file
1987       if (fDebug)
1988         Warning("ReadTreeS", "-> Cannot find TreeS in %s", fileName.Data()) ;
1989       return 1;
1990     }
1991     
1992     //set address of the SDigits and SDigitizer
1993     TBranch   * sdigitsBranch    = 0;
1994     TBranch   * sdigitizerBranch = 0;
1995     TBranch   * branch           = 0 ;  
1996     TObjArray * lob = static_cast<TObjArray*>(treeS->GetListOfBranches()) ;
1997     TIter next(lob) ; 
1998     Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
1999
2000     while ( (branch = static_cast<TBranch*>(next())) && (!phosfound || !sdigitizerfound) ) {
2001       if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
2002         phosfound = kTRUE ;
2003         sdigitsBranch = branch ; 
2004       }
2005       
2006       else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && 
2007                 (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
2008         sdigitizerfound = kTRUE ; 
2009         sdigitizerBranch = branch ;
2010       }
2011     }
2012     if ( !phosfound || !sdigitizerfound ) {
2013       if (fDebug)
2014         Warning("ReadSDigits", "-> Digits and/or Digitizer branch with name %s not found", GetName()) ;
2015       return 2; 
2016     }   
2017     
2018     if ( !folder->FindObject(fSDigitsTitle) ){  
2019       TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1) ;
2020       sdigits->SetName(fSDigitsTitle) ;
2021       folder->Add(sdigits) ;
2022     }
2023
2024     ((TClonesArray*) (*SDigitsRef(fSDigitsTitle,folder->GetName())))->Clear() ;
2025     sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
2026     sdigitsBranch->GetEntry(0) ;
2027     
2028     TString sdname(fSDigitsTitle) ;
2029     sdname+=":" ;
2030     sdname+=folder->GetName() ;
2031     if(!SDigitizer(sdname) ) 
2032       PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
2033     sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
2034     sdigitizerBranch->GetEntry(0) ; 
2035     if(gAlice->TreeS()!=treeS)
2036       treeS->Delete();
2037   }    
2038   return 0 ; 
2039 }
2040
2041 //____________________________________________________________________________ 
2042 void AliPHOSGetter::ReadTreeS(TTree * treeS, Int_t input)
2043
2044 {  // Read the summable digits fron treeS()  
2045
2046
2047   TString filename("mergefile") ;
2048   filename+= input ;
2049
2050   TFolder * phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ; 
2051   if ( !phosFolder ) { 
2052    phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
2053   } 
2054   TFolder * folder=(TFolder*)phosFolder->FindObject(filename) ;
2055   //set address of the SDigits and SDigitizer
2056   TBranch   * sdigitsBranch    = 0;
2057   TBranch   * sdigitizerBranch = 0;
2058   TBranch   * branch           = 0 ;  
2059   TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
2060   TIter next(lob) ; 
2061   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
2062   
2063   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
2064     if ( strcmp(branch->GetName(), "PHOS")==0) {
2065       phosfound = kTRUE ;
2066       sdigitsBranch = branch ; 
2067     }
2068     
2069     else if ( strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) {
2070       sdigitizerfound = kTRUE ; 
2071       sdigitizerBranch = branch ;
2072     }
2073   }
2074   if ( !phosfound || !sdigitizerfound ) {
2075     if (fDebug)
2076       Warning("ReadTreeS", "-> Digits and/or Digitizer branch not found") ;
2077     return ; 
2078   }   
2079   
2080   if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
2081     PostSDigits(sdigitsBranch->GetTitle(),filename) ;
2082
2083   sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),folder->GetName())) ;
2084   sdigitsBranch->GetEntry(0) ;
2085   
2086   TString sdname(sdigitsBranch->GetTitle()) ;
2087   sdname+=":" ;
2088   sdname+=filename ;
2089   
2090   if(!SDigitizer(sdigitsBranch->GetTitle()) )
2091     PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
2092   sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
2093   sdigitizerBranch->GetEntry(0) ;
2094   if(gAlice->TreeS()!=treeS)
2095     treeS->Delete();
2096 }    
2097
2098
2099 //____________________________________________________________________________ 
2100 void AliPHOSGetter::ReadPrimaries()
2101 {
2102   // a lot simplified.... if 2 files are opened then we have a problem
2103
2104   TClonesArray * ar = 0  ; 
2105   if(! (ar = Primaries()) ) { 
2106     PostPrimaries() ;
2107     ar = Primaries() ; 
2108   }
2109   ar->Delete() ; 
2110   
2111   if (TreeK(fHeaderFile)) { // treeK found in header file
2112     if (fDebug) 
2113       Info("ReadPrimaries", "-> TreeK found in %s", fHeaderFile.Data() ); 
2114     fNPrimaries = gAlice->GetNtrack() ; 
2115     fAlice = 0 ; 
2116   
2117   } else { // treeK not found in header file
2118     
2119     Error("ReadPrimaries", "TreeK not found") ; 
2120     return ;
2121     
2122   }
2123   Int_t index = 0 ; 
2124   for (index = 0 ; index < fNPrimaries; index++) { 
2125     new ((*ar)[index]) TParticle(*(Primary(index)));
2126   }
2127 }
2128
2129 //____________________________________________________________________________ 
2130 void AliPHOSGetter::Event(const Int_t event, const char* opt)  
2131 {
2132   // Reads the content of all Tree's S, D and R
2133
2134   if (event >= gAlice->TreeE()->GetEntries() ) {
2135     Error("Event", "%d not found in TreeE !", event) ; 
2136     return ; 
2137   }
2138
2139   Bool_t any = kFALSE ; 
2140   if (strstr(opt,"A") ) // do not check the title of the branches
2141     any = kTRUE; 
2142
2143   gAlice->GetEvent(event) ; 
2144
2145   if( strstr(opt,"R") )
2146     ReadTreeR(event) ;
2147
2148   if( strstr(opt,"D") )
2149     ReadTreeD(event) ;
2150
2151   if(strstr(opt,"S") )
2152     ReadTreeS(event) ;
2153
2154   if(strstr(opt,"H") )
2155     ReadTreeH() ;
2156    
2157   if( strstr(opt,"Q") )
2158     ReadTreeQA() ;
2159  
2160   if( strstr(opt,"P") || (strcmp(opt,"")==0) )
2161     ReadPrimaries() ;
2162   
2163 }
2164
2165 //____________________________________________________________________________ 
2166 TObject * AliPHOSGetter::ReturnO(TString what, TString name, TString file) const 
2167 {
2168   // get the object named "what" from the folder
2169   // folders are named like //Folders
2170
2171   if ( file.IsNull() ) 
2172     file = fHeaderFile ; 
2173   if( name.IsNull() )
2174     name = fBranchTitle ;
2175
2176   TFolder * folder = 0 ;
2177   TObject * phosO  = 0 ; 
2178
2179   if ( what.CompareTo("Primaries") == 0 ) {
2180     folder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ; 
2181     if (folder) 
2182       phosO  = dynamic_cast<TObject *>(folder->FindObject("Primaries")) ;  
2183     else 
2184       return 0 ; 
2185   }
2186   else if ( what.CompareTo("Hits") == 0 ) {
2187     folder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("PHOS")) ; 
2188     if (folder) 
2189       phosO  = dynamic_cast<TObject *>(folder->FindObject("Hits")) ;  
2190   }
2191   else if ( what.CompareTo("SDigits") == 0 ) {
2192     if(fToSplit){
2193       file.Remove(file.Last('/')+1,file.Length()-file.Last('/')-1) ;
2194       file.ReplaceAll("/","_") ; 
2195       file+="PHOS.SDigits." ;
2196       if(name && (strcmp(name,"Default")!=0)){
2197         file+=name ;
2198         file+="." ;
2199       }
2200       file+="root" ;
2201     }
2202     TString path = "PHOS/" + file  ;
2203     folder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject(path.Data())) ; 
2204     if (folder) { 
2205       if (name.IsNull())
2206         name = fSDigitsTitle ; 
2207       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2208     }
2209   }
2210   else if ( what.CompareTo("Digits") == 0 ){
2211     folder = dynamic_cast<TFolder *>(fDigitsFolder->FindObject("PHOS")) ; 
2212     if (folder) { 
2213       if (name.IsNull())
2214         name = fDigitsTitle ; 
2215       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2216     } 
2217   }
2218   else if ( what.CompareTo("EmcRecPoints") == 0 ) {
2219     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ; 
2220     if (folder) { 
2221       if (name.IsNull())
2222         name = fRecPointsTitle ; 
2223       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
2224     } 
2225   }
2226   else if ( what.CompareTo("CpvRecPoints") == 0 ) {
2227     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ; 
2228     if (folder) { 
2229       if (name.IsNull())
2230         name = fRecPointsTitle ; 
2231       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2232     }   
2233   }
2234   else if ( what.CompareTo("TrackSegments") == 0 ) {
2235     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/TrackSegments")) ; 
2236     if (folder) { 
2237       if (name.IsNull())
2238         name = fTrackSegmentsTitle ; 
2239       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ; 
2240     }   
2241   }
2242   else if ( what.CompareTo("RecParticles") == 0 ) {
2243     folder = dynamic_cast<TFolder *>(fRecoFolder->FindObject("PHOS/RecParticles")) ; 
2244    if (folder) { 
2245       if (name.IsNull())
2246         name = fRecParticlesTitle ; 
2247       phosO  = dynamic_cast<TObject *>(folder->FindObject(name)) ;
2248     }   
2249  }
2250   else if ( what.CompareTo("Alarms") == 0 ){ 
2251     if (name.IsNull() ) 
2252       phosO = dynamic_cast<TObject *>(fQAFolder->FindObject("PHOS")) ;  
2253     else {
2254       folder = dynamic_cast<TFolder *>(fQAFolder->FindObject("PHOS")) ; 
2255       if (!folder) 
2256         phosO = 0 ; 
2257       else 
2258         phosO = dynamic_cast<TObject *>(folder->FindObject(name)) ;  
2259     }
2260   }
2261   if (!phosO) {
2262     if(fDebug)
2263       Warning("ReturnO", "Object %s not found in PHOS", what.Data() ) ; 
2264     return 0 ;
2265   }
2266
2267   return phosO ;
2268 }
2269   
2270 //____________________________________________________________________________ 
2271 const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const 
2272 {
2273   // get the TTask named "what" from the folder
2274   // folders are named like //Folders/Tasks/what/PHOS/name
2275
2276   TString search(what) ; 
2277   if ( what.CompareTo("Clusterizer") == 0 ) 
2278     search = "Reconstructioner" ; 
2279   else if ( what.CompareTo("TrackSegmentMaker") == 0 ) 
2280     search = "Reconstructioner" ; 
2281   else if ( what.CompareTo("PID") == 0 ) 
2282     search = "Reconstructioner" ; 
2283   else if ( what.CompareTo("QATasks") == 0 ) 
2284     search = "QA" ; 
2285
2286   TTask * tasks = dynamic_cast<TTask*>(fTasksFolder->FindObject(search)) ; 
2287
2288   if (!tasks) {
2289     Error("ReturnT", "Task %s not found !", what.Data() ) ;  
2290     return 0 ; 
2291   }
2292
2293   TTask * phosT = dynamic_cast<TTask*>(tasks->GetListOfTasks()->FindObject("PHOS")) ; 
2294   if (!phosT) { 
2295      Error("ReturnT", "Task %s/PHOS not found !", what.Data() ) ;  
2296     return 0 ; 
2297   }
2298   
2299   TList * list = phosT->GetListOfTasks() ; 
2300  
2301   if (what.CompareTo("SDigitizer") == 0) {  
2302     if ( name.IsNull() )
2303       name =  fSDigitsTitle ; 
2304   } else  if (what.CompareTo("Digitizer") == 0){ 
2305     if ( name.IsNull() )
2306       name =  fDigitsTitle ;
2307   } else  if (what.CompareTo("Clusterizer") == 0){ 
2308     if ( name.IsNull() )
2309       name =  fRecPointsTitle ;
2310     name.Append(":clu") ;
2311   }
2312   else  if (what.CompareTo("TrackSegmentMaker") == 0){ 
2313     if ( name.IsNull() )
2314       name =  fTrackSegmentsTitle ;
2315     name.Append(":tsm") ;
2316   }
2317   else  if (what.CompareTo("PID") == 0){ 
2318     if ( name.IsNull() )
2319       name =  fRecParticlesTitle ;
2320     name.Append(":pid") ;
2321   }
2322   else  if (what.CompareTo("QATasks") == 0){ 
2323     if ( name.IsNull() )
2324       return phosT ;
2325   }
2326   
2327   TIter it(list) ;
2328   TTask * task = 0 ; 
2329   while((task = static_cast<TTask *>(it.Next()) )){
2330     TString taskname(task->GetName()) ;
2331     if(taskname.BeginsWith(name))
2332       return task ;
2333   }
2334   
2335   if(fDebug)
2336     Warning("ReturnT", "-> Task %s/PHOS/%s not found", search.Data(), name.Data() ) ; 
2337   return 0 ;
2338 }
2339
2340 //____________________________________________________________________________ 
2341 void AliPHOSGetter::RemoveTask(TString opt, TString name) const 
2342 {
2343   // remove a task from the folder
2344   // path is fTasksFolder/SDigitizer/PHOS/name
2345   
2346   TTask * task = 0 ; 
2347   TTask * phos = 0 ; 
2348   TList * lofTasks = 0 ; 
2349
2350   if (opt == "S") { // SDigitizer
2351     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
2352     if (!task) 
2353       return ; 
2354   }
2355   else if (opt == "D") { // Digitizer
2356     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
2357     if (!task) 
2358       return ; 
2359   }
2360   else if (opt == "C" || opt == "T" || opt == "P"  ) { // Clusterizer, TrackSegmentMaker, PID
2361     task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
2362     if (!task) 
2363       return ; 
2364   }
2365   else {
2366     Warning("RemoveTask", "Unknown option %s", opt.Data() ); 
2367     return ; 
2368   }
2369   phos =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2370   if (!phos)
2371     return ; 
2372   lofTasks = phos->GetListOfTasks() ;
2373   if (!lofTasks) 
2374     return ; 
2375   TObject * obj = lofTasks->FindObject(name) ; 
2376   if (obj) 
2377     lofTasks->Remove(obj) ;
2378    
2379 }
2380
2381 //____________________________________________________________________________ 
2382 void AliPHOSGetter::RemoveObjects(TString opt, TString name) const 
2383 {
2384   // remove SDigits from the folder
2385   // path is fSDigitsFolder/fHeaderFileName/name
2386
2387   TFolder * phos     = 0 ; 
2388   TFolder * phosmain = 0 ; 
2389
2390   if (opt == "H") { // Hits
2391     phos = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ;
2392     if (!phos) 
2393       return ;
2394     name = "Hits" ; 
2395   }
2396
2397   else if ( opt == "S") { // SDigits
2398     phosmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2399     if (!phosmain) 
2400       return ;
2401     phos = dynamic_cast<TFolder*>(phosmain->FindObject(fHeaderFile)) ;
2402     if (!phos) 
2403       return ;
2404   }
2405   
2406   else if (opt == "D") { // Digits
2407     phos = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
2408     if (!phos) 
2409       return ;
2410   }
2411
2412   else if (opt == "RE") { // EMCARecPoints
2413     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ;
2414     if (!phos) 
2415       return ;
2416   }
2417
2418   else if (opt == "RC") { // CPVRecPoints
2419     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ;
2420     if (!phos) 
2421       return ;
2422   }  
2423
2424   else if (opt == "T") { // TrackSegments
2425     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ;
2426     if (!phos) 
2427       return ;
2428   }
2429
2430   else if (opt == "P") { // RecParticles
2431     phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ;
2432     if (!phos) 
2433       return ;
2434   }
2435   
2436   else {
2437     Warning("RemoveObjects", "Unknown option %s", opt.Data() ) ; 
2438     return ; 
2439   }
2440   
2441   TObjArray * ar  = dynamic_cast<TObjArray*>(phos->FindObject(name)) ; 
2442   if (ar) { 
2443     phos->Remove(ar) ;
2444     ar->Delete() ; 
2445     delete ar ; 
2446   }
2447
2448   if (opt == "S") 
2449     phosmain->Remove(phos) ; 
2450   
2451 }
2452
2453 //____________________________________________________________________________ 
2454 void AliPHOSGetter::RemoveSDigits() const 
2455 {
2456   TFolder * phos= dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2457   if (!phos) 
2458     return ;
2459   
2460   phos->SetOwner() ; 
2461   phos->Clear() ; 
2462 }
2463
2464 //____________________________________________________________________________ 
2465 void AliPHOSGetter::CleanWhiteBoard(void){
2466
2467   TFolder * phosmain = 0 ; 
2468   TFolder * phos ;
2469   TObjArray * ar ;
2470   TList * lofTasks = 0 ; 
2471   TTask * task = 0 ; 
2472   TTask * phost = 0 ; 
2473   
2474   // Hits  
2475   phos = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ;
2476   if (phos){  
2477     TObjArray * ar  = dynamic_cast<TObjArray*>(phos->FindObject("Hits")) ; 
2478     if (ar) { 
2479       phos->Remove(ar) ;
2480       ar->Delete() ; 
2481       delete ar ; 
2482     }
2483   }
2484   
2485   // SDigits
2486   phosmain = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2487   if (phosmain){ 
2488     phos = dynamic_cast<TFolder*>(phosmain->FindObject(fHeaderFile)) ;
2489     if (phos) {
2490       ar  = dynamic_cast<TObjArray*>(phos->FindObject(fSDigitsTitle)) ; 
2491       if (ar) { 
2492         phos->Remove(ar) ;
2493         ar->Delete() ; 
2494         delete ar ; 
2495       }
2496     }
2497     phosmain->Remove(phos) ; 
2498   }
2499
2500   
2501   // Digits
2502   phos = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
2503   if (phos){ 
2504     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fDigitsTitle)) ; 
2505     if (ar) { 
2506       phos->Remove(ar) ;
2507       ar->Delete() ; 
2508       delete ar ; 
2509     }
2510   }
2511
2512
2513   // EMCARecPoints
2514   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/EMCARecPoints")) ;
2515   if (phos){ 
2516     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fRecPointsTitle)) ; 
2517     if (ar) { 
2518       phos->Remove(ar) ;
2519       ar->Delete() ; 
2520       delete ar ; 
2521     }
2522   }
2523
2524   
2525   // CPVRecPoints
2526   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/CPVRecPoints")) ;
2527   if (phos){ 
2528     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fRecPointsTitle)) ; 
2529     if (ar) { 
2530       phos->Remove(ar) ;
2531       ar->Delete() ; 
2532       delete ar ; 
2533     }
2534   }  
2535
2536   
2537   // TrackSegments
2538   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/TrackSegments")) ;
2539   if (phos) { 
2540     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fTrackSegmentsTitle)) ; 
2541     if (ar) { 
2542       phos->Remove(ar) ;
2543       ar->Delete() ; 
2544       delete ar ; 
2545     }
2546   }
2547   
2548
2549
2550   // RecParticles
2551   phos = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS/RecParticles")) ;
2552   if (phos){ 
2553     ar  = dynamic_cast<TObjArray*>(phos->FindObject(fRecParticlesTitle)) ; 
2554     if (ar) { 
2555       phos->Remove(ar) ;
2556       ar->Delete() ; 
2557       delete ar ; 
2558     }
2559   }
2560
2561
2562   //---- Now Tasks ----------- 
2563
2564   TObject * obj ;
2565   TString sdname(fSDigitsTitle);
2566   
2567   // Digitizer
2568   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Digitizer")) ;
2569   if (task){ 
2570     phost =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2571     if (phost){
2572       lofTasks = phost->GetListOfTasks() ;
2573       if (lofTasks){ 
2574         obj = lofTasks->FindObject(sdname.Data()) ; 
2575         if (obj) 
2576           lofTasks->Remove(obj) ;
2577       }
2578     }      
2579   }
2580   
2581
2582   sdname.Append(":") ;
2583   // Clusterizer, TrackSegmentMaker, PID
2584   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("Reconstructioner")) ;
2585   if (task){ 
2586     phost =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2587     if (phost){
2588       lofTasks = phost->GetListOfTasks() ;
2589       TIter next(lofTasks);
2590       while((obj=next())){ 
2591         TString oname(obj->GetName()) ;
2592         if (oname.BeginsWith(sdname)){ 
2593           lofTasks->Remove(obj) ;
2594         }
2595       }
2596     }  
2597   }
2598
2599
2600   // SDigitizer
2601   sdname.Append(fHeaderFile) ;
2602   task = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ;
2603   if (task) {
2604     phost =  dynamic_cast<TTask*>(task->GetListOfTasks()->FindObject("PHOS")) ;
2605     if (phost){
2606       lofTasks = phost->GetListOfTasks() ;
2607       if (lofTasks){ 
2608         obj = lofTasks->FindObject(sdname.Data()) ; 
2609         if (obj) 
2610           lofTasks->Remove(obj) ;
2611       }
2612     }
2613   }  
2614
2615 }
2616 //____________________________________________________________________________ 
2617 void AliPHOSGetter::SetTitle(const char * branchTitle ) 
2618 {
2619   fBranchTitle        = branchTitle ;
2620   fSDigitsTitle       = branchTitle ; 
2621   fDigitsTitle        = branchTitle ; 
2622   fRecPointsTitle     = branchTitle ; 
2623   fRecParticlesTitle  = branchTitle ; 
2624   fTrackSegmentsTitle = branchTitle ; 
2625   if(fToSplit){
2626     //First - extract full path if necessary
2627     TString sFileName(fHeaderFile) ;
2628     Ssiz_t islash = sFileName.Last('/') ;
2629     if(islash<sFileName.Length())
2630       sFileName.Remove(islash+1,sFileName.Length()) ;
2631     else
2632       sFileName="" ;
2633     //Now construct file names
2634     fSDigitsFileName       = sFileName ;
2635     fDigitsFileName        = sFileName ; 
2636     fRecPointsFileName     = sFileName ; 
2637     fRecParticlesFileName  = sFileName ; 
2638     fTrackSegmentsFileName = sFileName ; 
2639     fSDigitsFileName      += "PHOS.SDigits." ;
2640     fDigitsFileName       += "PHOS.Digits." ; 
2641     fRecPointsFileName    += "PHOS.RecData." ; 
2642     fTrackSegmentsFileName+= "PHOS.RecData." ; 
2643     fRecParticlesFileName += "PHOS.RecData." ; 
2644     if((strcmp(fBranchTitle.Data(),"Default")!=0)&&(strcmp(fBranchTitle.Data(),"")!=0)){
2645       fSDigitsFileName      += fBranchTitle ;
2646       fSDigitsFileName      += "." ;
2647       fDigitsFileName       += fBranchTitle ; 
2648       fDigitsFileName       += "." ; 
2649       fRecPointsFileName    += fBranchTitle ; 
2650       fRecPointsFileName    += "." ; 
2651       fRecParticlesFileName += fBranchTitle ; 
2652       fRecParticlesFileName += "." ; 
2653       fTrackSegmentsFileName+= fBranchTitle ; 
2654       fTrackSegmentsFileName+= "." ; 
2655     }
2656     fSDigitsFileName      += "root" ;
2657     fDigitsFileName       += "root" ; 
2658     fRecPointsFileName    += "root" ; 
2659     fRecParticlesFileName += "root" ; 
2660     fTrackSegmentsFileName+= "root" ; 
2661   }else{
2662     fSDigitsFileName       = fHeaderFile ;
2663
2664     fDigitsFileName        = "" ; 
2665     fRecPointsFileName     = "" ; 
2666     fRecParticlesFileName  = "" ; 
2667     fTrackSegmentsFileName = "" ; 
2668   }
2669   TFolder * phosFolder ; 
2670   phosFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("PHOS")) ; 
2671   if ( !phosFolder ) 
2672     phosFolder = fHitsFolder->AddFolder("PHOS", "Hits from PHOS") ; 
2673
2674   phosFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("PHOS")) ;
2675   if ( !phosFolder ) 
2676     phosFolder = fSDigitsFolder->AddFolder("PHOS", "SDigits from PHOS") ; 
2677
2678   //Make folder for SDigits
2679   fSDigitsFileName.ReplaceAll("/","_") ;
2680   phosFolder->AddFolder(fSDigitsFileName.Data(),"");
2681
2682   phosFolder  = dynamic_cast<TFolder*>(fDigitsFolder->FindObject("PHOS")) ;
2683   if ( !phosFolder ) 
2684     phosFolder = fDigitsFolder->AddFolder("PHOS", "Digits from PHOS") ;  
2685
2686   phosFolder  = dynamic_cast<TFolder*>(fRecoFolder->FindObject("PHOS")) ; 
2687   if ( !phosFolder )
2688     phosFolder = fRecoFolder->AddFolder("PHOS", "Reconstructed data from PHOS") ;  
2689   
2690 }
2691 //____________________________________________________________________________ 
2692 void AliPHOSGetter::CloseSplitFiles(void){
2693   TFile * file ;
2694   file = static_cast<TFile*>(gROOT->GetFile(fSDigitsFileName.Data() ) ) ;
2695   if(file)
2696     file->Close() ;
2697   file = static_cast<TFile*>(gROOT->GetFile(fDigitsFileName.Data() ) ) ;
2698   if(file)
2699     file->Close() ;
2700   file = static_cast<TFile*>(gROOT->GetFile(fRecPointsFileName.Data() ) ) ;
2701   if(file)
2702     file->Close() ;
2703   file = static_cast<TFile*>(gROOT->GetFile(fTrackSegmentsFileName.Data() ) ) ;
2704   if(file)
2705     file->Close() ;
2706   file = static_cast<TFile*>(gROOT->GetFile(fRecParticlesFileName.Data() ) ) ;
2707   if(file)
2708     file->Close() ;
2709
2710 }