git://git.uio.no / u / mrichter / AliRoot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
WARNINGs are put on cout instead of cerr
[u/mrichter/AliRoot.git] / PHOS / AliPHOSGetter.cxx
diff --git a/PHOS/AliPHOSGetter.cxx b/PHOS/AliPHOSGetter.cxx
index 1a8ef49280067847d950553f8ce6e994f1f368d4..6c65e88103acf79e9d540106f1fe4ddd9471a2ac 100644 (file)
--- a/PHOS/AliPHOSGetter.cxx
+++ b/PHOS/AliPHOSGetter.cxx
@@ -82,6 +82,7 @@ AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle )
   //Initialize  all lists
 
   fHeaderFile         = headerFile ; 
   //Initialize  all lists
 
   fHeaderFile         = headerFile ; 
+  fBranchTitle        = branchTitle ;
   fSDigitsTitle       = branchTitle ; 
   fDigitsTitle        = branchTitle ; 
   fRecPointsTitle     = branchTitle ; 
   fSDigitsTitle       = branchTitle ; 
   fDigitsTitle        = branchTitle ; 
   fRecPointsTitle     = branchTitle ; 
@@ -90,8 +91,8 @@ AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle )
 
   fPrimaries = new TObjArray(1) ;
 
 
   fPrimaries = new TObjArray(1) ;
 
-  if ( fHeaderFile != "aliroot" ) { // to call the getter without a file
-    
+  if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
+
     //open headers file
     TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ;
     
     //open headers file
     TFile * file = (TFile*) gROOT->GetFile(fHeaderFile.Data() ) ;
     
@@ -114,6 +115,31 @@ AliPHOSGetter::AliPHOSGetter(const char* headerFile, const char* branchTitle )
       }
     }
   }
       }
     }
   }
+  fDebug=0;
+}
+//____________________________________________________________________________ 
+AliPHOSGetter::~AliPHOSGetter(){
+  //Here we remove all TFolders and TTasks with current title and file name
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  if(aliceF){
+    //Hits:  the hierarchy is //YSALICE/WhiteBoard/Hits/PHOS/...
+    TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ; 
+    if(hitsF){
+      TObject * h = hitsF->FindObject("hits") ;
+      hitsF->Remove(h) ;
+    }
+    
+    //SDigits:  the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/...
+    TFolder * sdigitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ; 
+    if(sdigitsF){
+      TCollection* l = sdigitsF->GetListOfFolders() ;
+      TIter it(l) ;
+      TObject * sf ;
+      while((sf = it.Next()) )
+       sdigitsF->RecursiveRemove(sf) ;
+    }
+  }
 }
 //____________________________________________________________________________ 
 void AliPHOSGetter::CreateWhiteBoard() const
 }
 //____________________________________________________________________________ 
 void AliPHOSGetter::CreateWhiteBoard() const
@@ -121,11 +147,8 @@ void AliPHOSGetter::CreateWhiteBoard() const
   // Posts a few item to the white board (folders)
   
   // -- the geometry
   // Posts a few item to the white board (folders)
   
   // -- the geometry
-  Post(fHeaderFile, "G") ; 
+  if(!PostGeometry() ) abort() ; 
   
   
-  // -- the hits
-  Post(fHeaderFile, "H") ; 
-    
 }
 
 //____________________________________________________________________________ 
 }
 
 //____________________________________________________________________________ 
@@ -149,20 +172,18 @@ AliPHOSGetter * AliPHOSGetter::GetInstance(const char* headerFile,
   // Creates and returns the pointer of the unique instance
   // Must be called only when the environment has changed 
 
   // Creates and returns the pointer of the unique instance
   // Must be called only when the environment has changed 
 
-
-  if ( fgObjGetter )      // delete it if already exists
-    delete fgObjGetter ; 
-
+  if ( fgObjGetter )    
+    if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0) && 
+       (fgObjGetter->fHeaderFile.CompareTo(headerFile)==0))
+      return fgObjGetter ;
+    else
+      fgObjGetter->~AliPHOSGetter() ;  // delete it if already exists another version
+  
   fgObjGetter = new AliPHOSGetter(headerFile,branchTitle) ; 
   
   // Posts a few item to the white board (folders)
   fgObjGetter->CreateWhiteBoard() ;
   fgObjGetter = new AliPHOSGetter(headerFile,branchTitle) ; 
   
   // Posts a few item to the white board (folders)
   fgObjGetter->CreateWhiteBoard() ;
-
-  // Get the first event into the arrays posted on the white board
-  // branchTitle = 0, means simulation run and no event yet 
-  if (branchTitle) 
-    fgObjGetter->Event(0) ;
-
+    
   return fgObjGetter ; 
   
 }
   return fgObjGetter ; 
   
 }
@@ -185,347 +206,804 @@ AliPHOSGetter * AliPHOSGetter::GetInstance(const char* headerFile,
 }
 
 //____________________________________________________________________________ 
 }
 
 //____________________________________________________________________________ 
-void AliPHOSGetter::Post(const char * headerFile, const char * opt, const char * name, const Int_t event) const 
-{
-  // Adds a new folder for summable digits 
+Bool_t AliPHOSGetter::PostGeometry() const 
+{  //--------Geometry --------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/Geometry/PHOS/
+  TFolder * geomF  = (TFolder*)aliceF->FindObject("WhiteBoard/Geometry/PHOS") ; 
+  if ( !geomF ) {
+    cerr << "ERROR: AliPHOSGetter::Post G -> Folder WhiteBoard/Geometry/PHOS/" << " not found!" << endl;
+    return kFALSE ;
+  }    
+  else {
+    AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance(PHOS()->GetTitle(),"") ;  
+    geomF->Add((TObject*)geom) ; 
+  }
+  return kTRUE;   
+}
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostHits(void) const 
+{  //------- Hits ----------------------
+
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
+  TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ; 
+  if ( !hitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post H -> Folder WhiteBoard/Hits/PHOS/" << " not found!" << endl;
+    return kFALSE ;
+  }    
  
  
-  TString foldertitle ; 
-  if ( event >= 0 ) 
-    foldertitle += event ; 
-  else 
-    foldertitle = "" ; 
+  TObject * h = hitsF->FindObject("Hits") ;
+
+  if(!h){
+    TClonesArray *hits=  new TClonesArray("AliPHOSHit",1000) ;
+    hits->SetName("Hits") ;
+    hitsF->Add(hits) ; 
+  }
+ 
+  return kTRUE;
+} 
+//____________________________________________________________________________ 
+TClonesArray ** AliPHOSGetter::HitsRef(void) const 
+{  //------- Hits ----------------------
 
   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
 
   TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
+  TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ; 
+  if ( !hitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post H -> Folder WhiteBoard/Hits/PHOS/" << " not found!" << endl;
+    return 0;
+  }    
  
  
-  if ( strcmp(opt, "G") == 0 ) { // Geometry
-    // the hierarchy is //YSALICE/WhiteBoard/Geometry/PHOS/
-    AliPHOSGeometry * geom = AliPHOSGeometry::GetInstance(PHOS()->GetTitle(),"") ;  
-    TFolder * geomF  = (TFolder*)aliceF->FindObject("WhiteBoard/Geometry/PHOS") ; 
-    if ( !geomF ) {
-      cerr << "ERROR: AliPHOSGetter::Post G -> Folder WhiteBoard/Geometry/PHOS/" << " not found!" << endl;
-      abort() ; 
-    }    
-    else 
-      geomF->Add((TObject*)geom) ; 
-   
-  } else if ( strcmp(opt, "H") == 0 ) { // Hits
-    // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
-    TClonesArray * hits = new TClonesArray("AliPHOSHit",1000) ;
-    hits->SetName("Hits") ; 
-    TFolder * hitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Hits/PHOS") ; 
-    if ( !hitsF ) {
-      cerr << "ERROR: AliPHOSGetter::Post H -> Folder WhiteBoard/Hits/PHOS/" << " not found!" << endl;
-      abort() ; 
-    }    
-    else 
-      hitsF->Add(hits) ; 
-
-  } else if ( strcmp(opt, "S") == 0 ) { // summable digits
-    // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/headerFile/sdigitsname
-    // because you can have sdigits from several hit files for mixing
-    TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1000) ;
-    TString sdigitsName ; 
-    if (name) 
-      sdigitsName = name ;
-    else 
-      sdigitsName = "SDigits" ;        
-    sdigits->SetName( sdigitsName.Data() ) ; 
-    TFolder * sdigitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ;
-    TFolder * sdigitsF2 = 0 ; 
-    TString subdir(headerFile) ;
-    if ( !(sdigitsF2=(TFolder*)sdigitsF->FindObject(subdir)) ) 
-      sdigitsF2 = sdigitsF->AddFolder(subdir, foldertitle); 
-    else {
-      if ( sdigitsF2->FindObject( sdigitsName.Data() ) ) {
-       cerr <<"INFO: AliPHOSGetter::Post S -> Folder " << subdir << ", " << foldertitle
-            << " already exists!" << endl ;  
-       return ; 
-      }
-    }
-    if ( !sdigitsF2 ) {
-      cerr << "ERROR: AliPHOSGetter::Post S -> Folder WhiteBoard/SDigits/PHOS/" << subdir << " not created!" << endl;
-      abort() ; 
-    }
-    else 
-      sdigitsF2->Add(sdigits) ;
-
-  } else if ( strcmp(opt, "Ser") == 0 ) { // sdigizer
-    // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/sdigitsname
-    AliPHOSSDigitizer * sdigitizer = new AliPHOSSDigitizer() ; 
-    TString sdigitsName ; 
-    if (name) 
-      sdigitsName = name ;
-    else 
-      sdigitsName = "SDigitizer" ;
-    sdigitizer->SetName( sdigitsName.Data() ) ; 
-    TTask * sdigitsF  = (TTask*)aliceF->FindObject("tasks/SDigitizer") ; 
-    if ( !sdigitsF ) {
-      cerr << "ERROR: AliPHOSGetter::Post Ser -> Task tasks/SDigitizer" << " not found!" << endl;
-      abort() ; 
-    }        
-    TTask * phos = (TTask*)sdigitsF->GetListOfTasks()->FindObject("PHOS") ; 
-    if ( !phos )  {
-      cerr <<"ERROR: AliPHOSGetter::Post Ser -> tasks/SDigitizer/PHOS" << " not found!" << endl; 
-      abort() ; 
-    } else {
-      AliPHOSSDigitizer * phossd = (AliPHOSSDigitizer*)phos->GetListOfTasks()->FindObject(sdigitsName.Data()) ; 
-      if (phossd) { 
-       cout << "INFO: AliPHOSGetter::Post Ser -> Task " << sdigitsName.Data() << " already exists" << endl ; 
-       return ; 
-      } else 
-       phos->Add(sdigitizer) ;
-    } 
+  TObject * h = hitsF->FindObject("Hits") ;
+  if(!h)
+    return 0 ;
+  else
+    return (TClonesArray **) hitsF->GetListOfFolders()->GetObjectRef(h) ;
 
 
-  } else if ( strcmp(opt, "D") == 0 ) { // digits
-    // the hierarchy is //YSALICE/WhiteBoard/Digits/PHOS/digitsname
-    TClonesArray * digits  = new TClonesArray("AliPHOSDigit",20000) ;
-    TString digitsName ; 
-    if (name) 
-      digitsName = name ;
-    else 
-      digitsName = "Digits" ;  
-    digits->SetName( digitsName.Data() ) ; 
-    TFolder * digitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Digits/PHOS") ;
-    if ( !digitsF ) {
-      cerr << "ERROR: AliPHOSGetter::Post D -> Folder WhiteBoard/Digits/PHOS/" << " not found!" << endl;
-      abort() ; 
-    }    
-    digitsF->SetTitle(foldertitle) ; 
-    if ( digitsF->FindObject( digitsName.Data() ) ) {
-      cerr <<"INFO: AliPHOSGetter::Post D -> Object " << digitsName.Data() 
+}
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostSDigits(const char * name, const char * headerFile) const 
+{  //---------- SDigits -------------------------
+
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/headerFile/sdigitsname
+  // because you can have sdigits from several hit files for mixing
+
+  TFolder * sdigitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ;
+  TString subdir(headerFile) ;
+  TFolder * sdigitsF2 = (sdigitsF2=(TFolder*)sdigitsF->FindObject(subdir)) ; 
+  if ( !sdigitsF2 ) 
+    sdigitsF2 = sdigitsF->AddFolder(subdir, ""); 
+
+  TObject * sd  = sdigitsF2->FindObject(name ); 
+  if ( sd ) {
+    if (fDebug)
+      cerr <<"INFO: AliPHOSGetter::Post S -> Folder " << subdir 
           << " already exists!" << endl ;  
           << " already exists!" << endl ;  
-      return ; 
-    } 
-    else 
-      digitsF->Add(digits) ;  
-
-  } else if ( strcmp(opt, "Der") == 0 ) { // sdigizer
-    // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/digitsname
-    AliPHOSDigitizer * digitizer = new AliPHOSDigitizer() ; 
-    TString digitsName ; 
-    if (name) 
-      digitsName = name ;
-    else 
-      digitsName = "Digitizer" ;
-    digitizer->SetName( digitsName.Data() ) ; 
-    TTask * digitsF  = (TTask*)aliceF->FindObject("tasks/Digitizer") ; 
-    if ( !digitsF ) {
-      cerr << "ERROR: AliPHOSGetter::Post Der -> Task tasks/Digitizer" << " not found!" << endl;
-      abort() ; 
-    }        
-    TTask * phos = (TTask*)digitsF->GetListOfTasks()->FindObject("PHOS") ; 
-    if ( !phos )  {
-      cerr <<"ERROR: AliPHOSGetter::Post Der -> tasks/Digitizer/PHOS" << " not found!" << endl; 
-      abort() ; 
-    } else {
-      AliPHOSDigitizer * phosd = (AliPHOSDigitizer*)phos->GetListOfTasks()->FindObject(digitsName.Data()) ; 
-      if (phosd) { 
-       cout << "INFO: AliPHOSGetter::Post Der -> Task " << digitsName.Data() << " already exists" << endl ; 
-       return ; 
-      } else 
-       phos->Add(digitizer) ;
-    }
+  }else{
+    TClonesArray * sdigits = new TClonesArray("AliPHOSDigit",1000) ;
+    sdigits->SetName(name) ;
+    sdigitsF2->Add(sdigits) ;
+  }
+  
+  return kTRUE;
+} 
+//____________________________________________________________________________ 
+TClonesArray ** AliPHOSGetter::SDigitsRef(const char * name, const char * file) const 
+{  //------- Hits ----------------------
+
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/SDigits/PHOS/Hits
+  TFolder * sdisF  = (TFolder*)aliceF->FindObject("WhiteBoard/SDigits/PHOS") ; 
+  if ( !sdisF ) {
+    cerr << "ERROR: AliPHOSGetter::SDRef -> Folder WhiteBoard/SDigits/PHOS/" << " not found!" << endl;
+    return 0;
+  }    
+  TFolder * fileF ;
+  if(file)
+    fileF = (TFolder *) sdisF->FindObject(file) ;
+  else
+    fileF = (TFolder *) sdisF->FindObject(fHeaderFile) ;
+
+  if(!fileF)
+    abort() ;
+
+  TObject * dis = fileF->FindObject(name) ;
+  if(!dis)
+    return 0 ;
+  else
+    return (TClonesArray **) fileF->GetListOfFolders()->GetObjectRef(dis) ;
+
+}
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostSDigitizer(AliPHOSSDigitizer * sdigitizer) const 
+{  //---------- SDigitizer -------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/sdigitsname
+  TTask * sdigitsF  = (TTask*)aliceF->FindObject("tasks/SDigitizer") ; 
+  if ( !sdigitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Ser -> Task tasks/SDigitizer" << " not found!" << endl;
+    return kFALSE ;
+  }        
+  TTask * phos = (TTask*)sdigitsF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Ser -> tasks/SDigitizer/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  } 
+  AliPHOSSDigitizer * phossd  = (AliPHOSSDigitizer *) phos->GetListOfTasks()->FindObject( sdigitizer->GetName() ); 
+  if (phossd) { 
+    if (fDebug)
+      cout << "INFO: AliPHOSGetter::Post Ser -> Task " << sdigitizer->GetName() << " already exists" << endl ; 
+    phos->GetListOfTasks()->Remove(phossd) ;
+  }
+  phos->Add(sdigitizer) ;      
+  return kTRUE; 
+  
+}
+//____________________________________________________________________________ 
+AliPHOSSDigitizer ** AliPHOSGetter::SDigitizerRef(const char * name) const 
+{  
+
+  TString path("tasks/SDigitizer") ;
  
  
-  } else if ( strcmp(opt, "R") == 0 ) { // RecPoints
-    // the hierarchy is //YSALICE/WhiteBoard/RecPoints/PHOS/emc/recpointsname
-    //                  //YSALICE/WhiteBoard/RecPoints/PHOS/cpv/recpointsname
-    TObjArray * emcrp  = new TObjArray(100) ;
-    TObjArray * cpvrp  = new TObjArray(100) ;
-    TString recpointsName ; 
-    if (name) 
-      recpointsName = name ;
-    else       
-      recpointsName = "RecPoints" ;    
-    emcrp->SetName( recpointsName.Data() ) ; 
-    cpvrp->SetName( recpointsName.Data() ) ; 
-    TFolder * emcrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/emc") ; 
-    TFolder * cpvrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/cpv") ;
-    emcrpF->SetTitle(foldertitle) ; 
-    cpvrpF->SetTitle(foldertitle) ; 
-    if ( !emcrpF || !cpvrpF ) {
-      cerr << "ERROR: AliPHOSGetter::Post R -> Folder WhiteBoard/RecPoints/PHOS/emc(cpv)" << " not found!" << endl;
-      abort() ; 
-    }    
-    // TString title("PHOS Digits") ; 
-    if ( emcrpF->FindObject( recpointsName.Data() ) ||  cpvrpF->FindObject( recpointsName.Data() ) ) {
-      cerr <<"INFO: AliPHOSGetter::Post R -> Object " << recpointsName.Data() 
-          << " already exists!" << endl ;  
-      return ; 
-    } 
-    else {
-      emcrpF->Add(emcrp) ;  
-      cpvrpF->Add(cpvrp) ;
-    }  
+  TFolder * aliceF  = (TFolder*)gROOT ->FindObjectAny("YSAlice") ; 
+  TTask   * aliceT  = (TTask*)  aliceF->FindObject(path) ; 
 
 
-  } else if ( strcmp(opt, "Rer") == 0 ) { // clusterizer
-    // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
-    AliPHOSClusterizer * clusterizer; 
-    if ( strstr(name, "clu-v1") != 0 )   
-        clusterizer = new AliPHOSClusterizerv1() ;
-    else {
-      cerr << "ERROR: AliPHOSGetter::Post Rer -> " << name << " unknown clusterizer version" << endl ;  
-      abort() ; 
-    }
-    TString recpointsName ; 
-    if (name) 
-      recpointsName = name ;
-    else 
-      recpointsName = "Clusterizer" ;
-    clusterizer->SetName( recpointsName.Data() ) ; 
-    TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
-    if ( !reF ) {
-      cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
-      abort() ; 
-    }        
-    TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
-    if ( !phos )  {
-      cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
-      abort() ; 
-    } else {
-       AliPHOSClusterizer * phoscl = (AliPHOSClusterizer*)phos->GetListOfTasks()->FindObject(recpointsName.Data()) ; 
-      if (phoscl) { 
-       cout << "INFO: AliPHOSGetter::Post Rer -> Task " << recpointsName.Data() << " already exists" << endl ; 
-       return ; 
-      } else 
-       phos->Add(clusterizer) ;
-    }
+  if (!aliceT) {
+    cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;  
+    abort() ;
+  }
 
 
-  } else if ( strcmp(opt, "T") == 0 ) { //TrackSegments
-    // the hierarchy is //YSALICE/WhiteBoard/TrackSegments/PHOS/tracksegmentsname
-
-    TClonesArray * tracksegments  = new TClonesArray("AliPHOSTrackSegment", 200) ;
-    TString tracksegmentsName ; 
-    if (name) 
-      tracksegmentsName = name ;
-    else       
-      tracksegmentsName = "TrackSegments" ;    
-    tracksegments->SetName( tracksegmentsName.Data() ) ; 
-    TFolder * tracksegmentsF  = (TFolder*)aliceF->FindObject("WhiteBoard/TrackSegments/PHOS") ; 
-    tracksegmentsF->SetTitle(foldertitle) ;  
-    if ( !tracksegmentsF) {
-      cerr << "ERROR: AliPHOSGetter::Post T -> Folder WhiteBoard/TrackSegments/PHOS" << " not found!" << endl;
-      abort() ; 
-    }    
-    if ( tracksegmentsF->FindObject( tracksegmentsName.Data() ) ) {
-      cerr <<"INFO: AliPHOSGetter::Post T -> Object " << tracksegmentsName.Data() 
-          << " already exists!" << endl ;  
-      return ; 
-    } 
-    else 
-      tracksegmentsF->Add(tracksegments) ;  
-
-  } else if ( strcmp(opt, "Ter") == 0 ) { // TrackSegmentsMaker
-    // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/tracksegmentsname
-    AliPHOSTrackSegmentMaker * tracksegmentmaker ; 
-    if ( strstr(name, "tsm-v1") != 0 )   
-        tracksegmentmaker = new AliPHOSTrackSegmentMakerv1() ;
-    else {
-      cerr << "ERROR: AliPHOSGetter::Post Ter -> " << name << " unknown track segment maker version" << endl ;  
-      abort() ; 
+  TTask   * phosT   = (TTask*)  aliceT->GetListOfTasks()->FindObject("PHOS") ; 
+  if (!phosT) { 
+    cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;  
+    abort() ;
+  }
+  TList * l = phosT->GetListOfTasks() ; 
+
+  TTask * task = (TTask*)l->FindObject(name) ; 
+
+  return (AliPHOSSDigitizer **) l->GetObjectRef(task) ;
+
+}
+
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostSDigitizer(const char * name, const char * file) const 
+{  //---------- SDigitizer -------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/sdigitsname
+  TTask * sdigitsF  = (TTask*)aliceF->FindObject("tasks/SDigitizer") ; 
+  if ( !sdigitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Ser -> Task tasks/SDigitizer" << " not found!" << endl;
+    return kFALSE ;
+  }        
+  TTask * phos = (TTask*)sdigitsF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Ser -> tasks/SDigitizer/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  } 
+  TString sdname(name) ;
+  sdname.Append(":") ;
+  sdname.Append(file);
+  AliPHOSSDigitizer * phossd  = (AliPHOSSDigitizer *) phos->GetListOfTasks()->FindObject( sdname ); 
+  if (!phossd) {
+    phossd = new AliPHOSSDigitizer() ;  
+    //Note, we can not call constructor with parameters: it will call Getter and scrud up everething
+    phossd->SetName(sdname) ;
+    phossd->SetTitle(file) ;
+    phos->Add(phossd) ;        
+  }
+  return kTRUE; 
+  
+}
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostDigits(const char * name) const 
+{  //---------- Digits -------------------------
+
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/Digits/PHOS/digitsname
+  TFolder * digitsF  = (TFolder*)aliceF->FindObject("WhiteBoard/Digits/PHOS") ;
+  if ( !digitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post D -> Folder WhiteBoard/Digits/PHOS/" << " not found!" << endl;
+    return kFALSE ; 
+  }    
+  digitsF->SetTitle("") ; 
+  TObject*  dig = digitsF->FindObject( name ) ;
+  if ( !dig ) {
+    TClonesArray * digits = new TClonesArray("AliPHOSDigit",1000) ;
+    digits->SetName(name) ;
+    digitsF->Add(digits) ;  
+  }
+  return kTRUE; 
+}
+//____________________________________________________________________________ 
+TClonesArray ** AliPHOSGetter::DigitsRef(const char * name) const 
+{  
+
+  TFolder * digitsF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/Digits/PHOS") ; 
+  
+   if ( !digitsF ) {
+    cerr << "ERROR: AliPHOSGetter::DRef -> Folder WhiteBoard/Digits/PHOS/" << " not found!" << endl;
+    return 0;
+  }    
+
+  TObject * d = digitsF->FindObject(name) ;
+  if(!d)
+    return 0 ;
+  else
+    return (TClonesArray **) digitsF->GetListOfFolders()->GetObjectRef(d) ;
+
+}
+
+ 
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostDigitizer(AliPHOSDigitizer * digitizer) const 
+{  //---------- Digitizer -------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/digitsname
+  TTask * digitsF  = (TTask*)aliceF->FindObject("tasks/Digitizer") ; 
+  if ( !digitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Der -> Task tasks/Digitizer" << " not found!" << endl;
+    return kFALSE ; 
+  }        
+  TTask * phos = (TTask*)digitsF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Der -> tasks/Digitizer/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  } else {
+    AliPHOSDigitizer * phosd = (AliPHOSDigitizer*)phos->GetListOfTasks()->FindObject(digitizer->GetName()) ; 
+    if (phosd) { 
+      phosd->Delete() ;
+      phos->GetListOfTasks()->Remove(phosd) ;
     }
     }
-    TString tracksegmentsName ; 
-    if (name) 
-      tracksegmentsName = name ;
-    else 
-      tracksegmentsName = "TrackSegmentMaker" ;
-    tracksegmentmaker->SetName( tracksegmentsName.Data() ) ; 
-    TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
-    if ( !reF ) {
-      cerr << "ERROR: AliPHOSGetter::Post Ter -> Task tasks/Reconstructioner" << " not found!" << endl;
-      abort() ; 
-    }        
-    TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
-    if ( !phos )  {
-      cerr <<"ERROR: AliPHOSGetter::Post Ter -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
-      abort() ; 
-    } else {
-       AliPHOSTrackSegmentMaker * phosts = (AliPHOSTrackSegmentMaker*)phos->GetListOfTasks()->FindObject(tracksegmentsName.Data()) ; 
-      if (phosts) { 
-       cout << "INFO: AliPHOSGetter::Post Ter -> Task " << tracksegmentsName.Data() << " already exists" << endl ; 
-       return ; 
-      } else 
-       phos->Add(tracksegmentmaker) ;
+    phos->Add((TTask*)digitizer) ; 
+    return kTRUE; 
+  } 
+} 
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostDigitizer(const char * name) const 
+{  //---------- Digitizer -------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Digitizer/PHOS/digitsname
+  TTask * digitsF  = (TTask*)aliceF->FindObject("tasks/Digitizer") ; 
+  if ( !digitsF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Der -> Task tasks/Digitizer" << " not found!" << endl;
+    return kFALSE ; 
+  }        
+  TTask * phos = (TTask*)digitsF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Der -> tasks/Digitizer/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  }
+
+  AliPHOSDigitizer * phosd = (AliPHOSDigitizer*)phos->GetListOfTasks()->FindObject(name) ; 
+  if (!phosd) { 
+    phosd = new AliPHOSDigitizer() ;
+    phosd->SetName(fDigitsTitle) ;
+    phosd->SetTitle(fHeaderFile) ;
+    phos->Add(phosd) ;
+  }
+  return kTRUE;  
+}
+
+//____________________________________________________________________________ 
+AliPHOSDigitizer ** AliPHOSGetter::DigitizerRef(const char * name) const 
+{  
+
+  TString path("tasks/Digitizer") ;
+ 
+  TFolder * aliceF  = (TFolder*)gROOT ->FindObjectAny("YSAlice") ; 
+  TTask   * aliceT  = (TTask*)  aliceF->FindObject(path) ; 
+
+  if (!aliceT) {
+    cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;  
+    abort() ;
+  }
+
+  TTask   * phosT   = (TTask*)  aliceT->GetListOfTasks()->FindObject("PHOS") ; 
+  if (!phosT) { 
+    cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;  
+    abort() ;
+  }
+  TList * l = phosT->GetListOfTasks() ; 
+
+  TTask * task = (TTask*)l->FindObject(name) ; 
+
+  return (AliPHOSDigitizer **) l->GetObjectRef(task) ;
+
+}
+ 
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostRecPoints(const char * name) const 
+{ // -------------- RecPoints -------------------------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/RecPoints/PHOS/emc/recpointsname  
+  TFolder * emcrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/emc") ; 
+  
+  if ( !emcrpF ) {
+    cerr << "ERROR: AliPHOSGetter::Post R -> Folder WhiteBoard/RecPoints/PHOS/emc" 
+        << " not found!" << endl;
+    return kFALSE ; 
+  }    
+  emcrpF->SetTitle("") ;
+  TObject * erp = emcrpF->FindObject(name ) ;
+  if ( !erp )   {
+    TObjArray * emcrp = new TObjArray(100) ;
+    emcrp->SetName(name) ;
+    emcrpF->Add(emcrp) ;  
+  }
+
+  TFolder * cpvrpF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecPoints/PHOS/cpv") ; 
+  
+  if ( !cpvrpF ) {
+    cerr << "ERROR: AliPHOSGetter::Post R -> Folder WhiteBoard/RecPoints/PHOS/cpv" 
+        << " not found!" << endl;
+    return kFALSE ; 
+  }    
+  cpvrpF->SetTitle("") ; 
+  TObject * crp =  cpvrpF->FindObject( name ) ;
+  if ( !crp )   {
+    TObjArray * cpvrp = new TObjArray(100) ;
+    cpvrp->SetName(name) ;
+    cpvrpF->Add(cpvrp) ;  
+  }
+  return kTRUE; 
+}
+
+//____________________________________________________________________________ 
+TObjArray ** AliPHOSGetter::EmcRecPointsRef(const char * name) const 
+{ // -------------- RecPoints -------------------------------------------
+  
+  TFolder * emcrpF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/RecPoints/PHOS/emc") ; 
+   
+  if ( !emcrpF ) {
+    cerr << "ERROR: AliPHOSGetter::EmcRecPointsRef -> Folder WhiteBoard/RecPoints/PHOS/emc" 
+        << " not found!" << endl;
+    return 0 ; 
+  }    
+
+  TObject * erp = emcrpF->FindObject(name ) ;
+  if ( !erp )   {
+    return 0 ;
+  }
+  return (TObjArray **) emcrpF->GetListOfFolders()->GetObjectRef(erp) ;
+
+} 
+//____________________________________________________________________________ 
+TObjArray ** AliPHOSGetter::CpvRecPointsRef(const char * name) const 
+{ // -------------- RecPoints -------------------------------------------
+  
+  TFolder * cpvrpF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/RecPoints/PHOS/cpv") ; 
+   
+  if ( !cpvrpF ) {
+    cerr << "ERROR: AliPHOSGetter::CpvRecPointsRef -> Folder WhiteBoard/RecPoints/PHOS/cpv" 
+        << " not found!" << endl;
+    return 0 ; 
+  }    
+  TObject * crp = cpvrpF->FindObject(name ) ;
+  if ( !crp )   {
+    return 0 ;
+  }
+  return (TObjArray **) cpvrpF->GetListOfFolders()->GetObjectRef(crp) ;
+
+} 
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostClusterizer(AliPHOSClusterizer * clu) const 
+{ // ------------------ AliPHOSClusterizer ------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  } 
+       
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  } else {
+    AliPHOSClusterizer * phoscl = (AliPHOSClusterizer*)phos->GetListOfTasks()->FindObject(clu->GetName()) ; 
+    if (phoscl) { 
+      if (fDebug)
+       cout << "INFO: AliPHOSGetter::Post Rer -> Task " << clu->GetName() << " already exists" << endl ; 
+      phos->GetListOfTasks()->Remove(phoscl) ;
     }
     }
+    phos->Add(clu) ;      
+    return kTRUE; 
+  } 
+}
+
+//____________________________________________________________________________ 
+AliPHOSClusterizer ** AliPHOSGetter::ClusterizerRef(const char * name) const 
+{ // ------------------ AliPHOSClusterizer ------------------------
   
   
-  } else if ( strcmp(opt, "P") == 0 ) { // RecParticles
-    // the hierarchy is //YSALICE/WhiteBoard/RecParticles/PHOS/recparticlesname
-
-    TClonesArray * recparticles  = new TClonesArray("AliPHOSRecParticle", 200) ;
-    TString recparticlesName ; 
-    if (name) 
-      recparticlesName = name ;
-    else       
-      recparticlesName = "RecParticles" ;      
-    recparticles->SetName( recparticlesName.Data() ) ; 
-    TFolder * recparticlesF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecParticles/PHOS") ; 
-    recparticlesF->SetTitle(foldertitle) ;  
-    if ( !recparticlesF) {
-      cerr << "ERROR: AliPHOSGetter::Post P -> Folder WhiteBoard/RecParticles/PHOS" << " not found!" << endl;
-      abort() ; 
-    }    
-    if ( recparticlesF->FindObject( recparticlesName.Data() ) ) {
-      cerr <<"INFO: AliPHOSGetter::Post P -> Object " << recparticlesName.Data() 
-          << " already exists!" << endl ;  
-      return ; 
-    } 
-    else 
-      recparticlesF->Add(recparticles) ;  
-
-  } else if ( strcmp(opt, "Per") == 0 ) { // PID Maker
-    // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recparticlesname
-    AliPHOSPID * pid ; 
-    if ( strstr(name, "pid-v1") != 0 )   
-        pid = new AliPHOSPIDv1() ;
-    else {
-      cerr << "ERROR: AliPHOSGetter::Post Per -> " << name << " unknown PID maker version" << endl ;  
-      abort() ; 
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  } 
+       
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return 0 ; 
+  }
+  TList * l = phos->GetListOfTasks() ; 
+  TIter it(l) ;
+  TTask * task ;
+  TTask * clu = 0 ;
+  TString cluname(name) ;
+  cluname+=":clu-" ;
+  while((task = (TTask *)it.Next()) ){
+    TString taskname(task->GetName()) ;
+    if(taskname.BeginsWith(cluname)){
+      clu = task ;
+      break ;
     }
     }
-    TString recparticlesName ; 
-    if (name) 
-      recparticlesName = name ;
-    else 
-      recparticlesName = "PID" ;
-    pid->SetName( recparticlesName.Data() ) ; 
-    TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
-    if ( !reF ) {
-      cerr << "ERROR: AliPHOSGetter::Post Per -> Task tasks/Reconstructioner" << " not found!" << endl;
-      abort() ; 
-    }        
-    TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
-    if ( !phos )  {
-      cerr <<"ERROR: AliPHOSGetter::Post Per -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
-      abort() ; 
-    } else {
-       AliPHOSPID * phospid = (AliPHOSPID*)phos->GetListOfTasks()->FindObject(recparticlesName.Data()) ; 
-      if (phospid) { 
-       cout << "INFO: AliPHOSGetter::Post Per -> Task " << recparticlesName.Data() << " already exists" << endl ; 
-       return ; 
-      } else 
-       phos->Add(pid) ;
+  }
+
+  if(clu) 
+    return (AliPHOSClusterizer **) l->GetObjectRef(clu) ;
+  else
+    return 0 ;
+}
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostClusterizer(const char * name) const 
+{ // ------------------ AliPHOSClusterizer ------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recpointsname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Rer -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  } 
+       
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Rer -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  } 
+  AliPHOSClusterizer * phoscl = new AliPHOSClusterizerv1() ;
+  TString clun(name) ;
+  clun+=":clu-v1" ;
+  phoscl->SetName(clun) ;
+  phos->Add(phoscl) ;
+  return kTRUE; 
+  
+}
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostTrackSegments(const char * name) const 
+{ // ---------------TrackSegments -----------------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  // the hierarchy is //YSALICE/WhiteBoard/TrackSegments/PHOS/tracksegmentsname  
+  TFolder * tracksegmentsF  = (TFolder*)aliceF->FindObject("WhiteBoard/TrackSegments/PHOS") ; 
+  tracksegmentsF->SetTitle("") ;  
+  if ( !tracksegmentsF) {
+    cerr << "ERROR: AliPHOSGetter::Post T -> Folder WhiteBoard/TrackSegments/PHOS" << " not found!" << endl;
+    return kFALSE ; 
+  }    
+  TObject * tss =  tracksegmentsF->FindObject(name  ) ;
+  if (!tss) {
+    TClonesArray * ts = new TClonesArray("AliPHOSTrackSegment",100) ;
+    ts->SetName(name) ;
+    tracksegmentsF->Add(ts) ;  
+  }
+  return kTRUE; 
+} 
+
+//____________________________________________________________________________ 
+TClonesArray ** AliPHOSGetter::TrackSegmentsRef(const char * name) const 
+{ // ---------------TrackSegments -----------------------------------
+  
+  TFolder * phosF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/TrackSegments/PHOS") ; 
+  if ( !phosF) {
+    cerr << "ERROR: AliPHOSGetter::TrackSegmentsRef -> Folder WhiteBoard/TrackSegments/PHOS" << " not found!" << endl;
+    return 0 ; 
+  }    
+  
+  TObject * tss =  phosF->FindObject(name) ;
+  if (!tss) {
+    return 0 ;  
+  }
+  return (TClonesArray **) phosF->GetListOfFolders()->GetObjectRef(tss) ;
+} 
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostTrackSegmentMaker(AliPHOSTrackSegmentMaker * tsmaker) const 
+{ //------------Track Segment Maker ------------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/tracksegmentsname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Ter -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  }        
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Ter -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  }
+  
+  AliPHOSTrackSegmentMaker * phosts = 
+    (AliPHOSTrackSegmentMaker*)phos->GetListOfTasks()->FindObject(tsmaker->GetName()) ; 
+  if (phosts) { 
+    phosts->Delete() ;
+    phos->GetListOfTasks()->Remove(phosts) ;
+  }
+  phos->Add(tsmaker) ;      
+  return kTRUE; 
+  
+} 
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostTrackSegmentMaker(const char * name) const 
+{ //------------Track Segment Maker ------------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/tracksegmentsname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Ter -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  }        
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Ter -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  } 
+  AliPHOSTrackSegmentMaker * phosts = 
+    (AliPHOSTrackSegmentMaker*)phos->GetListOfTasks()->FindObject(name) ; 
+  if (!phosts) { 
+    phosts = new AliPHOSTrackSegmentMakerv1() ;
+    TString tsn(name);
+    tsn+=":tsm-v1" ;
+    phosts->SetName(tsn) ;
+    phos->Add(phosts) ;      
+  }
+  return kTRUE; 
+  
+} 
+//____________________________________________________________________________ 
+AliPHOSTrackSegmentMaker ** AliPHOSGetter::TSMakerRef(const char * name) const 
+{ //------------Track Segment Maker ------------------------------
+  
+  TTask * reF  = (TTask*)gROOT->FindObjectAny("YSAlice/tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::TrackSegmentMakerRef -> Task tasks/Reconstructioner" 
+        << " not found!" << endl;
+    return 0 ; 
+  }        
+  
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;   
+  if ( !phos ) {
+    cerr << "ERROR: AliPHOSGetter::TrackSegmentMakerRef -> Task tasks/Reconstructioner/PHOS" 
+        << " not found!" << endl;
+    return 0 ; 
+  }        
+  TList * l = phos->GetListOfTasks() ; 
+  TIter it(l) ;
+  TTask * task ;
+  TTask * tsm = 0 ;
+  TString tsmname(name) ;
+  tsmname+=":tsm-" ;
+  while((task = (TTask *)it.Next()) ){
+    TString taskname(task->GetName()) ;
+    if(taskname.BeginsWith(tsmname)){
+      tsm = task ;
+      break ;
     }
     }
+  }
+  
+  if(tsm) 
+    return (AliPHOSTrackSegmentMaker **) l->GetObjectRef(tsm) ;
+  else
+    return 0 ;
+  
+} 
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostRecParticles(const char * name) const 
+{  // -------------------- RecParticles ------------------------
+  
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // the hierarchy is //YSALICE/WhiteBoard/RecParticles/PHOS/recparticlesname  
+  TFolder * recparticlesF  = (TFolder*)aliceF->FindObject("WhiteBoard/RecParticles/PHOS") ; 
+  recparticlesF->SetTitle("") ;  
+  if ( !recparticlesF) {
+    cerr << "ERROR: AliPHOSGetter::Post P -> Folder WhiteBoard/RecParticles/PHOS" << " not found!" << endl;
+    return kFALSE ; 
+  }    
+  TObject * rps = recparticlesF->FindObject( name )  ;
+  if ( !rps ) {
+    TClonesArray * rp = new TClonesArray("AliPHOSRecParticle",100) ;
+    rp->SetName(name) ;    
+    recparticlesF->Add(rp) ;  
+  }
+  return kTRUE; 
+} 
+//____________________________________________________________________________ 
+TClonesArray ** AliPHOSGetter::RecParticlesRef(const char * name) const 
+{ // ---------------TrackSegments -----------------------------------
+  
+  TFolder * tsF  = (TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/RecParticles/PHOS") ; 
+  if ( !tsF) {
+    cerr << "ERROR: AliPHOSGetter::RecParticlesRef -> Folder WhiteBoard/RecParticles/PHOS" << " not found!" << endl;
+    return 0 ; 
+  }    
+  TObject * tss =  tsF->FindObject(name  ) ;
+  if (!tss) {
+    return 0 ;  
+  }
+  return (TClonesArray **) tsF->GetListOfFolders()->GetObjectRef(tss) ;
+}
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostPID(AliPHOSPID * pid) const 
+{     
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // ------------AliPHOS PID -----------------------------
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recparticlesname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Per -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  }        
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Per -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
   } 
   } 
-  else if ( strcmp(opt, "QA") == 0 ) { // Alarms
-    // the hierarchy is //YSALICE/WhiteBoard/Alarms/PHOS/
-
-    TFolder * alarmsF  = new TFolder() ;
-    TString alarmsName ; 
-    if (name) 
-      alarmsName = name ;
-    else       
-      alarmsName = "Alarm with no name" ;      
-    alarmsF->SetName( alarmsName.Data() ) ; 
-    alarmsF->SetTitle(foldertitle) ;  
-    TFolder * qaaF  = (TFolder*)aliceF->FindObject("WhiteBoard/QAAlarms") ; 
-    if ( !qaaF) {
-      cerr << "ERROR: AliPHOSGetter::Post QA -> Folder WhiteBoard/QAAlarms/" << " not found!" << endl;
-      return ; 
-    }    
-    if ( qaaF->FindObject( alarmsName.Data() ) ) 
-      qaaF->RecursiveRemove(  qaaF->FindObject( alarmsName.Data() ) ) ; 
-    
-    qaaF->Add(alarmsF) ;  
+  AliPHOSPID * phospid = (AliPHOSPID*)phos->GetListOfTasks()->FindObject(pid->GetName()) ; 
+  if (phospid) { 
+    if (fDebug)
+      cout << "INFO: AliPHOSGetter::Post Per -> Task " << pid->GetName()
+          << " already exists" << endl ; 
+    phos->GetListOfTasks()->Remove(phospid) ;
+  }
+  
+  phos->Add(pid) ;      
+  return kTRUE; 
+} 
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostPID(const char * name) const 
+{     
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // ------------AliPHOS PID -----------------------------
+  // the hierarchy is //YSALICE/tasks/Reconstructionner/PHOS/recparticlesname
+  TTask * reF  = (TTask*)aliceF->FindObject("tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::Post Per -> Task tasks/Reconstructioner" << " not found!" << endl;
+    return kFALSE ; 
+  }        
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ; 
+  if ( !phos )  {
+    cerr <<"ERROR: AliPHOSGetter::Post Per -> tasks/Reconstructioner/PHOS" << " not found!" << endl; 
+    return kFALSE ; 
+  }
 
 
+  TList * l = phos->GetListOfTasks() ;   
+  TIter it(l) ;
+  TString pidname(name) ;
+  pidname+=":pid" ; 
+  TTask * task ;
+  while((task = (TTask *)it.Next()) ){
+    TString taskname(task->GetName()) ;
+    if(taskname.BeginsWith(pidname))
+      return kTRUE ;
   }
   }
+ 
+  AliPHOSPIDv1 * phospid = new AliPHOSPIDv1() ;
+  pidname+="-v1" ;
+  phospid->SetName(pidname) ;
+  phos->Add(phospid) ;      
+  
+  return kTRUE; 
+} 
+//____________________________________________________________________________ 
+AliPHOSPID ** AliPHOSGetter::PIDRef(const char * name) const 
+{ //------------PID ------------------------------
+
+  TTask * reF  = (TTask*)gROOT->FindObjectAny("YSAlice/tasks/Reconstructioner") ; 
+  if ( !reF ) {
+    cerr << "ERROR: AliPHOSGetter::PIDRef -> Task tasks/Reconstructioner" 
+        << " not found!" << endl;
+    return 0 ; 
+  }        
+  
+  TTask * phos = (TTask*)reF->GetListOfTasks()->FindObject("PHOS") ;   
+  
+  if ( !phos ) {
+    cerr << "ERROR: AliPHOSGetter::PIDRef -> Task tasks/Reconstructioner/PHOS" 
+        << " not found!" << endl;
+    return 0 ; 
+  }        
+  TList * l = phos->GetListOfTasks() ; 
+  TIter it(l) ;
+  TTask * task ;
+  TTask * pid = 0 ;
+  TString pidname(name) ;
+  pidname+=":pid-" ;
+  while((task = (TTask *)it.Next()) ){
+    TString taskname(task->GetName()) ;
+    if(taskname.BeginsWith(pidname)){
+      pid = task ;
+      break ;
+    }
+  }
+  
+  if(pid) 
+    return (AliPHOSPID **) l->GetObjectRef(pid) ;
+  else
+    return 0 ;
+  
+} 
+
+//____________________________________________________________________________ 
+Bool_t AliPHOSGetter::PostQA( const char * name) const 
+{     
+  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
+  
+  // ------------------ QA ---------------------------------
+  // the hierarchy is //YSALICE/WhiteBoard/Alarms/PHOS/
+  
+  TFolder * alarmsF  = new TFolder() ;
+  TString alarmsName ; 
+  if (name) 
+    alarmsName = name ;
+  else       
+    alarmsName = "Alarm with no name" ;        
+  alarmsF->SetName( alarmsName.Data() ) ; 
+  alarmsF->SetTitle("") ;  
+  TFolder * qaaF  = (TFolder*)aliceF->FindObject("WhiteBoard/QAAlarms") ; 
+  if ( !qaaF) {
+    cerr << "ERROR: AliPHOSGetter::Post QA -> Folder WhiteBoard/QAAlarms/" << " not found!" << endl;
+    return kFALSE; 
+  }    
+  if ( qaaF->FindObject( alarmsName.Data() ) ) 
+    qaaF->RecursiveRemove(  qaaF->FindObject( alarmsName.Data() ) ) ; 
+  
+  qaaF->Add(alarmsF) ;  
+  
+  return kTRUE;
 }
 
 //____________________________________________________________________________ 
 }
 
 //____________________________________________________________________________ 
@@ -577,26 +1055,24 @@ void AliPHOSGetter::ReadTreeD()
   }
 
   if ( !phosfound || !digitizerfound ) {
   }
 
   if ( !phosfound || !digitizerfound ) {
-    cerr << "WARNING: AliPHOSGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " << fDigitsTitle << endl ;
+    cout << "WARNING: AliPHOSGetter::ReadTreeD -> Cannot find Digits and/or Digitizer with name " 
+        << fDigitsTitle << endl ;
     return ; 
   }   
  
     return ; 
   }   
  
-
- // Post the Digits
-  Post(fHeaderFile, "D", fDigitsTitle) ; 
+  //read digits
+  if(!Digits(fDigitsTitle) ) 
+    PostDigits(fDigitsTitle);
+  digitsbranch->SetAddress(DigitsRef(fDigitsTitle)) ;
+  digitsbranch->GetEntry(0) ;
   
   
-   // Post the Digitizer
-  Post(fHeaderFile, "Der", fDigitsTitle) ; 
-
-  TClonesArray * digits = Digits(fDigitsTitle) ; 
-  digits->Clear() ; 
-  digitsbranch   ->SetAddress(&digits) ;
-
-  AliPHOSDigitizer * digitizer = Digitizer(fDigitsTitle) ;
-  digitizerbranch->SetAddress(&digitizer) ;
-
-  digitsbranch   ->GetEntry(0) ;
+  
+  // read  the Digitizer
+  if(!Digitizer(fDigitsTitle))
+    PostDigitizer(fDigitsTitle) ;
+  digitizerbranch->SetAddress(DigitizerRef(fDigitsTitle)) ;
   digitizerbranch->GetEntry(0) ;
   digitizerbranch->GetEntry(0) ;
+ 
   
 }
 
   
 }
 
@@ -610,17 +1086,42 @@ void AliPHOSGetter::ReadTreeH()
     return ;
   }
   
     return ;
   }
   
-  TBranch * hitsbranch = (TBranch*)gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS") ;
+  TBranch * hitsbranch = (TBranch*)gAlice->TreeH()->GetBranch("PHOS") ;
   if ( !hitsbranch ) {
   if ( !hitsbranch ) {
-    cerr << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ; 
-  } else {
-    TClonesArray * hits = Hits() ; 
-    hits->Clear() ; 
-    hitsbranch->SetAddress(&hits) ;
-    hitsbranch->GetEntry(0) ;
+    cout << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ; 
+    return ;
   }
   }
+  if(!Hits())
+    PostHits() ;
+
+  hitsbranch->SetAddress(HitsRef()) ;
+
+  hitsbranch->GetEntry(0) ;
+
 }
 
 }
 
+//____________________________________________________________________________ 
+void AliPHOSGetter::Track(Int_t itrack)
+{
+  // Read the first entry of PHOS branch in hit tree gAlice->TreeH()
+
+  if(gAlice->TreeH()== 0){
+    cerr <<   "ERROR: AliPHOSGetter::ReadTreeH: -> Cannot read TreeH " << endl ;
+    return ;
+  }
+  
+  TBranch * hitsbranch = (TBranch*)gAlice->TreeH()->GetListOfBranches()->FindObject("PHOS") ;
+  if ( !hitsbranch ) {
+    cout << "WARNING:  AliPHOSGetter::ReadTreeH -> Cannot find branch PHOS" << endl ; 
+    return ;
+  }  
+  if(!Hits())
+    PostHits() ;
+  hitsbranch->SetAddress(HitsRef()) ;
+  hitsbranch->GetEntry(itrack) ;
+
+
+}
 //____________________________________________________________________________ 
 void AliPHOSGetter::ReadTreeQA()
 {
 //____________________________________________________________________________ 
 void AliPHOSGetter::ReadTreeQA()
 {
@@ -634,12 +1135,12 @@ void AliPHOSGetter::ReadTreeQA()
   
   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ; 
   if (!qabranch) { 
   
   TBranch * qabranch = PHOS()->TreeQA()->GetBranch("PHOS") ; 
   if (!qabranch) { 
-    cerr << "WARNING: AliPHOSGetter::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
+    cout << "WARNING: AliPHOSGetter::ReadTreeQA -> Cannot find QA Alarms for PHOS" << endl ;
     return ; 
   }   
     return ; 
   }   
-
- // Post the QA Alarms
-  Post(fHeaderFile, "QA", "PHOS") ; 
+  
+  // Post the QA Alarms
+  PostQA("PHOS") ; 
   TFolder * alarmsF = Alarms() ; 
   alarmsF->Clear() ; 
   qabranch->SetAddress(&alarmsF) ;
   TFolder * alarmsF = Alarms() ; 
   alarmsF->Clear() ; 
   qabranch->SetAddress(&alarmsF) ;
@@ -654,8 +1155,9 @@ void AliPHOSGetter::ReadTreeR()
 
   if(gAlice->TreeR()== 0){
     cout <<   "ERROR: AliPHOSGetter::ReadTreeR: can not read TreeR " << endl ;
 
   if(gAlice->TreeR()== 0){
     cout <<   "ERROR: AliPHOSGetter::ReadTreeR: can not read TreeR " << endl ;
-   return ;
+    return ;
   }
   }
+  
   // RecPoints 
   TObjArray * lob = (TObjArray*)gAlice->TreeR()->GetListOfBranches() ;
   TIter next(lob) ; 
   // RecPoints 
   TObjArray * lob = (TObjArray*)gAlice->TreeR()->GetListOfBranches() ;
   TIter next(lob) ; 
@@ -665,197 +1167,264 @@ void AliPHOSGetter::ReadTreeR()
   TBranch * clusterizerbranch = 0 ; 
   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ; 
   
   TBranch * clusterizerbranch = 0 ; 
   Bool_t phosemcrpfound = kFALSE, phoscpvrpfound = kFALSE, clusterizerfound = kFALSE ; 
   
-  while ( (branch = (TBranch*)next()) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) ) {
-    if ( (strcmp(branch->GetName(), "PHOSEmcRP")==0) && (strcmp(branch->GetTitle(), fRecPointsTitle)==0) ) {
-      emcbranch = branch ; 
-      phosemcrpfound = kTRUE ;
-    }
-    else if ( (strcmp(branch->GetName(), "PHOSCpvRP")==0) && (strcmp(branch->GetTitle(), fRecPointsTitle)==0) ) {
-      cpvbranch = branch ; 
-      phoscpvrpfound = kTRUE ;
-    }
-    else if ( (strcmp(branch->GetName(), "AliPHOSClusterizer")==0) && (strcmp(branch->GetTitle(), fRecPointsTitle)==0) ) {
-      clusterizerbranch = branch ; 
-      clusterizerfound = kTRUE ; 
+  while ( (branch = (TBranch*)next()) && (!phosemcrpfound || !phoscpvrpfound || !clusterizerfound) ) 
+    if(strcmp(branch->GetTitle(), fRecPointsTitle)==0) {
+      if ( strcmp(branch->GetName(), "PHOSEmcRP")==0) {
+       emcbranch = branch ; 
+       phosemcrpfound = kTRUE ;
+      }
+      else if ( strcmp(branch->GetName(), "PHOSCpvRP")==0) {
+       cpvbranch = branch ; 
+       phoscpvrpfound = kTRUE ;
+      }
+      else if(strcmp(branch->GetName(), "AliPHOSClusterizer")==0){
+       clusterizerbranch = branch ; 
+       clusterizerfound = kTRUE ; 
+      }
     }
     }
-  }
 
 
-  if ( !phosemcrpfound || !phoscpvrpfound || !clusterizerfound ) {
-    cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecPoints and/or Clusterizer with name " << fRecPointsTitle << endl ;
+  if ( !phosemcrpfound ) {
+    cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find EmcRecPoints with title " 
+        << fRecPointsTitle << endl ;
     return ; 
   }   
     return ; 
   }   
- 
- // Post the RecPoints
-  Post(fHeaderFile, "R", fRecPointsTitle) ; 
-
-  // Post the Clusterizer
-  //  Need the version first
-  AliPHOSClusterizer * clusterizer = 0 ; 
-  clusterizerbranch->SetAddress(&clusterizer) ;
-  clusterizerbranch->GetEntry(0) ;
-  TString clusterizerName(fRecPointsTitle) ; 
-  clusterizerName.Append(clusterizer->Version()) ; 
-  delete clusterizer ;
-  Post(fHeaderFile, "Rer", clusterizerName) ; 
-
-  TObjArray * emcRecPoints = EmcRecPoints(fRecPointsTitle) ;
-  emcRecPoints->Clear() ; 
-  emcbranch->SetAddress(&emcRecPoints) ;
-
-  TObjArray * cpvRecPoints = CpvRecPoints(fRecPointsTitle) ;
-  cpvRecPoints->Clear() ; 
-  cpvbranch->SetAddress(&cpvRecPoints) ;
-
-  clusterizer = Clusterizer(clusterizerName) ;
-  clusterizerbranch->SetAddress(&clusterizer) ;
-
-  emcbranch        ->GetEntry(0) ;
-  cpvbranch        ->GetEntry(0) ;
+  if ( !phoscpvrpfound ) {
+    cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find CpvRecPoints with title " 
+        << fRecPointsTitle << endl ;
+    return ; 
+  }   
+  if ( !clusterizerfound ) {
+    cout << "WARNING: AliPHOSGetter::ReadTreeR -> Can not find Clusterizer with title " 
+        << fRecPointsTitle << endl ;
+    return ; 
+  }   
+  
+  // Read and Post the RecPoints
+  if(!EmcRecPoints(fRecPointsTitle) )
+    PostRecPoints(fRecPointsTitle) ;
+  emcbranch->SetAddress(EmcRecPointsRef(fRecPointsTitle)) ;
+  emcbranch->GetEntry(0) ;
+
+  cpvbranch->SetAddress(CpvRecPointsRef(fRecPointsTitle)) ;
+  cpvbranch->GetEntry(0) ;
+  
+  if(!Clusterizer(fRecPointsTitle) )
+    PostClusterizer(fRecPointsTitle) ;
+  clusterizerbranch->SetAddress(ClusterizerRef(fRecPointsTitle)) ;
   clusterizerbranch->GetEntry(0) ;
  
   clusterizerbranch->GetEntry(0) ;
  
-  // TrackSegments
+  
+  //------------------- TrackSegments ---------------------
   next.Reset() ; 
   TBranch * tsbranch = 0 ; 
   TBranch * tsmakerbranch = 0 ; 
   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ; 
   next.Reset() ; 
   TBranch * tsbranch = 0 ; 
   TBranch * tsmakerbranch = 0 ; 
   Bool_t phostsfound = kFALSE, tsmakerfound = kFALSE ; 
-  
-  while ( (branch = (TBranch*)next()) && (!phostsfound || !tsmakerfound) ) {
-    if ( (strcmp(branch->GetName(), "PHOSTS")==0) && (strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0) ) {
-      tsbranch = branch ; 
-      phostsfound = kTRUE ;
-    }
-    else if ( (strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) && (strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0) ) {
-      tsmakerbranch = branch ; 
-      tsmakerfound  = kTRUE ; 
+    
+  while ( (branch = (TBranch*)next()) && (!phostsfound || !tsmakerfound) ) 
+    if(strcmp(branch->GetTitle(), fTrackSegmentsTitle)==0)  {
+      if ( strcmp(branch->GetName(), "PHOSTS")==0){
+       tsbranch = branch ; 
+       phostsfound = kTRUE ;
+      }
+      else if(strcmp(branch->GetName(), "AliPHOSTrackSegmentMaker")==0) {
+       tsmakerbranch = branch ; 
+       tsmakerfound  = kTRUE ; 
+      }
     }
     }
-  }
-
+  
   if ( !phostsfound || !tsmakerfound ) {
   if ( !phostsfound || !tsmakerfound ) {
-    cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name " << fTrackSegmentsTitle << endl ;
+    cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find TrackSegments and/or TrackSegmentMaker with name "
+        << fTrackSegmentsTitle << endl ;
     return ; 
   } 
     return ; 
   } 
-
- // Post the TrackSegments
-  Post(fHeaderFile, "T", fTrackSegmentsTitle) ; 
-
-  // Post the TrackSegment Maker
-  //  Need the version first
-  AliPHOSTrackSegmentMaker * tsmaker = 0 ; 
-  tsmakerbranch->SetAddress(&tsmaker) ;
+  
+  // Read and Post the TrackSegments
+  if(!TrackSegments(fTrackSegmentsTitle))
+    PostTrackSegments(fTrackSegmentsTitle) ;
+  tsbranch->SetAddress(TrackSegmentsRef(fTrackSegmentsTitle)) ;
+  tsbranch->GetEntry(0) ;
+  
+  // Read and Post the TrackSegment Maker
+  if(!TrackSegmentMaker(fTrackSegmentsTitle))
+    PostTrackSegmentMaker(fTrackSegmentsTitle) ;
+  tsmakerbranch->SetAddress(TSMakerRef(fTrackSegmentsTitle)) ;
   tsmakerbranch->GetEntry(0) ;
   tsmakerbranch->GetEntry(0) ;
-  TString tsmakerName(fTrackSegmentsTitle) ; 
-  tsmakerName.Append(tsmaker->Version()) ; 
-  delete tsmaker ;
-  Post(fHeaderFile, "Ter", tsmakerName) ; 
-
-  TClonesArray * tracksegments = TrackSegments(fTrackSegmentsTitle) ;
-  tracksegments->Clear() ; 
-  tsbranch->SetAddress(&tracksegments) ;
- 
-  tsmaker = TrackSegmentMaker(tsmakerName) ; 
-  tsmakerbranch->SetAddress(&tsmaker) ;
-
-  tsmakerbranch    ->GetEntry(0) ;
-  tsbranch         ->GetEntry(0) ;
-   
-  // RecParticles
+  
+  
+  //------------ RecParticles ----------------------------
   next.Reset() ; 
   TBranch * rpabranch = 0 ; 
   TBranch * pidbranch = 0 ; 
   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ; 
   
   next.Reset() ; 
   TBranch * rpabranch = 0 ; 
   TBranch * pidbranch = 0 ; 
   Bool_t phosrpafound = kFALSE, pidfound = kFALSE ; 
   
-  while ( (branch = (TBranch*)next()) && (!phosrpafound || !pidfound) ) {
-    if ( (strcmp(branch->GetName(), "PHOSRP")==0) && (strcmp(branch->GetTitle(), fRecParticlesTitle)==0) ) {
-      rpabranch = branch ; 
-      phosrpafound = kTRUE ;
-    }
-    else if ( (strcmp(branch->GetName(), "AliPHOSPID")==0) && (strcmp(branch->GetTitle(), fRecParticlesTitle)==0) ) {
-      pidbranch = branch ; 
-      pidfound  = kTRUE ; 
+  while ( (branch = (TBranch*)next()) && (!phosrpafound || !pidfound) ) 
+    if(strcmp(branch->GetTitle(), fRecParticlesTitle)==0) {   
+      if ( strcmp(branch->GetName(), "PHOSRP")==0) {   
+       rpabranch = branch ; 
+       phosrpafound = kTRUE ;
+      }
+      else if (strcmp(branch->GetName(), "AliPHOSPID")==0) {
+       pidbranch = branch ; 
+       pidfound  = kTRUE ; 
+      }
     }
     }
-  }
-
+  
   if ( !phosrpafound || !pidfound ) {
   if ( !phosrpafound || !pidfound ) {
-    cerr << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name " << fRecParticlesTitle << endl ;
+    cout << "WARNING: AliPHOSGetter::ReadTreeR -> Cannot find RecParticles and/or PID with name " 
+        << fRecParticlesTitle << endl ;
     return ; 
   } 
     return ; 
   } 
-
-  // Post the RecParticles
-  Post(fHeaderFile, "P", fRecParticlesTitle) ; 
-
-  // Post the PID
-  //  Need the version first
-  AliPHOSPID * pid = 0 ; 
-  pidbranch->SetAddress(&pid) ;
+  
+  // Read and Post the RecParticles
+  if(!RecParticles(fRecParticlesTitle))
+    PostRecParticles(fRecParticlesTitle) ;
+  rpabranch->SetAddress(RecParticlesRef(fRecParticlesTitle)) ;
+  rpabranch->GetEntry(0) ;
+  
+  // Read and Post the PID
+  if(!PID(fRecParticlesTitle))
+    PostPID(fRecParticlesTitle) ;
+  pidbranch->SetAddress(PIDRef(fRecParticlesTitle)) ;
   pidbranch->GetEntry(0) ;
   pidbranch->GetEntry(0) ;
-  TString pidName(fRecParticlesTitle) ; 
-  pidName.Append(pid->Version()) ; 
-  delete pid ;
-
-  Post(fHeaderFile, "Per", pidName) ; 
-
-  TClonesArray * recParticles = RecParticles(fRecParticlesTitle) ; 
-  recParticles->Clear() ; 
-  rpabranch->SetAddress(&recParticles) ;
-
-  pid = PID(pidName) ; 
-  pidbranch->SetAddress(&pid) ;
   
   
-  pidbranch        ->GetEntry(0) ;
-  rpabranch        ->GetEntry(0) ;
   
 }
 
 //____________________________________________________________________________ 
   
 }
 
 //____________________________________________________________________________ 
-void AliPHOSGetter::ReadTreeS()
+void AliPHOSGetter::ReadTreeS(Int_t event)
 {
   // Read the summable digits tree gAlice->TreeS()  
 {
   // Read the summable digits tree gAlice->TreeS()  
-
-  if(gAlice->TreeS()== 0){
-    cerr <<   "ERROR: AliPHOSGetter::ReadTreeS -> Cannot find TreeS " << endl ;
-    return ;
+  
+  // loop over all opened files and read their SDigits to the White Board
+  TFolder * phosF = (TFolder *)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS") ;
+  TCollection * folderslist = phosF->GetListOfFolders() ; 
+  
+  //Add current file to list if it is not there yet
+  if ( (fHeaderFile != "aliroot") && ( !folderslist->Contains(fHeaderFile) ) ){
+    phosF->AddFolder(fHeaderFile, ""); 
+    folderslist = phosF->GetListOfFolders() ;
   }
   
   }
   
-  TObjArray * lob = (TObjArray*)gAlice->TreeS()->GetListOfBranches() ;
+  TIter next(folderslist) ; 
+  TFolder * folder = 0 ; 
+  TFile * file; 
+  TTree * treeS = 0;
+  while ( (folder = (TFolder*)next()) ) {
+    if(fHeaderFile.CompareTo(folder->GetName()) == 0 ) 
+      treeS=gAlice->TreeS() ;
+    else{
+      file = (TFile*)gROOT->GetFile(folder->GetName()); 
+      file->cd() ;
+      
+      // Get SDigits Tree header from file
+      TString treeName("TreeS") ;
+      treeName += event ; 
+      treeS = (TTree*)gDirectory->Get(treeName.Data());
+    }
+    if(treeS==0){
+      cerr << "ERROR: AliPHOSGetter::ReadTreeS There is no SDigit Tree" << endl;
+      return ;
+    }
+    
+    //set address of the SDigits and SDigitizer
+    TBranch   * sdigitsBranch    = 0;
+    TBranch   * sdigitizerBranch = 0;
+    TBranch   * branch           = 0 ;  
+    TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
+    TIter next(lob) ; 
+    Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
+    
+    while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
+      if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
+       phosfound = kTRUE ;
+       sdigitsBranch = branch ; 
+      }
+      
+      else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
+       sdigitizerfound = kTRUE ; 
+       sdigitizerBranch = branch ;
+      }
+    }
+    if ( !phosfound || !sdigitizerfound ) {
+      cout << "WARNING: AliPHOSDigitizer::ReadSDigits -> Digits and/or Digitizer branch with name " << GetName() 
+          << " not found" << endl ;
+      return ; 
+    }   
+    
+    if ( !folder->FindObject(fSDigitsTitle) )  
+      PostSDigits(fSDigitsTitle,folder->GetName()) ;
+    sdigitsBranch->SetAddress(SDigitsRef(fSDigitsTitle,folder->GetName())) ;
+    sdigitsBranch->GetEntry(0) ;
+    
+    TString sdname(fSDigitsTitle) ;
+    sdname+=":" ;
+    sdname+=folder->GetName() ;
+    if(!SDigitizer(sdname) ) 
+      PostSDigitizer(fSDigitsTitle,folder->GetName()) ;
+    sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
+    sdigitizerBranch->GetEntry(0) ;
+    
+  }    
+  
+  // After SDigits have been read from all files, return to the first one
+  
+  next.Reset();
+  folder = (TFolder*)next();
+  if(folder){
+    file   = (TFile*)gROOT->GetFile(folder->GetName()); 
+    file   ->cd() ;
+  }
+  
+}
+//____________________________________________________________________________ 
+void AliPHOSGetter::ReadTreeS(TTree * treeS, Int_t input)
+{  // Read the summable digits fron treeS()  
+
+  TString filename("mergefile") ;
+  filename+= input ;
+  TFolder * phosF =(TFolder*)gROOT->FindObjectAny("YSAlice/WhiteBoard/SDigits/PHOS")  ;   
+  TFolder * folder=(TFolder*)phosF->FindObject(filename) ;
+  //set address of the SDigits and SDigitizer
+  TBranch   * sdigitsBranch    = 0;
+  TBranch   * sdigitizerBranch = 0;
+  TBranch   * branch           = 0 ;  
+  TObjArray * lob = (TObjArray*)treeS->GetListOfBranches() ;
   TIter next(lob) ; 
   TIter next(lob) ; 
-  TBranch * branch = 0 ; 
-  TBranch * sdigitsbranch = 0 ; 
-  TBranch * sdigitizerbranch = 0 ; 
   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
   
   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
   Bool_t phosfound = kFALSE, sdigitizerfound = kFALSE ; 
   
   while ( (branch = (TBranch*)next()) && (!phosfound || !sdigitizerfound) ) {
-    if ( (strcmp(branch->GetName(), "PHOS")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
-      sdigitsbranch = branch ; 
+    if ( strcmp(branch->GetName(), "PHOS")==0) {
       phosfound = kTRUE ;
       phosfound = kTRUE ;
+      sdigitsBranch = branch ; 
     }
     }
-    else if ( (strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) && (strcmp(branch->GetTitle(), fSDigitsTitle)==0) ) {
-      sdigitizerbranch = branch ; 
+    
+    else if ( strcmp(branch->GetName(), "AliPHOSSDigitizer")==0) {
       sdigitizerfound = kTRUE ; 
       sdigitizerfound = kTRUE ; 
+      sdigitizerBranch = branch ;
     }
   }
     }
   }
-
   if ( !phosfound || !sdigitizerfound ) {
   if ( !phosfound || !sdigitizerfound ) {
-    cerr << "WARNING: AliPHOSGetter::ReadTreeS -> Cannot find SDigits and/or SDigitizer with name " << fSDigitsTitle << endl ;
+    cout << "WARNING: AliPHOSGetter::ReadTreeS -> Digits and/or Digitizer branch not found" << endl ;
     return ; 
   }   
     return ; 
   }   
-
-  // -- the SDigits 
-  Post(fHeaderFile, "S", fSDigitsTitle) ; 
-
-  // Post the SDigitizer
-  Post(fHeaderFile, "Ser", fSDigitsTitle) ; 
   
   
-  TClonesArray * sdigits = SDigits(fSDigitsTitle) ; 
-  sdigits->Clear() ; 
-  sdigitsbranch->SetAddress(&sdigits) ;
+  if (!folder || !(folder->FindObject(sdigitsBranch->GetTitle()) ) )
+    PostSDigits(sdigitsBranch->GetTitle(),filename) ;
 
 
-  AliPHOSSDigitizer * sdigitizer = SDigitizer(fSDigitsTitle) ;
-  sdigitizerbranch->SetAddress(&sdigitizer) ;
+  sdigitsBranch->SetAddress(SDigitsRef(sdigitsBranch->GetTitle(),filename)) ;
+  
+  TString sdname(sdigitsBranch->GetTitle()) ;
+  sdname+=":" ;
+  sdname+=filename ;
+  if(!SDigitizer(sdigitsBranch->GetTitle()) )
+    PostSDigitizer(sdigitsBranch->GetTitle(),filename) ;
+  sdigitizerBranch->SetAddress(SDigitizerRef(sdname)) ;
+  
+  sdigitsBranch->GetEntry(0) ;
+  sdigitizerBranch->GetEntry(0) ;
+  
+}    
 
 
-  sdigitsbranch->GetEvent(0) ;
-  sdigitizerbranch->GetEvent(0) ;
-    
-}
 
 //____________________________________________________________________________ 
 void AliPHOSGetter::ReadPrimaries()
 
 //____________________________________________________________________________ 
 void AliPHOSGetter::ReadPrimaries()
@@ -934,23 +1503,35 @@ void AliPHOSGetter::ReadPrimaries()
   return ;
 }
 //____________________________________________________________________________ 
   return ;
 }
 //____________________________________________________________________________ 
-void AliPHOSGetter::Event(Int_t event)
+void AliPHOSGetter::Event(Int_t event, const char* opt)
 {
   // Reads the content of all Tree's S, D and R
   
   if ( event > gAlice->TreeE()->GetEntries() ) {
 {
   // Reads the content of all Tree's S, D and R
   
   if ( event > gAlice->TreeE()->GetEntries() ) {
-    cerr << "ERROR: AliPHOSGetter::Event -> There are only " << gAlice->TreeE()->GetEntries() << " events in this file" << endl ; 
+    cerr << "ERROR: AliPHOSGetter::Event -> There are only " 
+        << gAlice->TreeE()->GetEntries() << " events in this file" << endl ; 
     return ;
   }
   
   gAlice->GetEvent(event) ;
     return ;
   }
   
   gAlice->GetEvent(event) ;
+
+  if(strstr(opt,"H") )
+    ReadTreeH() ;
   
   
-  ReadTreeH() ;
-  ReadTreeS() ;
-  ReadTreeD() ;
-  ReadTreeR() ;
-  ReadTreeQA() ;
-  ReadPrimaries() ;
+  if(strstr(opt,"S") )
+    ReadTreeS(event) ;
+
+  if( strstr(opt,"D") )
+    ReadTreeD() ;
+
+  if( strstr(opt,"R") )
+    ReadTreeR() ;
+
+  if( strstr(opt,"Q") )
+    ReadTreeQA() ;
+
+  if( strstr(opt,"P") )
+    ReadPrimaries() ;
 
 }
 
 
 }
 
@@ -1042,8 +1623,9 @@ const TObject * AliPHOSGetter::ReturnO(TString what, TString name, TString file)
   path.Prepend("YSAlice/") ;
   TObject * phosO  = (TObject*)gROOT->FindObjectAny(path) ; 
   if (!phosO) {
   path.Prepend("YSAlice/") ;
   TObject * phosO  = (TObject*)gROOT->FindObjectAny(path) ; 
   if (!phosO) {
-    cerr << "ERROR : AliPHOSGetter::ReturnO -> Object " << path << " not found!" << endl ; 
-    abort() ;
+    if(fDebug)
+      cerr << "ERROR : AliPHOSGetter::ReturnO -> Object " << path << " not found!" << endl ; 
+    return 0 ;
   }
   return phosO ;
 }
   }
   return phosO ;
 }
@@ -1069,15 +1651,15 @@ const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const
   else if ( what.CompareTo("QATasks") == 0 ) 
     path += "/QA" ; 
 
   else if ( what.CompareTo("QATasks") == 0 ) 
     path += "/QA" ; 
 
-  TFolder * aliceF  = (TFolder*)gROOT->FindObjectAny("YSAlice") ; 
-  TTask * aliceT  = (TTask*)aliceF->FindObject(path) ; 
+  TFolder * aliceF  = (TFolder*)gROOT ->FindObjectAny("YSAlice") ; 
+  TTask   * aliceT  = (TTask*)  aliceF->FindObject(path) ; 
 
   if (!aliceT) {
     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;  
     abort() ;
   }
 
 
   if (!aliceT) {
     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << " not found!" << endl ;  
     abort() ;
   }
 
-  TTask * phosT = (TTask*)aliceT->GetListOfTasks()->FindObject("PHOS") ; 
+  TTask   * phosT   = (TTask*)  aliceT->GetListOfTasks()->FindObject("PHOS") ; 
   if (!phosT) { 
     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;  
     abort() ;
   if (!phosT) { 
     cerr << "ERROR: AliPHOSGetter::ReturnT -> Task " << path << "/PHOS not found!" << endl ;  
     abort() ;
@@ -1093,24 +1675,32 @@ const TTask * AliPHOSGetter::ReturnT(TString what, TString name) const
   } else  if (what.CompareTo("Clusterizer") == 0){ 
     if ( name.IsNull() )
       name =  fRecPointsTitle ;
   } else  if (what.CompareTo("Clusterizer") == 0){ 
     if ( name.IsNull() )
       name =  fRecPointsTitle ;
+    name.Append(":clu") ;
   }
   else  if (what.CompareTo("TrackSegmentMaker") == 0){ 
     if ( name.IsNull() )
       name =  fTrackSegmentsTitle ;
   }
   else  if (what.CompareTo("TrackSegmentMaker") == 0){ 
     if ( name.IsNull() )
       name =  fTrackSegmentsTitle ;
+    name.Append(":tsm") ;
   }
   else  if (what.CompareTo("PID") == 0){ 
     if ( name.IsNull() )
       name =  fRecParticlesTitle ;
   }
   else  if (what.CompareTo("PID") == 0){ 
     if ( name.IsNull() )
       name =  fRecParticlesTitle ;
+    name.Append(":pid") ;
   }
   }
-    else  if (what.CompareTo("QATasks") == 0){ 
+  else  if (what.CompareTo("QATasks") == 0){ 
     if ( name.IsNull() )
       return phosT ;
   }
     if ( name.IsNull() )
       return phosT ;
   }
-
-  TTask * task = (TTask*)l->FindObject(name) ; 
-
-  if (!task)
-    cout << "WARNING: AliPHOSGetter::ReturnT -> Task " << path << "/" << name << " not found!" << endl ; 
   
   
-  return task ;
+  TIter it(l) ;
+  TTask * task = 0 ; 
+  while((task = (TTask *)it.Next()) ){
+    TString taskname(task->GetName()) ;
+    if(taskname.BeginsWith(name))
+      return task ;
+  }
+  
+  if(fDebug)
+    cout << "WARNING: AliPHOSGetter::ReturnT -> Task " << path << "/" << name << " not found!" << endl ; 
+  return 0 ;
 }
 }