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